# detect tgt_isa
case "$gcctarget" in
+ armv6*)
+ tgt_isa=armv6
+ ;;
+ armv7*)
+ tgt_isa=armv7
+ ;;
+ armv5te*)
+ tgt_isa=armv5te
+ ;;
*x86_64*|*amd64*)
tgt_isa=x86_64
;;
# Almost every platform uses pthreads.
if enabled multithread; then
case ${toolchain} in
- *-win*);;
+ *-win*-vs*);;
*-android-gcc);;
*) check_header pthread.h && add_extralibs -lpthread
esac
# Can only build shared libs on a subset of platforms. Doing this check
# here rather than at option parse time because the target auto-detect
# magic happens after the command line has been parsed.
- enabled linux || die "--enable-shared only supported on ELF for now"
+ if ! enabled linux; then
+ if enabled gnu; then
+ echo "--enable-shared is only supported on ELF; assuming this is OK"
+ else
+ die "--enable-shared only supported on ELF for now"
+ fi
+ fi
fi
if [ -z "$CC" ]; then
echo "Bypassing toolchain for environment detection."
unsigned char size = 8; /* size in bytes to output */
/* mask to compare for byte size */
- uint64_t minVal = 0xff;
+ int64_t minVal = 0xff;
for (size = 1; size < 8; size ++)
{
/* TODO: it's not clear from the spec whether the nul terminator
* should be serialized too. For now we omit the null terminator.
*/
- Ebml_Write(glob, str, size);
+ Ebml_Write(glob, str, (unsigned long)size);
}
void Ebml_WriteUTF8(EbmlGlobal *glob, const wchar_t *wstr)
const uint64_t size = strlen;
Ebml_WriteLen(glob, size);
- Ebml_Write(glob, wstr, size);
+ Ebml_Write(glob, wstr, (unsigned long)size);
}
void Ebml_WriteID(EbmlGlobal *glob, unsigned long class_id)
obj_int_extract.vcproj: $(SRC_PATH_BARE)/build/make/obj_int_extract.c
@cp $(SRC_PATH_BARE)/build/x86-msvs/obj_int_extract.bat .
@echo " [CREATE] $@"
- $(SRC_PATH_BARE)/build/make/gen_msvs_proj.sh \
+ $(qexec)$(SRC_PATH_BARE)/build/make/gen_msvs_proj.sh \
--exe \
--target=$(TOOLCHAIN) \
--name=obj_int_extract \
vpx.def: $(call enabled,CODEC_EXPORTS)
@echo " [CREATE] $@"
- $(SRC_PATH_BARE)/build/make/gen_msvs_def.sh\
+ $(qexec)$(SRC_PATH_BARE)/build/make/gen_msvs_def.sh\
--name=vpx\
--out=$@ $^
CLEAN-OBJS += vpx.def
vpx.vcproj: $(CODEC_SRCS) vpx.def
@echo " [CREATE] $@"
- $(SRC_PATH_BARE)/build/make/gen_msvs_proj.sh \
+ $(qexec)$(SRC_PATH_BARE)/build/make/gen_msvs_proj.sh \
--lib \
--target=$(TOOLCHAIN) \
$(if $(CONFIG_STATIC_MSVCRT),--static-crt) \
$(qexec)echo 'Version: $(VERSION_MAJOR).$(VERSION_MINOR).$(VERSION_PATCH)' >> $@
$(qexec)echo 'Requires:' >> $@
$(qexec)echo 'Conflicts:' >> $@
- $(qexec)echo 'Libs: -L$${libdir} -lvpx -lm' >> $@
+ $(qexec)echo 'Libs: -L$${libdir} -lvpx' >> $@
+ $(qexec)echo 'Libs.private: -lm -lpthread' >> $@
$(qexec)echo 'Cflags: -I$${includedir}' >> $@
INSTALL-LIBS-yes += $(LIBSUBDIR)/pkgconfig/vpx.pc
INSTALL_MAPS += $(LIBSUBDIR)/pkgconfig/%.pc %.pc
LIBVPX_TEST_DATA=$(addprefix $(LIBVPX_TEST_DATA_PATH)/,\
$(call enabled,LIBVPX_TEST_DATA))
libvpx_test_data_url=http://downloads.webmproject.org/test_data/libvpx/$(1)
-BINS-yes += $(LIBVPX_TEST_BINS)
$(LIBVPX_TEST_DATA):
@echo " [DOWNLOAD] $@"
gtest.vcproj: $(SRC_PATH_BARE)/third_party/googletest/src/src/gtest-all.cc
@echo " [CREATE] $@"
- $(SRC_PATH_BARE)/build/make/gen_msvs_proj.sh \
+ $(qexec)$(SRC_PATH_BARE)/build/make/gen_msvs_proj.sh \
--lib \
--target=$(TOOLCHAIN) \
$(if $(CONFIG_STATIC_MSVCRT),--static-crt) \
test_libvpx.vcproj: $(LIBVPX_TEST_SRCS)
@echo " [CREATE] $@"
- $(SRC_PATH_BARE)/build/make/gen_msvs_proj.sh \
+ $(qexec)$(SRC_PATH_BARE)/build/make/gen_msvs_proj.sh \
--exe \
--target=$(TOOLCHAIN) \
--name=test_libvpx \
$(LIBVPX_TEST_OBJS) $(LIBVPX_TEST_OBJS:.o=.d): CXXFLAGS += -I$(SRC_PATH_BARE)/third_party/googletest/src
$(LIBVPX_TEST_OBJS) $(LIBVPX_TEST_OBJS:.o=.d): CXXFLAGS += -I$(SRC_PATH_BARE)/third_party/googletest/src/include
OBJS-$(BUILD_LIBVPX) += $(LIBVPX_TEST_OBJS)
+BINS-$(BUILD_LIBVPX) += $(LIBVPX_TEST_BINS)
# Install test sources only if codec source is included
INSTALL-SRCS-$(CONFIG_CODEC_SRCS) += $(patsubst $(SRC_PATH_BARE)/%,%,\
if (total > block_size)
return -1;
- entry = ne_find_track_entry(ctx, track - 1);
+ entry = ne_find_track_entry(ctx, (unsigned int)(track - 1));
if (!entry)
return -1;
pkt = ne_alloc(sizeof(*pkt));
pkt->track = track - 1;
- pkt->timecode = abs_timecode * tc_scale * track_scale;
+ pkt->timecode = (uint64_t)(abs_timecode * tc_scale * track_scale);
ctx->log(ctx, NESTEGG_LOG_DEBUG, "%sblock t %lld pts %f f %llx frames: %llu",
block_id == ID_BLOCK ? "" : "simple", pkt->track, pkt->timecode / 1e9, flags, frames);
if (ne_get_uint(entry->video.pixel_width, &value) != 0)
return -1;
- params->width = value;
+ params->width = (unsigned int)value;
if (ne_get_uint(entry->video.pixel_height, &value) != 0)
return -1;
- params->height = value;
+ params->height = (unsigned int)value;
value = 0;
ne_get_uint(entry->video.pixel_crop_bottom, &value);
- params->crop_bottom = value;
+ params->crop_bottom = (unsigned int)value;
value = 0;
ne_get_uint(entry->video.pixel_crop_top, &value);
- params->crop_top = value;
+ params->crop_top = (unsigned int)value;
value = 0;
ne_get_uint(entry->video.pixel_crop_left, &value);
- params->crop_left = value;
+ params->crop_left = (unsigned int)value;
value = 0;
ne_get_uint(entry->video.pixel_crop_right, &value);
- params->crop_right = value;
+ params->crop_right = (unsigned int)value;
value = params->width;
ne_get_uint(entry->video.display_width, &value);
- params->display_width = value;
+ params->display_width = (unsigned int)value;
value = params->height;
ne_get_uint(entry->video.display_height, &value);
- params->display_height = value;
+ params->display_height = (unsigned int)value;
return 0;
}
value = 1;
ne_get_uint(entry->audio.channels, &value);
- params->channels = value;
+ params->channels = (unsigned int)value;
value = 16;
ne_get_uint(entry->audio.bit_depth, &value);
- params->depth = value;
+ params->depth = (unsigned int)value;
return 0;
}
int
nestegg_packet_track(nestegg_packet * pkt, unsigned int * track)
{
- *track = pkt->track;
+ *track = (unsigned int)pkt->track;
return 0;
}
--- /dev/null
+/*
+ * Copyright (c) 2012 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 "third_party/googletest/src/include/gtest/gtest.h"
+#include "test/encode_test_driver.h"
+#include "test/i420_video_source.h"
+
+namespace {
+
+// lookahead range: [kLookAheadMin, kLookAheadMax).
+const int kLookAheadMin = 5;
+const int kLookAheadMax = 26;
+
+class AltRefTest : public libvpx_test::EncoderTest,
+ public ::testing::TestWithParam<int> {
+ protected:
+ AltRefTest() : altref_count_(0) {}
+ virtual ~AltRefTest() {}
+
+ virtual void SetUp() {
+ InitializeConfig();
+ SetMode(libvpx_test::kTwoPassGood);
+ }
+
+ virtual void BeginPassHook(unsigned int pass) {
+ altref_count_ = 0;
+ }
+
+ virtual bool Continue() const {
+ return !HasFatalFailure() && !abort_;
+ }
+
+ virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video,
+ libvpx_test::Encoder *encoder) {
+ if (video->frame() == 1) {
+ encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
+ encoder->Control(VP8E_SET_CPUUSED, 3);
+ }
+ }
+
+ virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
+ if (pkt->data.frame.flags & VPX_FRAME_IS_INVISIBLE) ++altref_count_;
+ }
+
+ int altref_count() const { return altref_count_; }
+
+ private:
+ int altref_count_;
+};
+
+TEST_P(AltRefTest, MonotonicTimestamps) {
+ const vpx_rational timebase = { 33333333, 1000000000 };
+ cfg_.g_timebase = timebase;
+ cfg_.rc_target_bitrate = 1000;
+ cfg_.g_lag_in_frames = GetParam();
+
+ libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
+ timebase.den, timebase.num, 0, 30);
+ ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
+ EXPECT_GE(altref_count(), 1);
+}
+
+INSTANTIATE_TEST_CASE_P(NonZeroLag, AltRefTest,
+ ::testing::Range(kLookAheadMin, kLookAheadMax));
+} // namespace
++frame_count_out_;
}
- virtual bool Continue() {
+ virtual bool Continue() const {
return !HasFatalFailure() && !abort_;
}
void EncoderTest::RunLoop(VideoSource *video) {
for (unsigned int pass = 0; pass < passes_; pass++) {
+ last_pts_ = 0;
+
if (passes_ == 1)
cfg_.g_pass = VPX_RC_ONE_PASS;
else if (pass == 0)
again = video->img() != NULL;
PreEncodeFrameHook(video);
+ PreEncodeFrameHook(video, &encoder);
encoder.EncodeFrame(video, flags_);
CxDataIterator iter = encoder.GetCxData();
if (pkt->kind != VPX_CODEC_CX_FRAME_PKT)
continue;
+ ASSERT_GE(pkt->data.frame.pts, last_pts_);
+ last_pts_ = pkt->data.frame.pts;
FramePktHook(pkt);
}
EncodeFrame(video, 0);
}
+ void Control(int ctrl_id, int arg) {
+ const vpx_codec_err_t res = vpx_codec_control_(&encoder_, ctrl_id, arg);
+ ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
+ }
+
void set_deadline(unsigned long deadline) {
deadline_ = deadline;
}
// classes directly, so that tests can be parameterized differently.
class EncoderTest {
protected:
- EncoderTest() : abort_(false), flags_(0) {}
+ EncoderTest() : abort_(false), flags_(0), last_pts_(0) {}
virtual ~EncoderTest() {}
// Hook to be called before encoding a frame.
virtual void PreEncodeFrameHook(VideoSource *video) {}
+ virtual void PreEncodeFrameHook(VideoSource *video, Encoder *encoder) {}
// Hook to be called on every compressed data packet.
virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {}
unsigned long deadline_;
TwopassStatsStore stats_;
unsigned long flags_;
+ vpx_codec_pts_t last_pts_;
};
} // namespace libvpx_test
kf_count_ = 0;
kf_count_max_ = INT_MAX;
kf_do_force_kf_ = false;
+ set_cpu_used_ = 0;
}
- virtual bool Continue() {
+ virtual bool Continue() const {
return !HasFatalFailure() && !abort_;
}
- virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video) {
+ virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,
+ ::libvpx_test::Encoder *encoder) {
if (kf_do_force_kf_)
flags_ = (video->frame() % 3) ? 0 : VPX_EFLAG_FORCE_KF;
+ if (set_cpu_used_ && video->frame() == 1)
+ encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_);
}
virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
int kf_count_;
int kf_count_max_;
std::vector<vpx_codec_pts_t> kf_pts_list_;
+ int set_cpu_used_;
};
TEST_P(KeyframeTest, TestRandomVideoSource) {
cfg_.kf_mode = VPX_KF_AUTO;
kf_do_force_kf_ = false;
+ // Force a deterministic speed step in Real Time mode, as the faster modes
+ // may not produce a keyframe like we expect. This is necessary when running
+ // on very slow environments (like Valgrind). The step -11 was determined
+ // experimentally as the fastest mode that still throws the keyframe.
+ if (deadline_ == VPX_DL_REALTIME)
+ set_cpu_used_ = -11;
+
// This clip has a cut scene every 30 frames -> Frame 0, 30, 60, 90, 120.
// I check only the first 40 frames to make sure there's a keyframe at frame
// 0 and 30.
CheckSad(128);
}
+using std::tr1::make_tuple;
+
+const sad_m_by_n_fn_t sad_16x16_c = vp8_sad16x16_c;
+const sad_m_by_n_fn_t sad_8x16_c = vp8_sad8x16_c;
+const sad_m_by_n_fn_t sad_16x8_c = vp8_sad16x8_c;
+const sad_m_by_n_fn_t sad_8x8_c = vp8_sad8x8_c;
+const sad_m_by_n_fn_t sad_4x4_c = vp8_sad4x4_c;
INSTANTIATE_TEST_CASE_P(C, SADTest, ::testing::Values(
- std::tr1::make_tuple(16, 16, vp8_sad16x16_c),
- std::tr1::make_tuple(8, 16, vp8_sad8x16_c),
- std::tr1::make_tuple(16, 8, vp8_sad16x8_c),
- std::tr1::make_tuple(8, 8, vp8_sad8x8_c),
- std::tr1::make_tuple(4, 4, vp8_sad4x4_c)));
+ make_tuple(16, 16, sad_16x16_c),
+ make_tuple(8, 16, sad_8x16_c),
+ make_tuple(16, 8, sad_16x8_c),
+ make_tuple(8, 8, sad_8x8_c),
+ make_tuple(4, 4, sad_4x4_c)));
// ARM tests
#if HAVE_MEDIA
+const sad_m_by_n_fn_t sad_16x16_armv6 = vp8_sad16x16_armv6;
INSTANTIATE_TEST_CASE_P(MEDIA, SADTest, ::testing::Values(
- std::tr1::make_tuple(16, 16, vp8_sad16x16_armv6)));
+ make_tuple(16, 16, sad_16x16_armv6)));
#endif
#if HAVE_NEON
+const sad_m_by_n_fn_t sad_16x16_neon = vp8_sad16x16_neon;
+const sad_m_by_n_fn_t sad_8x16_neon = vp8_sad8x16_neon;
+const sad_m_by_n_fn_t sad_16x8_neon = vp8_sad16x8_neon;
+const sad_m_by_n_fn_t sad_8x8_neon = vp8_sad8x8_neon;
+const sad_m_by_n_fn_t sad_4x4_neon = vp8_sad4x4_neon;
INSTANTIATE_TEST_CASE_P(NEON, SADTest, ::testing::Values(
- std::tr1::make_tuple(16, 16, vp8_sad16x16_neon),
- std::tr1::make_tuple(8, 16, vp8_sad8x16_neon),
- std::tr1::make_tuple(16, 8, vp8_sad16x8_neon),
- std::tr1::make_tuple(8, 8, vp8_sad8x8_neon),
- std::tr1::make_tuple(4, 4, vp8_sad4x4_neon)));
+ make_tuple(16, 16, sad_16x16_neon),
+ make_tuple(8, 16, sad_8x16_neon),
+ make_tuple(16, 8, sad_16x8_neon),
+ make_tuple(8, 8, sad_8x8_neon),
+ make_tuple(4, 4, sad_4x4_neon)));
#endif
// X86 tests
#if HAVE_MMX
+const sad_m_by_n_fn_t sad_16x16_mmx = vp8_sad16x16_mmx;
+const sad_m_by_n_fn_t sad_8x16_mmx = vp8_sad8x16_mmx;
+const sad_m_by_n_fn_t sad_16x8_mmx = vp8_sad16x8_mmx;
+const sad_m_by_n_fn_t sad_8x8_mmx = vp8_sad8x8_mmx;
+const sad_m_by_n_fn_t sad_4x4_mmx = vp8_sad4x4_mmx;
INSTANTIATE_TEST_CASE_P(MMX, SADTest, ::testing::Values(
- std::tr1::make_tuple(16, 16, vp8_sad16x16_mmx),
- std::tr1::make_tuple(8, 16, vp8_sad8x16_mmx),
- std::tr1::make_tuple(16, 8, vp8_sad16x8_mmx),
- std::tr1::make_tuple(8, 8, vp8_sad8x8_mmx),
- std::tr1::make_tuple(4, 4, vp8_sad4x4_mmx)));
+ make_tuple(16, 16, sad_16x16_mmx),
+ make_tuple(8, 16, sad_8x16_mmx),
+ make_tuple(16, 8, sad_16x8_mmx),
+ make_tuple(8, 8, sad_8x8_mmx),
+ make_tuple(4, 4, sad_4x4_mmx)));
#endif
#if HAVE_SSE2
+const sad_m_by_n_fn_t sad_16x16_wmt = vp8_sad16x16_wmt;
+const sad_m_by_n_fn_t sad_8x16_wmt = vp8_sad8x16_wmt;
+const sad_m_by_n_fn_t sad_16x8_wmt = vp8_sad16x8_wmt;
+const sad_m_by_n_fn_t sad_8x8_wmt = vp8_sad8x8_wmt;
+const sad_m_by_n_fn_t sad_4x4_wmt = vp8_sad4x4_wmt;
INSTANTIATE_TEST_CASE_P(SSE2, SADTest, ::testing::Values(
- std::tr1::make_tuple(16, 16, vp8_sad16x16_wmt),
- std::tr1::make_tuple(8, 16, vp8_sad8x16_wmt),
- std::tr1::make_tuple(16, 8, vp8_sad16x8_wmt),
- std::tr1::make_tuple(8, 8, vp8_sad8x8_wmt),
- std::tr1::make_tuple(4, 4, vp8_sad4x4_wmt)));
+ make_tuple(16, 16, sad_16x16_wmt),
+ make_tuple(8, 16, sad_8x16_wmt),
+ make_tuple(16, 8, sad_16x8_wmt),
+ make_tuple(8, 8, sad_8x8_wmt),
+ make_tuple(4, 4, sad_4x4_wmt)));
#endif
#if HAVE_SSSE3
+const sad_m_by_n_fn_t sad_16x16_sse3 = vp8_sad16x16_sse3;
INSTANTIATE_TEST_CASE_P(SSE3, SADTest, ::testing::Values(
- std::tr1::make_tuple(16, 16, vp8_sad16x16_sse3)));
+ make_tuple(16, 16, sad_16x16_sse3)));
#endif
} // namespace
}
using std::tr1::make_tuple;
+
+const sixtap_predict_fn_t sixtap_16x16_c = vp8_sixtap_predict16x16_c;
+const sixtap_predict_fn_t sixtap_8x8_c = vp8_sixtap_predict8x8_c;
+const sixtap_predict_fn_t sixtap_8x4_c = vp8_sixtap_predict8x4_c;
+const sixtap_predict_fn_t sixtap_4x4_c = vp8_sixtap_predict4x4_c;
INSTANTIATE_TEST_CASE_P(
C, SixtapPredictTest, ::testing::Values(
- make_tuple(16, 16, vp8_sixtap_predict16x16_c),
- make_tuple(8, 8, vp8_sixtap_predict8x8_c),
- make_tuple(8, 4, vp8_sixtap_predict8x4_c),
- make_tuple(4, 4, vp8_sixtap_predict4x4_c)));
+ make_tuple(16, 16, sixtap_16x16_c),
+ make_tuple(8, 8, sixtap_8x8_c),
+ make_tuple(8, 4, sixtap_8x4_c),
+ make_tuple(4, 4, sixtap_4x4_c)));
#if HAVE_MMX
+const sixtap_predict_fn_t sixtap_16x16_mmx = vp8_sixtap_predict16x16_mmx;
+const sixtap_predict_fn_t sixtap_8x8_mmx = vp8_sixtap_predict8x8_mmx;
+const sixtap_predict_fn_t sixtap_8x4_mmx = vp8_sixtap_predict8x4_mmx;
+const sixtap_predict_fn_t sixtap_4x4_mmx = vp8_sixtap_predict4x4_mmx;
INSTANTIATE_TEST_CASE_P(
MMX, SixtapPredictTest, ::testing::Values(
- make_tuple(16, 16, vp8_sixtap_predict16x16_mmx),
- make_tuple(8, 8, vp8_sixtap_predict8x8_mmx),
- make_tuple(8, 4, vp8_sixtap_predict8x4_mmx),
- make_tuple(4, 4, vp8_sixtap_predict4x4_mmx)));
+ make_tuple(16, 16, sixtap_16x16_mmx),
+ make_tuple(8, 8, sixtap_8x8_mmx),
+ make_tuple(8, 4, sixtap_8x4_mmx),
+ make_tuple(4, 4, sixtap_4x4_mmx)));
#endif
#if HAVE_SSE2
+const sixtap_predict_fn_t sixtap_16x16_sse2 = vp8_sixtap_predict16x16_sse2;
+const sixtap_predict_fn_t sixtap_8x8_sse2 = vp8_sixtap_predict8x8_sse2;
+const sixtap_predict_fn_t sixtap_8x4_sse2 = vp8_sixtap_predict8x4_sse2;
INSTANTIATE_TEST_CASE_P(
SSE2, SixtapPredictTest, ::testing::Values(
- make_tuple(16, 16, vp8_sixtap_predict16x16_sse2),
- make_tuple(8, 8, vp8_sixtap_predict8x8_sse2),
- make_tuple(8, 4, vp8_sixtap_predict8x4_sse2)));
+ make_tuple(16, 16, sixtap_16x16_sse2),
+ make_tuple(8, 8, sixtap_8x8_sse2),
+ make_tuple(8, 4, sixtap_8x4_sse2)));
#endif
#if HAVE_SSSE3
+const sixtap_predict_fn_t sixtap_16x16_ssse3 = vp8_sixtap_predict16x16_ssse3;
+const sixtap_predict_fn_t sixtap_8x8_ssse3 = vp8_sixtap_predict8x8_ssse3;
+const sixtap_predict_fn_t sixtap_8x4_ssse3 = vp8_sixtap_predict8x4_ssse3;
+const sixtap_predict_fn_t sixtap_4x4_ssse3 = vp8_sixtap_predict4x4_ssse3;
INSTANTIATE_TEST_CASE_P(
SSSE3, SixtapPredictTest, ::testing::Values(
- make_tuple(16, 16, vp8_sixtap_predict16x16_ssse3),
- make_tuple(8, 8, vp8_sixtap_predict8x8_ssse3),
- make_tuple(8, 4, vp8_sixtap_predict8x4_ssse3),
- make_tuple(4, 4, vp8_sixtap_predict4x4_ssse3)));
+ make_tuple(16, 16, sixtap_16x16_ssse3),
+ make_tuple(8, 8, sixtap_8x8_ssse3),
+ make_tuple(8, 4, sixtap_8x4_ssse3),
+ make_tuple(4, 4, sixtap_4x4_ssse3)));
#endif
} // namespace
##
## Black box tests only use the public API.
##
+LIBVPX_TEST_SRCS-$(CONFIG_VP8_ENCODER) += altref_test.cc
LIBVPX_TEST_SRCS-$(CONFIG_VP8_ENCODER) += config_test.cc
LIBVPX_TEST_SRCS-$(CONFIG_VP8_ENCODER) += encode_test_driver.cc
LIBVPX_TEST_SRCS-$(CONFIG_VP8_ENCODER) += encode_test_driver.h
AREA ||.text||, CODE, READONLY, ALIGN=2
-;void vp8_intra4x4_predict_armv6(unsigned char *src, int src_stride, int b_mode,
-; unsigned char *dst, int dst_stride)
-
+;void vp8_intra4x4_predict_armv6(unsigned char *Above, unsigned char *yleft,
+; B_PREDICTION_MODE left_stride, int b_mode,
+; unsigned char *dst, int dst_stride,
+; unsigned char top_left)
+
+; r0: *Above
+; r1: *yleft
+; r2: left_stride
+; r3: b_mode
+; sp + #40: dst
+; sp + #44: dst_stride
+; sp + #48: top_left
|vp8_intra4x4_predict_armv6| PROC
push {r4-r12, lr}
-
- cmp r2, #10
- addlt pc, pc, r2, lsl #2 ; position independent switch
+ cmp r3, #10
+ addlt pc, pc, r3, lsl #2 ; position independent switch
pop {r4-r12, pc} ; default
b b_dc_pred
b b_tm_pred
b_dc_pred
; load values
- ldr r8, [r0, -r1] ; Above
- ldrb r4, [r0, #-1]! ; Left[0]
+ ldr r8, [r0] ; Above
+ ldrb r4, [r1], r2 ; Left[0]
mov r9, #0
- ldrb r5, [r0, r1] ; Left[1]
- ldrb r6, [r0, r1, lsl #1]! ; Left[2]
+ ldrb r5, [r1], r2 ; Left[1]
+ ldrb r6, [r1], r2 ; Left[2]
usad8 r12, r8, r9
- ldrb r7, [r0, r1] ; Left[3]
+ ldrb r7, [r1] ; Left[3]
; calculate dc
add r4, r4, r5
add r4, r4, r7
add r4, r4, r12
add r4, r4, #4
- ldr r0, [sp, #40] ; load stride
+ ldr r0, [sp, #44] ; dst_stride
mov r12, r4, asr #3 ; (expected_dc + 4) >> 3
add r12, r12, r12, lsl #8
- add r3, r3, r0
+ ldr r3, [sp, #40] ; dst
add r12, r12, r12, lsl #16
; store values
- str r12, [r3, -r0]
+ str r12, [r3], r0
+ str r12, [r3], r0
+ str r12, [r3], r0
str r12, [r3]
- str r12, [r3, r0]
- str r12, [r3, r0, lsl #1]
pop {r4-r12, pc}
b_tm_pred
- sub r10, r0, #1 ; Left
- ldr r8, [r0, -r1] ; Above
- ldrb r9, [r10, -r1] ; top_left
- ldrb r4, [r0, #-1]! ; Left[0]
- ldrb r5, [r10, r1]! ; Left[1]
- ldrb r6, [r0, r1, lsl #1] ; Left[2]
- ldrb r7, [r10, r1, lsl #1] ; Left[3]
- ldr r0, [sp, #40] ; load stride
-
+ ldr r8, [r0] ; Above
+ ldrb r9, [sp, #48] ; top_left
+ ldrb r4, [r1], r2 ; Left[0]
+ ldrb r5, [r1], r2 ; Left[1]
+ ldrb r6, [r1], r2 ; Left[2]
+ ldrb r7, [r1] ; Left[3]
+ ldr r0, [sp, #44] ; dst_stride
+ ldr r3, [sp, #40] ; dst
add r9, r9, r9, lsl #16 ; [tl|tl]
uxtb16 r10, r8 ; a[2|0]
str r12, [r3], r0
add r12, r4, r5, lsl #8 ; [3|2|1|0]
- str r12, [r3], r0
+ str r12, [r3]
pop {r4-r12, pc}
b_ve_pred
- ldr r8, [r0, -r1]! ; a[3|2|1|0]
+ ldr r8, [r0] ; a[3|2|1|0]
ldr r11, c00FF00FF
- ldrb r9, [r0, #-1] ; top_left
+ ldrb r9, [sp, #48] ; top_left
ldrb r10, [r0, #4] ; a[4]
ldr r0, c00020002
uxtb16 r4, r8 ; a[2|0]
uxtb16 r5, r8, ror #8 ; a[3|1]
- ldr r2, [sp, #40] ; stride
+ ldr r2, [sp, #44] ; dst_stride
pkhbt r9, r9, r5, lsl #16 ; a[1|-1]
add r9, r9, r4, lsl #1 ;[a[1]+2*a[2] | tl+2*a[0] ]
uxtab16 r9, r9, r5 ;[a[1]+2*a[2]+a[3] | tl+2*a[0]+a[1] ]
+ ldr r3, [sp, #40] ; dst
uxtab16 r9, r9, r0 ;[a[1]+2*a[2]+a[3]+2| tl+2*a[0]+a[1]+2]
add r0, r0, r10, lsl #16 ;[a[4]+2 | 2]
and r9, r11, r9, asr #2
and r4, r11, r4, asr #2
- add r3, r3, r2 ; dst + dst_stride
add r9, r9, r4, lsl #8
; store values
- str r9, [r3, -r2]
+ str r9, [r3], r2
+ str r9, [r3], r2
+ str r9, [r3], r2
str r9, [r3]
- str r9, [r3, r2]
- str r9, [r3, r2, lsl #1]
pop {r4-r12, pc}
b_he_pred
- sub r10, r0, #1 ; Left
- ldrb r4, [r0, #-1]! ; Left[0]
- ldrb r8, [r10, -r1] ; top_left
- ldrb r5, [r10, r1]! ; Left[1]
- ldrb r6, [r0, r1, lsl #1] ; Left[2]
- ldrb r7, [r10, r1, lsl #1] ; Left[3]
+ ldrb r4, [r1], r2 ; Left[0]
+ ldrb r8, [sp, #48] ; top_left
+ ldrb r5, [r1], r2 ; Left[1]
+ ldrb r6, [r1], r2 ; Left[2]
+ ldrb r7, [r1] ; Left[3]
add r8, r8, r4 ; tl + l[0]
add r9, r4, r5 ; l[0] + l[1]
pkhtb r10, r10, r10, asr #16 ; l[-|2|-|2]
pkhtb r11, r11, r11, asr #16 ; l[-|3|-|3]
- ldr r0, [sp, #40] ; stride
+ ldr r0, [sp, #44] ; dst_stride
+ ldr r3, [sp, #40] ; dst
add r8, r8, r8, lsl #8 ; l[0|0|0|0]
add r9, r9, r9, lsl #8 ; l[1|1|1|1]
; store values
str r8, [r3], r0
- str r9, [r3]
- str r10, [r3, r0]
- str r11, [r3, r0, lsl #1]
+ str r9, [r3], r0
+ str r10, [r3], r0
+ str r11, [r3]
pop {r4-r12, pc}
b_ld_pred
- ldr r4, [r0, -r1]! ; Above
+ ldr r4, [r0] ; Above[0-3]
ldr r12, c00020002
- ldr r5, [r0, #4]
+ ldr r5, [r0, #4] ; Above[4-7]
ldr lr, c00FF00FF
uxtb16 r6, r4 ; a[2|0]
pkhtb r10, r6, r8 ; a[2|4]
pkhtb r11, r7, r9 ; a[3|5]
-
add r4, r6, r7, lsl #1 ; [a2+2*a3 | a0+2*a1]
add r4, r4, r10, ror #16 ; [a2+2*a3+a4 | a0+2*a1+a2]
uxtab16 r4, r4, r12 ; [a2+2*a3+a4+2 | a0+2*a1+a2+2]
add r7, r7, r9, asr #16 ; [ a5+2*a6+a7]
uxtah r7, r7, r12 ; [ a5+2*a6+a7+2]
- ldr r0, [sp, #40] ; stride
+ ldr r0, [sp, #44] ; dst_stride
+ ldr r3, [sp, #40] ; dst
; scale down
and r4, lr, r4, asr #2
mov r6, r6, lsr #16
mov r11, r10, lsr #8
add r11, r11, r6, lsl #24 ; [6|5|4|3]
- str r11, [r3], r0
+ str r11, [r3]
pop {r4-r12, pc}
b_rd_pred
- sub r12, r0, r1 ; Above = src - src_stride
- ldrb r7, [r0, #-1]! ; l[0] = pp[3]
- ldr lr, [r12] ; Above = pp[8|7|6|5]
- ldrb r8, [r12, #-1]! ; tl = pp[4]
- ldrb r6, [r12, r1, lsl #1] ; l[1] = pp[2]
- ldrb r5, [r0, r1, lsl #1] ; l[2] = pp[1]
- ldrb r4, [r12, r1, lsl #2] ; l[3] = pp[0]
+ ldrb r7, [r1], r2 ; l[0] = pp[3]
+ ldr lr, [r0] ; Above = pp[8|7|6|5]
+ ldrb r8, [sp, #48] ; tl = pp[4]
+ ldrb r6, [r1], r2 ; l[1] = pp[2]
+ ldrb r5, [r1], r2 ; l[2] = pp[1]
+ ldrb r4, [r1], r2 ; l[3] = pp[0]
uxtb16 r9, lr ; p[7|5]
add r7, r7, r10 ; [p6+2*p7+p8 | p4+2*p5+p6]
uxtab16 r7, r7, r12 ; [p6+2*p7+p8+2 | p4+2*p5+p6+2]
- ldr r0, [sp, #40] ; stride
+ ldr r0, [sp, #44] ; dst_stride
+ ldr r3, [sp, #40] ; dst
; scale down
and r7, lr, r7, asr #2
mov r11, r10, lsl #8 ; [3|2|1|-]
uxtab r11, r11, r4 ; [3|2|1|0]
- str r11, [r3], r0
+ str r11, [r3]
pop {r4-r12, pc}
b_vr_pred
- sub r12, r0, r1 ; Above = src - src_stride
- ldrb r7, [r0, #-1]! ; l[0] = pp[3]
- ldr lr, [r12] ; Above = pp[8|7|6|5]
- ldrb r8, [r12, #-1]! ; tl = pp[4]
- ldrb r6, [r12, r1, lsl #1] ; l[1] = pp[2]
- ldrb r5, [r0, r1, lsl #1] ; l[2] = pp[1]
- ldrb r4, [r12, r1, lsl #2] ; l[3] = pp[0]
+ ldrb r7, [r1], r2 ; l[0] = pp[3]
+ ldr lr, [r0] ; Above = pp[8|7|6|5]
+ ldrb r8, [sp, #48] ; tl = pp[4]
+ ldrb r6, [r1], r2 ; l[1] = pp[2]
+ ldrb r5, [r1], r2 ; l[2] = pp[1]
+ ldrb r4, [r1] ; l[3] = pp[0]
add r5, r5, r7, lsl #16 ; p[3|1]
add r6, r6, r8, lsl #16 ; p[4|2]
add r8, r8, r10 ; [p6+2*p7+p8 | p4+2*p5+p6]
uxtab16 r8, r8, r12 ; [p6+2*p7+p8+2 | p4+2*p5+p6+2]
- ldr r0, [sp, #40] ; stride
+ ldr r0, [sp, #44] ; dst_stride
+ ldr r3, [sp, #40] ; dst
; scale down
and r5, lr, r5, asr #2 ; [B|A]
pkhtb r10, r7, r5, asr #16 ; [-|H|-|B]
str r2, [r3], r0
add r12, r12, r10, lsl #8 ; [H|D|B|A]
- str r12, [r3], r0
+ str r12, [r3]
pop {r4-r12, pc}
b_vl_pred
- ldr r4, [r0, -r1]! ; [3|2|1|0]
+ ldr r4, [r0] ; [3|2|1|0] = Above[0-3]
ldr r12, c00020002
- ldr r5, [r0, #4] ; [7|6|5|4]
+ ldr r5, [r0, #4] ; [7|6|5|4] = Above[4-7]
ldr lr, c00FF00FF
ldr r2, c00010001
add r9, r9, r11 ; [p5+2*p6+p7 | p3+2*p4+p5]
uxtab16 r9, r9, r12 ; [p5+2*p6+p7+2 | p3+2*p4+p5+2]
- ldr r0, [sp, #40] ; stride
+ ldr r0, [sp, #44] ; dst_stride
+ ldr r3, [sp, #40] ; dst
; scale down
and r5, lr, r5, asr #2 ; [D|C]
and r8, lr, r8, asr #2 ; [I|D]
and r9, lr, r9, asr #2 ; [J|H]
-
add r10, r4, r6, lsl #8 ; [F|B|E|A]
str r10, [r3], r0
str r12, [r3], r0
add r10, r7, r10, lsl #8 ; [J|H|D|G]
- str r10, [r3], r0
+ str r10, [r3]
pop {r4-r12, pc}
b_hd_pred
- sub r12, r0, r1 ; Above = src - src_stride
- ldrb r7, [r0, #-1]! ; l[0] = pp[3]
- ldr lr, [r12] ; Above = pp[8|7|6|5]
- ldrb r8, [r12, #-1]! ; tl = pp[4]
- ldrb r6, [r0, r1] ; l[1] = pp[2]
- ldrb r5, [r0, r1, lsl #1] ; l[2] = pp[1]
- ldrb r4, [r12, r1, lsl #2] ; l[3] = pp[0]
+ ldrb r7, [r1], r2 ; l[0] = pp[3]
+ ldr lr, [r0] ; Above = pp[8|7|6|5]
+ ldrb r8, [sp, #48] ; tl = pp[4]
+ ldrb r6, [r1], r2 ; l[1] = pp[2]
+ ldrb r5, [r1], r2 ; l[2] = pp[1]
+ ldrb r4, [r1] ; l[3] = pp[0]
uxtb16 r9, lr ; p[7|5]
uxtb16 r10, lr, ror #8 ; p[8|6]
pkhtb r1, r9, r10 ; p[7|6]
pkhbt r10, r8, r10, lsl #16 ; p[6|5]
-
uadd16 r11, r4, r5 ; [p1+p2 | p0+p1]
uhadd16 r11, r11, r2 ; [(p1+p2+1)>>1 | (p0+p1+1)>>1]
; [B|A]
and r5, lr, r5, asr #2 ; [H|G]
and r6, lr, r6, asr #2 ; [J|I]
- ldr lr, [sp, #40] ; stride
+ ldr lr, [sp, #44] ; dst_stride
+ ldr r3, [sp, #40] ; dst
pkhtb r2, r0, r6 ; [-|F|-|I]
pkhtb r12, r6, r5, asr #16 ; [-|J|-|H]
mov r12, r12, ror #24 ; [J|I|H|F]
str r12, [r3], lr
-
mov r7, r11, asr #16 ; [-|-|-|B]
str r2, [r3], lr
add r7, r7, r0, lsl #16 ; [-|E|-|B]
str r7, [r3], lr
add r5, r11, r4, lsl #8 ; [D|B|C|A]
- str r5, [r3], lr
+ str r5, [r3]
pop {r4-r12, pc}
b_hu_pred
- ldrb r4, [r0, #-1]! ; Left[0]
+ ldrb r4, [r1], r2 ; Left[0]
ldr r12, c00020002
- ldrb r5, [r0, r1]! ; Left[1]
+ ldrb r5, [r1], r2 ; Left[1]
ldr lr, c00FF00FF
- ldrb r6, [r0, r1]! ; Left[2]
+ ldrb r6, [r1], r2 ; Left[2]
ldr r2, c00010001
- ldrb r7, [r0, r1] ; Left[3]
-
+ ldrb r7, [r1] ; Left[3]
add r4, r4, r5, lsl #16 ; [1|0]
add r5, r5, r6, lsl #16 ; [2|1]
add r4, r4, r5, lsl #1 ; [p1+2*p2 | p0+2*p1]
add r4, r4, r9 ; [p1+2*p2+p3 | p0+2*p1+p2]
uxtab16 r4, r4, r12 ; [p1+2*p2+p3+2 | p0+2*p1+p2+2]
- ldr r2, [sp, #40] ; stride
+ ldr r2, [sp, #44] ; dst_stride
+ ldr r3, [sp, #40] ; dst
and r4, lr, r4, asr #2 ; [D|C]
add r10, r6, r7 ; [p2+p3]
add r10, r11, lsl #8 ; [-|-|F|E]
add r10, r10, r9, lsl #16 ; [G|G|F|E]
- str r10, [r3]
+ str r10, [r3], r2
- str r7, [r3, r2]
+ str r7, [r3]
pop {r4-r12, pc}
uint8_t segment_id; /* Which set of segmentation parameters should be used for this MB */
} MB_MODE_INFO;
-typedef struct
+typedef struct modeinfo
{
MB_MODE_INFO mbmi;
union b_mode_info bmi[16];
}
}
+
+void vp8_loop_filter_row_normal(VP8_COMMON *cm, MODE_INFO *mode_info_context,
+ int mb_row, int post_ystride, int post_uvstride,
+ unsigned char *y_ptr, unsigned char *u_ptr,
+ unsigned char *v_ptr)
+{
+ int mb_col;
+ int filter_level;
+ loop_filter_info_n *lfi_n = &cm->lf_info;
+ loop_filter_info lfi;
+ FRAME_TYPE frame_type = cm->frame_type;
+
+ for (mb_col = 0; mb_col < cm->mb_cols; mb_col++)
+ {
+ int skip_lf = (mode_info_context->mbmi.mode != B_PRED &&
+ mode_info_context->mbmi.mode != SPLITMV &&
+ mode_info_context->mbmi.mb_skip_coeff);
+
+ const int mode_index = lfi_n->mode_lf_lut[mode_info_context->mbmi.mode];
+ const int seg = mode_info_context->mbmi.segment_id;
+ const int ref_frame = mode_info_context->mbmi.ref_frame;
+
+ filter_level = lfi_n->lvl[seg][ref_frame][mode_index];
+
+ if (filter_level)
+ {
+ const int hev_index = lfi_n->hev_thr_lut[frame_type][filter_level];
+ lfi.mblim = lfi_n->mblim[filter_level];
+ lfi.blim = lfi_n->blim[filter_level];
+ lfi.lim = lfi_n->lim[filter_level];
+ lfi.hev_thr = lfi_n->hev_thr[hev_index];
+
+ if (mb_col > 0)
+ vp8_loop_filter_mbv
+ (y_ptr, u_ptr, v_ptr, post_ystride, post_uvstride, &lfi);
+
+ if (!skip_lf)
+ vp8_loop_filter_bv
+ (y_ptr, u_ptr, v_ptr, post_ystride, post_uvstride, &lfi);
+
+ /* don't apply across umv border */
+ if (mb_row > 0)
+ vp8_loop_filter_mbh
+ (y_ptr, u_ptr, v_ptr, post_ystride, post_uvstride, &lfi);
+
+ if (!skip_lf)
+ vp8_loop_filter_bh
+ (y_ptr, u_ptr, v_ptr, post_ystride, post_uvstride, &lfi);
+ }
+
+ y_ptr += 16;
+ u_ptr += 8;
+ v_ptr += 8;
+
+ mode_info_context++; /* step to next MB */
+ }
+
+}
+
+void vp8_loop_filter_row_simple(VP8_COMMON *cm, MODE_INFO *mode_info_context,
+ int mb_row, int post_ystride, int post_uvstride,
+ unsigned char *y_ptr, unsigned char *u_ptr,
+ unsigned char *v_ptr)
+{
+ int mb_col;
+ int filter_level;
+ loop_filter_info_n *lfi_n = &cm->lf_info;
+
+ for (mb_col = 0; mb_col < cm->mb_cols; mb_col++)
+ {
+ int skip_lf = (mode_info_context->mbmi.mode != B_PRED &&
+ mode_info_context->mbmi.mode != SPLITMV &&
+ mode_info_context->mbmi.mb_skip_coeff);
+
+ const int mode_index = lfi_n->mode_lf_lut[mode_info_context->mbmi.mode];
+ const int seg = mode_info_context->mbmi.segment_id;
+ const int ref_frame = mode_info_context->mbmi.ref_frame;
+
+ filter_level = lfi_n->lvl[seg][ref_frame][mode_index];
+
+ if (filter_level)
+ {
+ if (mb_col > 0)
+ vp8_loop_filter_simple_mbv
+ (y_ptr, post_ystride, lfi_n->mblim[filter_level]);
+
+ if (!skip_lf)
+ vp8_loop_filter_simple_bv
+ (y_ptr, post_ystride, lfi_n->blim[filter_level]);
+
+ /* don't apply across umv border */
+ if (mb_row > 0)
+ vp8_loop_filter_simple_mbh
+ (y_ptr, post_ystride, lfi_n->mblim[filter_level]);
+
+ if (!skip_lf)
+ vp8_loop_filter_simple_bh
+ (y_ptr, post_ystride, lfi_n->blim[filter_level]);
+ }
+
+ y_ptr += 16;
+ u_ptr += 8;
+ v_ptr += 8;
+
+ mode_info_context++; /* step to next MB */
+ }
+
+}
void vp8_loop_filter_frame(VP8_COMMON *cm,
MACROBLOCKD *mbd,
int frame_type)
/* assorted loopfilter functions which get used elsewhere */
struct VP8Common;
struct macroblockd;
+struct modeinfo;
void vp8_loop_filter_init(struct VP8Common *cm);
void vp8_loop_filter_update_sharpness(loop_filter_info_n *lfi,
int sharpness_lvl);
+void vp8_loop_filter_row_normal(struct VP8Common *cm,
+ struct modeinfo *mode_info_context,
+ int mb_row, int post_ystride, int post_uvstride,
+ unsigned char *y_ptr, unsigned char *u_ptr,
+ unsigned char *v_ptr);
+
+void vp8_loop_filter_row_simple(struct VP8Common *cm,
+ struct modeinfo *mode_info_context,
+ int mb_row, int post_ystride, int post_uvstride,
+ unsigned char *y_ptr, unsigned char *u_ptr,
+ unsigned char *v_ptr);
#endif
void vp8_intra4x4_predict_c(unsigned char *Above,
unsigned char *yleft, int left_stride,
- int b_mode,
+ B_PREDICTION_MODE b_mode,
unsigned char *dst, int dst_stride,
unsigned char top_left)
{
}
break;
+ default:
+ break;
}
}
common_forward_decls() {
cat <<EOF
+#include "vp8/common/blockd.h"
+
struct blockd;
struct macroblockd;
struct loop_filter_info;
prototype void vp8_build_intra_predictors_mbuv_s "struct macroblockd *x, unsigned char * uabove_row, unsigned char * vabove_row, unsigned char *uleft, unsigned char *vleft, int left_stride, unsigned char * upred_ptr, unsigned char * vpred_ptr, int pred_stride"
specialize vp8_build_intra_predictors_mbuv_s sse2 ssse3
-prototype void vp8_intra4x4_predict "unsigned char *above, unsigned char *left, int left_stride, int b_mode, unsigned char *dst, int dst_stride, unsigned char top_left"
-# No existing specializations
+prototype void vp8_intra4x4_predict "unsigned char *Above, unsigned char *yleft, int left_stride, B_PREDICTION_MODE b_mode, unsigned char *dst, int dst_stride, unsigned char top_left"
+specialize vp8_intra4x4_predict media
+vp8_intra4x4_predict_media=vp8_intra4x4_predict_armv6
#
# Postproc
#
# Single block SAD
#
-prototype unsigned int vp8_sad4x4 "const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int max_sad"
+prototype unsigned int vp8_sad4x4 "const unsigned char *src_ptr, int src_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int max_sad"
specialize vp8_sad4x4 mmx sse2 neon
vp8_sad4x4_sse2=vp8_sad4x4_wmt
-prototype unsigned int vp8_sad8x8 "const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int max_sad"
+prototype unsigned int vp8_sad8x8 "const unsigned char *src_ptr, int src_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int max_sad"
specialize vp8_sad8x8 mmx sse2 neon
vp8_sad8x8_sse2=vp8_sad8x8_wmt
-prototype unsigned int vp8_sad8x16 "const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int max_sad"
+prototype unsigned int vp8_sad8x16 "const unsigned char *src_ptr, int src_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int max_sad"
specialize vp8_sad8x16 mmx sse2 neon
vp8_sad8x16_sse2=vp8_sad8x16_wmt
-prototype unsigned int vp8_sad16x8 "const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int max_sad"
+prototype unsigned int vp8_sad16x8 "const unsigned char *src_ptr, int src_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int max_sad"
specialize vp8_sad16x8 mmx sse2 neon
vp8_sad16x8_sse2=vp8_sad16x8_wmt
-prototype unsigned int vp8_sad16x16 "const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int max_sad"
+prototype unsigned int vp8_sad16x16 "const unsigned char *src_ptr, int src_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int max_sad"
specialize vp8_sad16x16 mmx sse2 sse3 media neon
vp8_sad16x16_sse2=vp8_sad16x16_wmt
vp8_sad16x16_media=vp8_sad16x16_armv6
#
# Multi-block SAD, comparing a reference to N blocks 1 pixel apart horizontally
#
-prototype void vp8_sad4x4x3 "const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int *sad_array"
+prototype void vp8_sad4x4x3 "const unsigned char *src_ptr, int src_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int *sad_array"
specialize vp8_sad4x4x3 sse3
-prototype void vp8_sad8x8x3 "const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int *sad_array"
+prototype void vp8_sad8x8x3 "const unsigned char *src_ptr, int src_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int *sad_array"
specialize vp8_sad8x8x3 sse3
-prototype void vp8_sad8x16x3 "const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int *sad_array"
+prototype void vp8_sad8x16x3 "const unsigned char *src_ptr, int src_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int *sad_array"
specialize vp8_sad8x16x3 sse3
-prototype void vp8_sad16x8x3 "const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int *sad_array"
+prototype void vp8_sad16x8x3 "const unsigned char *src_ptr, int src_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int *sad_array"
specialize vp8_sad16x8x3 sse3 ssse3
-prototype void vp8_sad16x16x3 "const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int *sad_array"
+prototype void vp8_sad16x16x3 "const unsigned char *src_ptr, int src_stride, const unsigned char *ref_ptr, int ref_stride, unsigned int *sad_array"
specialize vp8_sad16x16x3 sse3 ssse3
# Note the only difference in the following prototypes is that they return into
# an array of short
-prototype void vp8_sad4x4x8 "const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int ref_stride, unsigned short *sad_array"
+prototype void vp8_sad4x4x8 "const unsigned char *src_ptr, int src_stride, const unsigned char *ref_ptr, int ref_stride, unsigned short *sad_array"
specialize vp8_sad4x4x8 sse4_1
vp8_sad4x4x8_sse4_1=vp8_sad4x4x8_sse4
-prototype void vp8_sad8x8x8 "const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int ref_stride, unsigned short *sad_array"
+prototype void vp8_sad8x8x8 "const unsigned char *src_ptr, int src_stride, const unsigned char *ref_ptr, int ref_stride, unsigned short *sad_array"
specialize vp8_sad8x8x8 sse4_1
vp8_sad8x8x8_sse4_1=vp8_sad8x8x8_sse4
-prototype void vp8_sad8x16x8 "const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int ref_stride, unsigned short *sad_array"
+prototype void vp8_sad8x16x8 "const unsigned char *src_ptr, int src_stride, const unsigned char *ref_ptr, int ref_stride, unsigned short *sad_array"
specialize vp8_sad8x16x8 sse4_1
vp8_sad8x16x8_sse4_1=vp8_sad8x16x8_sse4
-prototype void vp8_sad16x8x8 "const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int ref_stride, unsigned short *sad_array"
+prototype void vp8_sad16x8x8 "const unsigned char *src_ptr, int src_stride, const unsigned char *ref_ptr, int ref_stride, unsigned short *sad_array"
specialize vp8_sad16x8x8 sse4_1
vp8_sad16x8x8_sse4_1=vp8_sad16x8x8_sse4
-prototype void vp8_sad16x16x8 "const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int ref_stride, unsigned short *sad_array"
+prototype void vp8_sad16x16x8 "const unsigned char *src_ptr, int src_stride, const unsigned char *ref_ptr, int ref_stride, unsigned short *sad_array"
specialize vp8_sad16x16x8 sse4_1
vp8_sad16x16x8_sse4_1=vp8_sad16x16x8_sse4
#
# Multi-block SAD, comparing a reference to N independent blocks
#
-prototype void vp8_sad4x4x4d "const unsigned char *src_ptr, int source_stride, const unsigned char * const ref_ptr[], int ref_stride, unsigned int *sad_array"
+prototype void vp8_sad4x4x4d "const unsigned char *src_ptr, int src_stride, const unsigned char * const ref_ptr[], int ref_stride, unsigned int *sad_array"
specialize vp8_sad4x4x4d sse3
-prototype void vp8_sad8x8x4d "const unsigned char *src_ptr, int source_stride, const unsigned char * const ref_ptr[], int ref_stride, unsigned int *sad_array"
+prototype void vp8_sad8x8x4d "const unsigned char *src_ptr, int src_stride, const unsigned char * const ref_ptr[], int ref_stride, unsigned int *sad_array"
specialize vp8_sad8x8x4d sse3
-prototype void vp8_sad8x16x4d "const unsigned char *src_ptr, int source_stride, const unsigned char * const ref_ptr[], int ref_stride, unsigned int *sad_array"
+prototype void vp8_sad8x16x4d "const unsigned char *src_ptr, int src_stride, const unsigned char * const ref_ptr[], int ref_stride, unsigned int *sad_array"
specialize vp8_sad8x16x4d sse3
-prototype void vp8_sad16x8x4d "const unsigned char *src_ptr, int source_stride, const unsigned char * const ref_ptr[], int ref_stride, unsigned int *sad_array"
+prototype void vp8_sad16x8x4d "const unsigned char *src_ptr, int src_stride, const unsigned char * const ref_ptr[], int ref_stride, unsigned int *sad_array"
specialize vp8_sad16x8x4d sse3
-prototype void vp8_sad16x16x4d "const unsigned char *src_ptr, int source_stride, const unsigned char * const ref_ptr[], int ref_stride, unsigned int *sad_array"
+prototype void vp8_sad16x16x4d "const unsigned char *src_ptr, int src_stride, const unsigned char * const ref_ptr[], int ref_stride, unsigned int *sad_array"
specialize vp8_sad16x16x4d sse3
#
int loop_end, x; \
size_t bits_left = ((_bufend)-(_bufptr))*CHAR_BIT; \
\
- x = shift + CHAR_BIT - bits_left; \
+ x = (int)(shift + CHAR_BIT - bits_left); \
loop_end = 0; \
if(x >= 0) \
{ \
{
BLOCKD *b = &xd->block[i];
unsigned char *dst = xd->dst.y_buffer + b->offset;
- int b_mode = xd->mode_info_context->bmi[i].as_mode;
+ B_PREDICTION_MODE b_mode =
+ xd->mode_info_context->bmi[i].as_mode;
unsigned char *Above = dst - dst_stride;
unsigned char *yleft = dst - 1;
int left_stride = dst_stride;
VP8_COMMON *const pc = & pbi->common;
MACROBLOCKD *const xd = & pbi->mb;
+ MODE_INFO *lf_mic = xd->mode_info_context;
+
int ibc = 0;
int num_part = 1 << pc->multi_token_partition;
unsigned char *ref_buffer[MAX_REF_FRAMES][3];
unsigned char *dst_buffer[3];
+ unsigned char *lf_dst[3];
int i;
int ref_fb_index[MAX_REF_FRAMES];
int ref_fb_corrupted[MAX_REF_FRAMES];
ref_fb_corrupted[i] = pc->yv12_fb[ref_fb_index[i]].corrupted;
}
- dst_buffer[0] = pc->yv12_fb[dst_fb_idx].y_buffer;
- dst_buffer[1] = pc->yv12_fb[dst_fb_idx].u_buffer;
- dst_buffer[2] = pc->yv12_fb[dst_fb_idx].v_buffer;
+ /* Set up the buffer pointers */
+ lf_dst[0] = dst_buffer[0] = pc->yv12_fb[dst_fb_idx].y_buffer;
+ lf_dst[1] = dst_buffer[1] = pc->yv12_fb[dst_fb_idx].u_buffer;
+ lf_dst[2] = dst_buffer[2] = pc->yv12_fb[dst_fb_idx].v_buffer;
xd->up_available = 0;
+ /* Initialize the loop filter for this frame. */
+ if(pc->filter_level)
+ vp8_loop_filter_frame_init(pc, xd, pc->filter_level);
+
/* Decode the individual macro block */
for (mb_row = 0; mb_row < pc->mb_rows; mb_row++)
{
xd->recon_left[1] += 8;
xd->recon_left[2] += 8;
-
recon_yoffset += 16;
recon_uvoffset += 8;
++xd->mode_info_context; /* next mb */
xd->above_context++;
-
}
/* adjust to the next row of mbs */
- vp8_extend_mb_row(
- &pc->yv12_fb[dst_fb_idx],
- xd->dst.y_buffer + 16, xd->dst.u_buffer + 8, xd->dst.v_buffer + 8
- );
+ vp8_extend_mb_row(&pc->yv12_fb[dst_fb_idx], xd->dst.y_buffer + 16,
+ xd->dst.u_buffer + 8, xd->dst.v_buffer + 8);
++xd->mode_info_context; /* skip prediction column */
xd->up_available = 1;
+ if(pc->filter_level)
+ {
+ if(mb_row > 0)
+ {
+ if (pc->filter_type == NORMAL_LOOPFILTER)
+ vp8_loop_filter_row_normal(pc, lf_mic, mb_row-1,
+ recon_y_stride, recon_uv_stride,
+ lf_dst[0], lf_dst[1], lf_dst[2]);
+ else
+ vp8_loop_filter_row_simple(pc, lf_mic, mb_row-1,
+ recon_y_stride, recon_uv_stride,
+ lf_dst[0], lf_dst[1], lf_dst[2]);
+ lf_dst[0] += recon_y_stride * 16;
+ lf_dst[1] += recon_uv_stride * 8;
+ lf_dst[2] += recon_uv_stride * 8;
+ lf_mic += pc->mb_cols;
+ lf_mic++; /* Skip border mb */
+ }
+ }
+ }
+
+ if(pc->filter_level)
+ {
+ if (pc->filter_type == NORMAL_LOOPFILTER)
+ vp8_loop_filter_row_normal(pc, lf_mic, mb_row-1, recon_y_stride,
+ recon_uv_stride, lf_dst[0], lf_dst[1],
+ lf_dst[2]);
+ else
+ vp8_loop_filter_row_simple(pc, lf_mic, mb_row-1, recon_y_stride,
+ recon_uv_stride, lf_dst[0], lf_dst[1],
+ lf_dst[2]);
}
+
+ vp8_yv12_extend_frame_borders(&pc->yv12_fb[dst_fb_idx]);
}
static unsigned int read_partition_size(const unsigned char *cx_size)
if (read_is_valid(partition_size_ptr, 3, first_fragment_end))
partition_size = read_partition_size(partition_size_ptr);
else if (pbi->ec_active)
- partition_size = bytes_left;
+ partition_size = (unsigned int)bytes_left;
else
vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
"Truncated partition size data");
}
else
- partition_size = bytes_left;
+ partition_size = (unsigned int)bytes_left;
/* Validate the calculated partition length. If the buffer
* described by the partition can't be fully read, then restrict
if (!read_is_valid(fragment_start, partition_size, fragment_end))
{
if (pbi->ec_active)
- partition_size = bytes_left;
+ partition_size = (unsigned int)bytes_left;
else
vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
"Truncated packet or corrupt partition "
/* Size of first partition + token partition sizes element */
ptrdiff_t ext_first_part_size = token_part_sizes -
pbi->fragments[0] + 3 * (num_token_partitions - 1);
- fragment_size -= ext_first_part_size;
+ fragment_size -= (unsigned int)ext_first_part_size;
if (fragment_size > 0)
{
- pbi->fragment_sizes[0] = ext_first_part_size;
+ pbi->fragment_sizes[0] = (unsigned int)ext_first_part_size;
/* The fragment contains an additional partition. Move to
* next. */
fragment_idx++;
fragment_end,
fragment_idx - 1,
num_token_partitions);
- pbi->fragment_sizes[fragment_idx] = partition_size;
- fragment_size -= partition_size;
+ pbi->fragment_sizes[fragment_idx] = (unsigned int)partition_size;
+ fragment_size -= (unsigned int)partition_size;
assert(fragment_idx <= num_token_partitions);
if (fragment_size > 0)
{
init_frame(pbi);
- if (vp8dx_start_decode(bc, data, data_end - data))
+ if (vp8dx_start_decode(bc, data, (unsigned int)(data_end - data)))
vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
"Failed to allocate bool decoder 0");
if (pc->frame_type == KEY_FRAME) {
pbi->num_fragments = 0;
return -1;
}
-
- if(cm->filter_level)
- {
- /* Apply the loop filter if appropriate. */
- vp8_loop_filter_frame(cm, &pbi->mb, cm->frame_type);
- }
- vp8_yv12_extend_frame_borders(cm->frame_to_show);
}
-
vp8_clear_system_state();
#if CONFIG_ERROR_CONCEALMENT
{
BLOCKD *b = &xd->block[i];
unsigned char *dst = xd->dst.y_buffer + b->offset;
- int b_mode = xd->mode_info_context->bmi[i].as_mode;
+ B_PREDICTION_MODE b_mode =
+ xd->mode_info_context->bmi[i].as_mode;
unsigned char *Above;
unsigned char *yleft;
int left_stride;
{
const TOKENEXTRA *p = cpi->tplist[mb_row].start;
const TOKENEXTRA *stop = cpi->tplist[mb_row].stop;
- int tokens = stop - p;
+ int tokens = (int)(stop - p);
vp8_pack_tokens_c(w, p, tokens);
}
{
const TOKENEXTRA *p = cpi->tplist[mb_row].start;
const TOKENEXTRA *stop = cpi->tplist[mb_row].stop;
- int tokens = stop - p;
+ int tokens = (int)(stop - p);
vp8_pack_tokens_c(w, p, tokens);
}
mv_row = x->best_sse_mv.as_mv.row;
if (frame == INTRA_FRAME ||
- (mv_row *mv_row + mv_col *mv_col <= NOISE_MOTION_THRESHOLD &&
- sse_diff < SSE_DIFF_THRESHOLD))
+ ((unsigned int)(mv_row *mv_row + mv_col *mv_col)
+ <= NOISE_MOTION_THRESHOLD &&
+ sse_diff < (int)SSE_DIFF_THRESHOLD))
{
/*
* Handle intra blocks as referring to last frame with zero motion
#endif
- /* Count of last ref frame 0,0 usage */
- if ((xd->mode_info_context->mbmi.mode == ZEROMV) && (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME))
- cpi->inter_zz_count ++;
-
/* Special case code for cyclic refresh
* If cyclic update enabled then copy xd->mbmi.segment_id; (which
* may have been updated based on mode during
xd->subpixel_predict16x16 = vp8_bilinear_predict16x16;
}
- /* Reset frame count of inter 0,0 motion vector usage. */
- cpi->inter_zz_count = 0;
-
cpi->prediction_error = 0;
cpi->intra_error = 0;
cpi->skip_true_count = 0;
for (mb_row = 0; mb_row < cm->mb_rows; mb_row ++)
{
- cpi->tok_count += cpi->tplist[mb_row].stop - cpi->tplist[mb_row].start;
+ cpi->tok_count += (unsigned int)
+ (cpi->tplist[mb_row].stop - cpi->tplist[mb_row].start);
}
if (xd->segmentation_enabled)
x->src.v_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
}
- cpi->tok_count = tp - cpi->tok;
+ cpi->tok_count = (unsigned int)(tp - cpi->tok);
}
#if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
MB_ROW_COMP *mbri = (MB_ROW_COMP *)(((ENCODETHREAD_DATA *)p_data)->ptr2);
ENTROPY_CONTEXT_PLANES mb_row_left_context;
- const int nsync = cpi->mt_sync_range;
-
while (1)
{
if (cpi->b_multi_threaded == 0)
if (sem_wait(&cpi->h_event_start_encoding[ithread]) == 0)
{
+ const int nsync = cpi->mt_sync_range;
VP8_COMMON *cm = &cpi->common;
int mb_row;
MACROBLOCK *x = &mbri->mb;
#endif
- /* Count of last ref frame 0,0 usage */
- if ((xd->mode_info_context->mbmi.mode == ZEROMV) && (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME))
- cpi->inter_zz_count++;
-
/* Special case code for cyclic refresh
* If cyclic update enabled then copy
* xd->mbmi.segment_id; (which may have been updated
FIRSTPASS_STATS fps;
fps.frame = cm->current_video_frame ;
- fps.intra_error = intra_error >> 8;
- fps.coded_error = coded_error >> 8;
+ fps.intra_error = (double)(intra_error >> 8);
+ fps.coded_error = (double)(coded_error >> 8);
weight = simple_weight(cpi->Source);
/* TODO: handle the case when duration is set to 0, or something less
* than the full time between subsequent cpi->source_time_stamps
*/
- fps.duration = cpi->source->ts_end
- - cpi->source->ts_start;
+ fps.duration = (double)(cpi->source->ts_end
+ - cpi->source->ts_start);
/* don't want to do output stats with a stack variable! */
memcpy(&cpi->twopass.this_frame_stats,
/* Estimate of overhead bits per mb */
/* Correction to overhead bits for min allowed Q. */
overhead_bits_per_mb = overhead_bits / num_mbs;
- overhead_bits_per_mb *= pow( 0.98, (double)cpi->twopass.maxq_min_limit );
+ overhead_bits_per_mb = (int)(overhead_bits_per_mb *
+ pow( 0.98, (double)cpi->twopass.maxq_min_limit ));
/* Try and pick a max Q that will be high enough to encode the
* content at the given rate.
* Give average a chance to settle though.
*/
if ( (cpi->ni_frames >
- ((unsigned int)cpi->twopass.total_stats.count >> 8)) &&
+ ((int)cpi->twopass.total_stats.count >> 8)) &&
(cpi->ni_frames > 150) )
{
cpi->twopass.maxq_max_limit = ((cpi->ni_av_qi + 32) < cpi->worst_quality)
/* For cbr apply buffer related limits */
if (cpi->drop_frames_allowed)
{
- int df_buffer_level = cpi->oxcf.drop_frames_water_mark *
+ int64_t df_buffer_level = cpi->oxcf.drop_frames_water_mark *
(cpi->oxcf.optimal_buffer_level / 100);
if (cpi->buffer_level > df_buffer_level)
* so it now points at the ARF frame.
*/
half_gf_int = cpi->baseline_gf_interval >> 1;
- frames_after_arf = cpi->twopass.total_stats.count -
- this_frame->frame - 1;
+ frames_after_arf = (int)(cpi->twopass.total_stats.count -
+ this_frame->frame - 1);
switch (cpi->oxcf.arnr_type)
{
else
cpi->twopass.gf_group_bits = 0;
- cpi->twopass.gf_group_bits =
+ cpi->twopass.gf_group_bits = (int)(
(cpi->twopass.gf_group_bits < 0)
? 0
: (cpi->twopass.gf_group_bits > cpi->twopass.kf_group_bits)
- ? cpi->twopass.kf_group_bits : cpi->twopass.gf_group_bits;
+ ? cpi->twopass.kf_group_bits : cpi->twopass.gf_group_bits);
/* Clip cpi->twopass.gf_group_bits based on user supplied data rate
* variability limit (cpi->oxcf.two_pass_vbrmax_section)
/* Apply an additional limit for CBR */
if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
{
- if (cpi->twopass.gf_bits > (cpi->buffer_level >> 1))
- cpi->twopass.gf_bits = cpi->buffer_level >> 1;
+ if (cpi->twopass.gf_bits > (int)(cpi->buffer_level >> 1))
+ cpi->twopass.gf_bits = (int)(cpi->buffer_level >> 1);
}
/* Dont allow a negative value for gf_bits */
{
/* Adjust KF group bits and error remainin */
- cpi->twopass.kf_group_error_left -= gf_group_err;
+ cpi->twopass.kf_group_error_left -= (int64_t)gf_group_err;
cpi->twopass.kf_group_bits -= cpi->twopass.gf_group_bits;
if (cpi->twopass.kf_group_bits < 0)
* already happened)
*/
if (!cpi->source_alt_ref_pending && cpi->common.frame_type != KEY_FRAME)
- cpi->twopass.gf_group_error_left = gf_group_err - gf_first_frame_err;
+ cpi->twopass.gf_group_error_left = (int)(gf_group_err -
+ gf_first_frame_err);
else
- cpi->twopass.gf_group_error_left = gf_group_err;
+ cpi->twopass.gf_group_error_left = (int) gf_group_err;
cpi->twopass.gf_group_bits -= cpi->twopass.gf_bits - cpi->min_frame_bandwidth;
avg_stats(§ionstats);
- cpi->twopass.section_intra_rating =
- sectionstats.intra_error /
- DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
+ cpi->twopass.section_intra_rating = (unsigned int)
+ (sectionstats.intra_error /
+ DOUBLE_DIVIDE_CHECK(sectionstats.coded_error));
Ratio = sectionstats.intra_error / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
cpi->twopass.section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025);
}
/* Adjust error and bits remaining */
- cpi->twopass.gf_group_error_left -= modified_err;
+ cpi->twopass.gf_group_error_left -= (int)modified_err;
cpi->twopass.gf_group_bits -= target_frame_size;
if (cpi->twopass.gf_group_bits < 0)
*/
if (cpi->oxcf.error_resilient_mode)
{
- cpi->twopass.gf_group_bits = cpi->twopass.kf_group_bits;
- cpi->twopass.gf_group_error_left = cpi->twopass.kf_group_error_left;
+ cpi->twopass.gf_group_bits = (int)cpi->twopass.kf_group_bits;
+ cpi->twopass.gf_group_error_left =
+ (int)cpi->twopass.kf_group_error_left;
cpi->baseline_gf_interval = cpi->twopass.frames_to_key;
cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
cpi->source_alt_ref_pending = 0;
}
/* Keep a globally available copy of this and the next frame's iiratio. */
- cpi->twopass.this_iiratio = this_frame_intra_error /
- DOUBLE_DIVIDE_CHECK(this_frame_coded_error);
+ cpi->twopass.this_iiratio = (unsigned int)(this_frame_intra_error /
+ DOUBLE_DIVIDE_CHECK(this_frame_coded_error));
{
FIRSTPASS_STATS next_frame;
if ( lookup_next_frame_stats(cpi, &next_frame) != EOF )
{
- cpi->twopass.next_iiratio = next_frame.intra_error /
- DOUBLE_DIVIDE_CHECK(next_frame.coded_error);
+ cpi->twopass.next_iiratio = (unsigned int)(next_frame.intra_error /
+ DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
}
}
/* Set nominal per second bandwidth for this frame */
- cpi->target_bandwidth = cpi->per_frame_bandwidth * cpi->output_frame_rate;
+ cpi->target_bandwidth = (int)
+ (cpi->per_frame_bandwidth * cpi->output_frame_rate);
if (cpi->target_bandwidth < 0)
cpi->target_bandwidth = 0;
/* Account for mv, mode and other overheads. */
- overhead_bits = estimate_modemvcost(
+ overhead_bits = (int)estimate_modemvcost(
cpi, &cpi->twopass.total_left_stats );
/* Special case code for first frame. */
/* Additional special case for CBR if buffer is getting full. */
if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
{
- int opt_buffer_lvl = cpi->oxcf.optimal_buffer_level;
- int buffer_lvl = cpi->buffer_level;
+ int64_t opt_buffer_lvl = cpi->oxcf.optimal_buffer_level;
+ int64_t buffer_lvl = cpi->buffer_level;
/* If the buffer is near or above the optimal and this kf group is
* not being allocated much then increase the allocation a bit.
*/
if (buffer_lvl >= opt_buffer_lvl)
{
- int high_water_mark = (opt_buffer_lvl +
+ int64_t high_water_mark = (opt_buffer_lvl +
cpi->oxcf.maximum_buffer_size) >> 1;
int64_t av_group_bits;
avg_stats(§ionstats);
- cpi->twopass.section_intra_rating =
- sectionstats.intra_error
- / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
+ cpi->twopass.section_intra_rating = (unsigned int)
+ (sectionstats.intra_error
+ / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error));
Ratio = sectionstats.intra_error / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
cpi->twopass.section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025);
if (cpi->drop_frames_allowed)
{
- int df_buffer_level = cpi->oxcf.drop_frames_water_mark * (cpi->oxcf.optimal_buffer_level / 100);
+ int df_buffer_level = (int)(cpi->oxcf.drop_frames_water_mark
+ * (cpi->oxcf.optimal_buffer_level / 100));
if (cpi->buffer_level > df_buffer_level)
max_boost = ((double)((cpi->buffer_level - df_buffer_level) * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
/* Work out how many bits to allocate for the key frame itself */
if (1)
{
- int kf_boost = boost_score;
+ int kf_boost = (int)boost_score;
int allocation_chunks;
int Counter = cpi->twopass.frames_to_key;
int alt_kf_bits;
/* Apply an additional limit for CBR */
if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
{
- if (cpi->twopass.kf_bits > ((3 * cpi->buffer_level) >> 2))
- cpi->twopass.kf_bits = (3 * cpi->buffer_level) >> 2;
+ if (cpi->twopass.kf_bits > (int)((3 * cpi->buffer_level) >> 2))
+ cpi->twopass.kf_bits = (int)((3 * cpi->buffer_level) >> 2);
}
/* If the key frame is actually easier than the average for the
cpi->per_frame_bandwidth = cpi->twopass.kf_bits;
/* Convert to a per second bitrate */
- cpi->target_bandwidth = cpi->twopass.kf_bits * cpi->output_frame_rate;
+ cpi->target_bandwidth = (int)(cpi->twopass.kf_bits *
+ cpi->output_frame_rate);
}
/* Note the total error score of the kf group minus the key frame itself */
int new_width = cpi->oxcf.Width;
int new_height = cpi->oxcf.Height;
- int projected_buffer_level = cpi->buffer_level;
+ int projected_buffer_level = (int)cpi->buffer_level;
int tmp_q;
double projected_bits_perframe;
else
{
/* This accounts for how hard the section is... */
- bits_per_frame = cpi->twopass.kf_group_bits / cpi->twopass.frames_to_key;
+ bits_per_frame = (double)
+ (cpi->twopass.kf_group_bits / cpi->twopass.frames_to_key);
/* Dont turn to resampling in easy sections just because they
* have been assigned a small number of bits
bits_per_frame = (cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100);
/* Work out if spatial resampling is necessary */
- kf_q = estimate_kf_group_q(cpi, err_per_frame, bits_per_frame, group_iiratio);
+ kf_q = estimate_kf_group_q(cpi, err_per_frame,
+ (int)bits_per_frame, group_iiratio);
/* If we project a required Q higher than the maximum allowed Q then
* make a guess at the actual size of frames in this section
}
/* Guess at buffer level at the end of the section */
- projected_buffer_level = cpi->buffer_level - (int)((projected_bits_perframe - av_bits_per_frame) * cpi->twopass.frames_to_key);
+ projected_buffer_level = (int)
+ (cpi->buffer_level - (int)
+ ((projected_bits_perframe - av_bits_per_frame) *
+ cpi->twopass.frames_to_key));
if (0)
{
/* Now try again and see what Q we get with the smaller
* image size
*/
- kf_q = estimate_kf_group_q(cpi, err_per_frame * effective_size_ratio, bits_per_frame, group_iiratio);
+ kf_q = estimate_kf_group_q(cpi,
+ err_per_frame * effective_size_ratio,
+ (int)bits_per_frame, group_iiratio);
if (0)
{
cpi->mb.e_mbd.ref_lf_deltas[ALTREF_FRAME] = -2;
cpi->mb.e_mbd.mode_lf_deltas[0] = 4; /* BPRED */
- cpi->mb.e_mbd.mode_lf_deltas[1] = -2; /* Zero */
+
+ if(cpi->oxcf.Mode == MODE_REALTIME)
+ cpi->mb.e_mbd.mode_lf_deltas[1] = -12; /* Zero */
+ else
+ cpi->mb.e_mbd.mode_lf_deltas[1] = -2; /* Zero */
+
cpi->mb.e_mbd.mode_lf_deltas[2] = 2; /* New mv */
cpi->mb.e_mbd.mode_lf_deltas[3] = 4; /* Split mv */
}
cpi->gf_update_recommended = 0;
- /* Structures used to minitor GF usage */
+ /* Structures used to monitor GF usage */
vpx_free(cpi->gf_active_flags);
CHECK_MEM_ERROR(cpi->gf_active_flags,
- vpx_calloc(1, cm->mb_rows * cm->mb_cols));
+ vpx_calloc(sizeof(*cpi->gf_active_flags),
+ cm->mb_rows * cm->mb_cols));
cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
vpx_free(cpi->mb_activity_map);
CHECK_MEM_ERROR(cpi->mb_activity_map,
- vpx_calloc(sizeof(unsigned int),
+ vpx_calloc(sizeof(*cpi->mb_activity_map),
cm->mb_rows * cm->mb_cols));
vpx_free(cpi->mb_norm_activity_map);
CHECK_MEM_ERROR(cpi->mb_norm_activity_map,
- vpx_calloc(sizeof(unsigned int),
+ vpx_calloc(sizeof(*cpi->mb_norm_activity_map),
cm->mb_rows * cm->mb_cols));
+ /* allocate memory for storing last frame's MVs for MV prediction. */
+ vpx_free(cpi->lfmv);
+ CHECK_MEM_ERROR(cpi->lfmv, vpx_calloc((cm->mb_rows+2) * (cm->mb_cols+2),
+ sizeof(*cpi->lfmv)));
+ vpx_free(cpi->lf_ref_frame_sign_bias);
+ CHECK_MEM_ERROR(cpi->lf_ref_frame_sign_bias,
+ vpx_calloc((cm->mb_rows+2) * (cm->mb_cols+2),
+ sizeof(*cpi->lf_ref_frame_sign_bias)));
+ vpx_free(cpi->lf_ref_frame);
+ CHECK_MEM_ERROR(cpi->lf_ref_frame,
+ vpx_calloc((cm->mb_rows+2) * (cm->mb_cols+2),
+ sizeof(*cpi->lf_ref_frame)));
+
+ /* Create the encoder segmentation map and set all entries to 0 */
+ vpx_free(cpi->segmentation_map);
+ CHECK_MEM_ERROR(cpi->segmentation_map,
+ vpx_calloc(cm->mb_rows * cm->mb_cols,
+ sizeof(*cpi->segmentation_map)));
+ vpx_free(cpi->active_map);
+ CHECK_MEM_ERROR(cpi->active_map,
+ vpx_calloc(cm->mb_rows * cm->mb_cols,
+ sizeof(*cpi->active_map)));
+ vpx_memset(cpi->active_map , 1, (cm->mb_rows * cm->mb_cols));
+
#if CONFIG_MULTITHREAD
if (width < 640)
cpi->mt_sync_range = 1;
{
vpx_free(cpi->mt_current_mb_col);
CHECK_MEM_ERROR(cpi->mt_current_mb_col,
- vpx_malloc(sizeof(*cpi->mt_current_mb_col) * cm->mb_rows));
+ vpx_malloc(sizeof(*cpi->mt_current_mb_col) * cm->mb_rows));
}
#endif
vpx_free(cpi->tplist);
- CHECK_MEM_ERROR(cpi->tplist,
- vpx_malloc(sizeof(TOKENLIST) * cpi->common.mb_rows));
+ CHECK_MEM_ERROR(cpi->tplist, vpx_malloc(sizeof(TOKENLIST) * cm->mb_rows));
}
int64_t llden = denom;
int64_t llval = val;
- return llval * llnum / llden;
+ return (int)(llval * llnum / llden);
}
lc->maximum_buffer_size_in_ms = oxcf->maximum_buffer_size;
lc->starting_buffer_level =
- rescale(oxcf->starting_buffer_level,
+ rescale((int)(oxcf->starting_buffer_level),
lc->target_bandwidth, 1000);
if (oxcf->optimal_buffer_level == 0)
lc->optimal_buffer_level = lc->target_bandwidth / 8;
else
lc->optimal_buffer_level =
- rescale(oxcf->optimal_buffer_level,
+ rescale((int)(oxcf->optimal_buffer_level),
lc->target_bandwidth, 1000);
if (oxcf->maximum_buffer_size == 0)
lc->maximum_buffer_size = lc->target_bandwidth / 8;
else
lc->maximum_buffer_size =
- rescale(oxcf->maximum_buffer_size,
+ rescale((int)oxcf->maximum_buffer_size,
lc->target_bandwidth, 1000);
/* Work out the average size of a frame within this layer */
if (i > 0)
- lc->avg_frame_size_for_layer = (cpi->oxcf.target_bitrate[i] -
- cpi->oxcf.target_bitrate[i-1]) * 1000 /
- (lc->frame_rate - prev_layer_frame_rate);
+ lc->avg_frame_size_for_layer =
+ (int)((cpi->oxcf.target_bitrate[i] -
+ cpi->oxcf.target_bitrate[i-1]) * 1000 /
+ (lc->frame_rate - prev_layer_frame_rate));
lc->active_worst_quality = cpi->oxcf.worst_allowed_q;
lc->active_best_quality = cpi->oxcf.best_allowed_q;
lc->rate_correction_factor = 1.0;
lc->key_frame_rate_correction_factor = 1.0;
lc->gf_rate_correction_factor = 1.0;
- lc->inter_frame_target = 0.0;
+ lc->inter_frame_target = 0;
prev_layer_frame_rate = lc->frame_rate;
}
lc->target_bandwidth = oxcf->target_bitrate[i] * 1000;
lc->starting_buffer_level = rescale(
- oxcf->starting_buffer_level_in_ms,
+ (int)oxcf->starting_buffer_level_in_ms,
lc->target_bandwidth, 1000);
if (oxcf->optimal_buffer_level == 0)
lc->optimal_buffer_level = lc->target_bandwidth / 8;
else
lc->optimal_buffer_level = rescale(
- oxcf->optimal_buffer_level_in_ms,
+ (int)oxcf->optimal_buffer_level_in_ms,
lc->target_bandwidth, 1000);
if (oxcf->maximum_buffer_size == 0)
lc->maximum_buffer_size = lc->target_bandwidth / 8;
else
lc->maximum_buffer_size = rescale(
- oxcf->maximum_buffer_size_in_ms,
+ (int)oxcf->maximum_buffer_size_in_ms,
lc->target_bandwidth, 1000);
/* Work out the average size of a frame within this layer */
if (i > 0)
- lc->avg_frame_size_for_layer = (oxcf->target_bitrate[i] -
- oxcf->target_bitrate[i-1]) * 1000 /
- (lc->frame_rate - prev_layer_frame_rate);
+ lc->avg_frame_size_for_layer =
+ (int)((oxcf->target_bitrate[i] -
+ oxcf->target_bitrate[i-1]) * 1000 /
+ (lc->frame_rate - prev_layer_frame_rate));
prev_layer_frame_rate = lc->frame_rate;
}
cpi->oxcf.target_bandwidth *= 1000;
cpi->oxcf.starting_buffer_level =
- rescale(cpi->oxcf.starting_buffer_level,
+ rescale((int)cpi->oxcf.starting_buffer_level,
cpi->oxcf.target_bandwidth, 1000);
/* Set or reset optimal and maximum buffer levels. */
cpi->oxcf.optimal_buffer_level = cpi->oxcf.target_bandwidth / 8;
else
cpi->oxcf.optimal_buffer_level =
- rescale(cpi->oxcf.optimal_buffer_level,
+ rescale((int)cpi->oxcf.optimal_buffer_level,
cpi->oxcf.target_bandwidth, 1000);
if (cpi->oxcf.maximum_buffer_size == 0)
cpi->oxcf.maximum_buffer_size = cpi->oxcf.target_bandwidth / 8;
else
cpi->oxcf.maximum_buffer_size =
- rescale(cpi->oxcf.maximum_buffer_size,
+ rescale((int)cpi->oxcf.maximum_buffer_size,
cpi->oxcf.target_bandwidth, 1000);
/* Set up frame rate and related parameters rate control values. */
cpi->alt_is_last = 0 ;
cpi->gold_is_alt = 0 ;
- /* allocate memory for storing last frame's MVs for MV prediction. */
- CHECK_MEM_ERROR(cpi->lfmv, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int_mv)));
- CHECK_MEM_ERROR(cpi->lf_ref_frame_sign_bias, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int)));
- CHECK_MEM_ERROR(cpi->lf_ref_frame, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int)));
-
- /* Create the encoder segmentation map and set all entries to 0 */
- CHECK_MEM_ERROR(cpi->segmentation_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
-
- CHECK_MEM_ERROR(cpi->active_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
- vpx_memset(cpi->active_map , 1, (cpi->common.mb_rows * cpi->common.mb_cols));
cpi->active_map_enabled = 0;
#if 0
else if (cpi->pass == 2)
{
size_t packet_sz = sizeof(FIRSTPASS_STATS);
- int packets = oxcf->two_pass_stats_in.sz / packet_sz;
+ int packets = (int)(oxcf->two_pass_stats_in.sz / packet_sz);
cpi->twopass.stats_in_start = oxcf->two_pass_stats_in.buf;
cpi->twopass.stats_in = cpi->twopass.stats_in_start;
fprintf(f, "Layer\tBitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\t"
"GLPsnrP\tVPXSSIM\t\n");
- for (i=0; i<cpi->oxcf.number_of_layers; i++)
+ for (i=0; i<(int)cpi->oxcf.number_of_layers; i++)
{
double dr = (double)cpi->bytes_in_layer[i] *
8.0 / 1000.0 / time_encoded;
fprintf(f, "Layer\tBitRate\tSSIM_Y\tSSIM_U\tSSIM_V\tSSIM_A\t"
"Time(us)\n");
- for (i=0; i<cpi->oxcf.number_of_layers; i++)
+ for (i=0; i<(int)cpi->oxcf.number_of_layers; i++)
{
double dr = (double)cpi->bytes_in_layer[i] *
8.0 / 1000.0 / time_encoded;
for (i = 0; i < 4; i++)
pkt.data.psnr.psnr[i] = vp8_mse2psnr(pkt.data.psnr.samples[i], 255.0,
- pkt.data.psnr.sse[i]);
+ (double)(pkt.data.psnr.sse[i]));
vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
}
int undershoot_seen = 0;
#endif
- int drop_mark = cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100;
+ int drop_mark = (int)(cpi->oxcf.drop_frames_water_mark *
+ cpi->oxcf.optimal_buffer_level / 100);
int drop_mark75 = drop_mark * 2 / 3;
int drop_mark50 = drop_mark / 4;
int drop_mark25 = drop_mark / 8;
/* Per frame bit target for the alt ref frame */
cpi->per_frame_bandwidth = cpi->twopass.gf_bits;
/* per second target bitrate */
- cpi->target_bandwidth = cpi->twopass.gf_bits * cpi->output_frame_rate;
+ cpi->target_bandwidth = (int)(cpi->twopass.gf_bits *
+ cpi->output_frame_rate);
}
}
else
if (cpi->buffer_level < cpi->oxcf.maximum_buffer_size)
{
- buff_lvl_step = (cpi->oxcf.maximum_buffer_size - cpi->oxcf.optimal_buffer_level) / Adjustment;
+ buff_lvl_step = (int)
+ ((cpi->oxcf.maximum_buffer_size -
+ cpi->oxcf.optimal_buffer_level) /
+ Adjustment);
if (buff_lvl_step)
- Adjustment = (cpi->buffer_level - cpi->oxcf.optimal_buffer_level) / buff_lvl_step;
+ Adjustment = (int)
+ ((cpi->buffer_level -
+ cpi->oxcf.optimal_buffer_level) /
+ buff_lvl_step);
else
Adjustment = 0;
}
else if (cpi->buffer_level > cpi->oxcf.optimal_buffer_level)
{
- int Fraction = ((cpi->buffer_level - cpi->oxcf.optimal_buffer_level) * 128) / (cpi->oxcf.maximum_buffer_size - cpi->oxcf.optimal_buffer_level);
- int min_qadjustment = ((cpi->active_best_quality - cpi->best_quality) * Fraction) / 128;
+ int Fraction = (int)
+ (((cpi->buffer_level - cpi->oxcf.optimal_buffer_level) * 128)
+ / (cpi->oxcf.maximum_buffer_size -
+ cpi->oxcf.optimal_buffer_level));
+ int min_qadjustment = ((cpi->active_best_quality -
+ cpi->best_quality) * Fraction) / 128;
cpi->active_best_quality -= min_qadjustment;
}
}
}
+ /* Count last ref frame 0,0 usage on current encoded frame. */
+ {
+ int mb_row;
+ int mb_col;
+ /* Point to beginning of MODE_INFO arrays. */
+ MODE_INFO *tmp = cm->mi;
+
+ cpi->inter_zz_count = 0;
+
+ if(cm->frame_type != KEY_FRAME)
+ {
+ for (mb_row = 0; mb_row < cm->mb_rows; mb_row ++)
+ {
+ for (mb_col = 0; mb_col < cm->mb_cols; mb_col ++)
+ {
+ if(tmp->mbmi.mode == ZEROMV && tmp->mbmi.ref_frame == LAST_FRAME)
+ cpi->inter_zz_count++;
+ tmp++;
+ }
+ tmp++;
+ }
+ }
+ }
+
#if CONFIG_MULTI_RES_ENCODING
vp8_cal_dissimilarity(cpi);
#endif
for (i=cpi->current_layer+1; i<cpi->oxcf.number_of_layers; i++)
{
LAYER_CONTEXT *lc = &cpi->layer_context[i];
- int bits_off_for_this_layer = lc->target_bandwidth / lc->frame_rate
- - cpi->projected_frame_size;
+ int bits_off_for_this_layer =
+ (int)(lc->target_bandwidth / lc->frame_rate -
+ cpi->projected_frame_size);
lc->bits_off_target += bits_off_for_this_layer;
- cpi->last_time_stamp_seen;
/* do a step update if the duration changes by 10% */
if (last_duration)
- step = ((this_duration - last_duration) * 10 / last_duration);
+ step = (int)(((this_duration - last_duration) *
+ 10 / last_duration));
}
if (this_duration)
* frame rate. If we haven't seen 1 second yet, then average
* over the whole interval seen.
*/
- interval = cpi->source->ts_end - cpi->first_time_stamp_ever;
+ interval = (double)(cpi->source->ts_end -
+ cpi->first_time_stamp_ever);
if(interval > 10000000.0)
interval = 10000000;
vpx_usec_timer_mark(&tsctimer);
vpx_usec_timer_mark(&ticktimer);
- duration = vpx_usec_timer_elapsed(&ticktimer);
+ duration = (int)(vpx_usec_timer_elapsed(&ticktimer));
duration2 = (unsigned int)((double)duration / 2);
if (cm->frame_type != KEY_FRAME)
if (cpi->b_calculate_psnr)
{
- double ye,ue,ve;
+ uint64_t ye,ue,ve;
double frame_psnr;
YV12_BUFFER_CONFIG *orig = cpi->Source;
YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
int y_samples = orig->y_height * orig->y_width ;
int uv_samples = orig->uv_height * orig->uv_width ;
int t_samples = y_samples + 2 * uv_samples;
- int64_t sq_error, sq_error2;
+ double sq_error, sq_error2;
ye = calc_plane_error(orig->y_buffer, orig->y_stride,
recon->y_buffer, recon->y_stride, orig->y_width, orig->y_height);
ve = calc_plane_error(orig->v_buffer, orig->uv_stride,
recon->v_buffer, recon->uv_stride, orig->uv_width, orig->uv_height);
- sq_error = ye + ue + ve;
+ sq_error = (double)(ye + ue + ve);
frame_psnr = vp8_mse2psnr(t_samples, 255.0, sq_error);
- cpi->total_y += vp8_mse2psnr(y_samples, 255.0, ye);
- cpi->total_u += vp8_mse2psnr(uv_samples, 255.0, ue);
- cpi->total_v += vp8_mse2psnr(uv_samples, 255.0, ve);
+ cpi->total_y += vp8_mse2psnr(y_samples, 255.0, (double)ye);
+ cpi->total_u += vp8_mse2psnr(uv_samples, 255.0, (double)ue);
+ cpi->total_v += vp8_mse2psnr(uv_samples, 255.0, (double)ve);
cpi->total_sq_error += sq_error;
cpi->total += frame_psnr;
#if CONFIG_POSTPROC
ve = calc_plane_error(orig->v_buffer, orig->uv_stride,
pp->v_buffer, pp->uv_stride, orig->uv_width, orig->uv_height);
- sq_error2 = ye + ue + ve;
+ sq_error2 = (double)(ye + ue + ve);
frame_psnr2 = vp8_mse2psnr(t_samples, 255.0, sq_error2);
- cpi->totalp_y += vp8_mse2psnr(y_samples, 255.0, ye);
- cpi->totalp_u += vp8_mse2psnr(uv_samples, 255.0, ue);
- cpi->totalp_v += vp8_mse2psnr(uv_samples, 255.0, ve);
+ cpi->totalp_y += vp8_mse2psnr(y_samples,
+ 255.0, (double)ye);
+ cpi->totalp_u += vp8_mse2psnr(uv_samples,
+ 255.0, (double)ue);
+ cpi->totalp_v += vp8_mse2psnr(uv_samples,
+ 255.0, (double)ve);
cpi->total_sq_error2 += sq_error2;
cpi->totalp += frame_psnr2;
if (cpi->oxcf.number_of_layers > 1)
{
- int i;
+ unsigned int i;
for (i=cpi->current_layer;
i<cpi->oxcf.number_of_layers; i++)
if (cpi->oxcf.number_of_layers > 1)
{
- int i;
+ unsigned int i;
for (i=cpi->current_layer;
i<cpi->oxcf.number_of_layers; i++)
{
signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
int internal_delta_q[MAX_MB_SEGMENTS];
- const unsigned int range = 63;
+ const int range = 63;
int i;
// This method is currently incompatible with the cyclic refresh method
int target_bandwidth;
/* Layer specific coding parameters */
- int starting_buffer_level;
- int optimal_buffer_level;
- int maximum_buffer_size;
- int starting_buffer_level_in_ms;
- int optimal_buffer_level_in_ms;
- int maximum_buffer_size_in_ms;
+ int64_t starting_buffer_level;
+ int64_t optimal_buffer_level;
+ int64_t maximum_buffer_size;
+ int64_t starting_buffer_level_in_ms;
+ int64_t optimal_buffer_level_in_ms;
+ int64_t maximum_buffer_size_in_ms;
int avg_frame_size_for_layer;
- int buffer_level;
- int bits_off_target;
+ int64_t buffer_level;
+ int64_t bits_off_target;
int64_t total_actual_bits;
int total_target_vs_actual;
double frame_rate;
double ref_frame_rate;
int64_t buffer_level;
- int bits_off_target;
+ int64_t bits_off_target;
int rolling_target_bits;
int rolling_actual_bits;
vp8_refining_search_fn_t refining_search_sad;
vp8_diamond_search_fn_t diamond_search_sad;
vp8_variance_fn_ptr_t fn_ptr[BLOCK_MAX_SEGMENTS];
- unsigned int time_receive_data;
- unsigned int time_compress_data;
- unsigned int time_pick_lpf;
- unsigned int time_encode_mb_row;
+ uint64_t time_receive_data;
+ uint64_t time_compress_data;
+ uint64_t time_pick_lpf;
+ uint64_t time_encode_mb_row;
int base_skip_false_prob[128];
unsigned char *yleft = dst - 1;
unsigned char top_left = Above[-1];
- for (mode = B_DC_PRED; mode <= B_HE_PRED /*B_HU_PRED*/; mode++)
+ for (mode = B_DC_PRED; mode <= B_HE_PRED; mode++)
{
int this_rd;
}
}
- b->bmi.as_mode = (B_PREDICTION_MODE)(*best_mode);
+ b->bmi.as_mode = *best_mode;
vp8_encode_intra4x4block(x, ib);
return best_rd;
}
static void check_for_encode_breakout(unsigned int sse, MACROBLOCK* x)
{
- if (sse < x->encode_breakout)
+ MACROBLOCKD *xd = &x->e_mbd;
+
+ unsigned int threshold = (xd->block[0].dequant[1]
+ * xd->block[0].dequant[1] >>4);
+
+ if(threshold < x->encode_breakout)
+ threshold = x->encode_breakout;
+
+ if (sse < threshold )
{
/* Check u and v to make sure skip is ok */
unsigned int sse2 = 0;
{
/* boost defaults to half second */
int kf_boost;
- unsigned int target;
+ uint64_t target;
/* Clear down mmx registers to allow floating point in what follows */
vp8_clear_system_state();
target = max_rate;
}
- cpi->this_frame_target = target;
+ cpi->this_frame_target = (int)target;
/* TODO: if we separate rate targeting from Q targetting, move this.
* Reset the active worst quality to the baseline value for key frames.
/* Adapt target frame size with respect to any buffering constraints: */
if (cpi->buffered_mode)
{
- int one_percent_bits = 1 + cpi->oxcf.optimal_buffer_level / 100;
+ int one_percent_bits = (int)
+ (1 + cpi->oxcf.optimal_buffer_level / 100);
if ((cpi->buffer_level < cpi->oxcf.optimal_buffer_level) ||
(cpi->bits_off_target < cpi->oxcf.optimal_buffer_level))
if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
(cpi->buffer_level < cpi->oxcf.optimal_buffer_level))
{
- percent_low =
- (cpi->oxcf.optimal_buffer_level - cpi->buffer_level) /
- one_percent_bits;
+ percent_low = (int)
+ ((cpi->oxcf.optimal_buffer_level - cpi->buffer_level) /
+ one_percent_bits);
}
/* Are we overshooting the long term clip data rate... */
else if (cpi->bits_off_target < 0)
*/
if (cpi->auto_worst_q && cpi->ni_frames > 150)
{
- int critical_buffer_level;
+ int64_t critical_buffer_level;
/* For streaming applications the most important factor is
* cpi->buffer_level as this takes into account the
*/
cpi->active_worst_quality =
cpi->worst_quality -
- ((qadjustment_range * above_base) /
+ (int)((qadjustment_range * above_base) /
(cpi->oxcf.optimal_buffer_level*3>>2));
}
else
if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
&& (cpi->buffer_level > cpi->oxcf.optimal_buffer_level))
{
- percent_high = (cpi->buffer_level
+ percent_high = (int)((cpi->buffer_level
- cpi->oxcf.optimal_buffer_level)
- / one_percent_bits;
+ / one_percent_bits);
}
else if (cpi->bits_off_target > cpi->oxcf.optimal_buffer_level)
{
/* Update the buffer level variable. */
cpi->bits_off_target += cpi->av_per_frame_bandwidth;
if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size)
- cpi->bits_off_target = cpi->oxcf.maximum_buffer_size;
+ cpi->bits_off_target = (int)cpi->oxcf.maximum_buffer_size;
cpi->buffer_level = cpi->bits_off_target;
}
}
vpx_memcpy(best_dqcoeff, b->dqcoeff, 32);
}
}
- b->bmi.as_mode = (B_PREDICTION_MODE)(*best_mode);
+ b->bmi.as_mode = *best_mode;
vp8_short_idct4x4llm(best_dqcoeff, best_predictor, 16, dst, dst_stride);
VP8_COMMON_SRCS-$(HAVE_MEDIA) += common/arm/armv6/loopfilter_v6$(ASM)
VP8_COMMON_SRCS-$(HAVE_MEDIA) += common/arm/armv6/simpleloopfilter_v6$(ASM)
VP8_COMMON_SRCS-$(HAVE_MEDIA) += common/arm/armv6/sixtappredict8x4_v6$(ASM)
-#VP8_COMMON_SRCS-$(HAVE_MEDIA) += common/arm/armv6/intra4x4_predict_v6$(ASM)
+VP8_COMMON_SRCS-$(HAVE_MEDIA) += common/arm/armv6/intra4x4_predict_v6$(ASM)
VP8_COMMON_SRCS-$(HAVE_MEDIA) += common/arm/armv6/dequant_idct_v6$(ASM)
VP8_COMMON_SRCS-$(HAVE_MEDIA) += common/arm/armv6/dequantize_v6$(ASM)
VP8_COMMON_SRCS-$(HAVE_MEDIA) += common/arm/armv6/idct_blk_v6.c
if (cfg->g_pass == VPX_RC_LAST_PASS)
{
size_t packet_sz = sizeof(FIRSTPASS_STATS);
- int n_packets = cfg->rc_twopass_stats_in.sz / packet_sz;
+ int n_packets = (int)(cfg->rc_twopass_stats_in.sz /
+ packet_sz);
FIRSTPASS_STATS *stats;
if (!cfg->rc_twopass_stats_in.buf)
VP8_COMP *cpi = (VP8_COMP *)ctx->cpi;
/* Add the frame packet to the list of returned packets. */
- round = 1000000 * ctx->cfg.g_timebase.num / 2 - 1;
+ round = (vpx_codec_pts_t)1000000
+ * ctx->cfg.g_timebase.num / 2 - 1;
delta = (dst_end_time_stamp - dst_time_stamp);
pkt.kind = VPX_CODEC_CX_FRAME_PKT;
pkt.data.frame.pts =
(dst_time_stamp * ctx->cfg.g_timebase.den + round)
/ ctx->cfg.g_timebase.num / 10000000;
- pkt.data.frame.duration =
- (delta * ctx->cfg.g_timebase.den + round)
- / ctx->cfg.g_timebase.num / 10000000;
+ pkt.data.frame.duration = (unsigned long)
+ ((delta * ctx->cfg.g_timebase.den + round)
+ / ctx->cfg.g_timebase.num / 10000000);
pkt.data.frame.flags = lib_flags << 16;
if (lib_flags & FRAMEFLAGS_KEY)
return tsc;
#else
#if ARCH_X86_64
- return __rdtsc();
+ return (unsigned int)__rdtsc();
#else
__asm rdtsc;
#endif
case NESTEGG_SEEK_CUR: whence = SEEK_CUR; break;
case NESTEGG_SEEK_END: whence = SEEK_END; break;
};
- return fseek(userdata, offset, whence)? -1 : 0;
+ return fseek(userdata, (long)offset, whence)? -1 : 0;
}
goto fail;
*fps_num = (i - 1) * 1000000;
- *fps_den = tstamp / 1000;
+ *fps_den = (unsigned int)(tstamp / 1000);
return 0;
fail:
nestegg_destroy(input->nestegg_ctx);
That will have to wait until these tools support WebM natively.*/
sprintf(buffer, "YUV4MPEG2 C%s W%u H%u F%u:%u I%c\n",
"420jpeg", width, height, fps_num, fps_den, 'p');
- out_put(out, (unsigned char *)buffer, strlen(buffer), do_md5);
+ out_put(out, (unsigned char *)buffer,
+ (unsigned int)strlen(buffer), do_md5);
}
/* Try to determine the codec from the fourcc. */
vpx_usec_timer_start(&timer);
- if (vpx_codec_decode(&decoder, buf, buf_sz, NULL, 0))
+ if (vpx_codec_decode(&decoder, buf, (unsigned int)buf_sz, NULL, 0))
{
const char *detail = vpx_codec_error_detail(&decoder);
fprintf(stderr, "Failed to decode frame: %s\n", vpx_codec_error(&decoder));
}
vpx_usec_timer_mark(&timer);
- dx_time += vpx_usec_timer_elapsed(&timer);
+ dx_time += (unsigned int)vpx_usec_timer_elapsed(&timer);
++frame_in;
return;
pts = pkt->data.frame.pts;
- mem_put_le32(header, pkt->data.frame.sz);
+ mem_put_le32(header, (int)pkt->data.frame.sz);
mem_put_le32(header + 4, pts & 0xFFFFFFFF);
mem_put_le32(header + 8, pts >> 32);
static void write_ivf_frame_size(FILE *outfile, size_t size)
{
char header[4];
- mem_put_le32(header, size);
+ mem_put_le32(header, (int)size);
(void) fwrite(header, 1, 4, outfile);
}
#define WRITE_BUFFER(s) \
for(i = len-1; i>=0; i--)\
{ \
- x = *(const s *)buffer_in >> (i * CHAR_BIT); \
+ x = (char)(*(const s *)buffer_in >> (i * CHAR_BIT)); \
Ebml_Write(glob, &x, 1); \
}
void Ebml_Serialize(EbmlGlobal *glob, const void *buffer_in, int buffer_size, unsigned long len)
Ebml_StartSubElement(ebml, &startInfo, Info);
Ebml_SerializeUnsigned(ebml, TimecodeScale, 1000000);
Ebml_SerializeFloat(ebml, Segment_Duration,
- ebml->last_pts_ms + frame_time);
+ (double)(ebml->last_pts_ms + frame_time));
Ebml_SerializeString(ebml, 0x4D80, version_string);
Ebml_SerializeString(ebml, 0x5741, version_string);
Ebml_EndSubElement(ebml, &startInfo);
if(pts_ms - glob->cluster_timecode > SHRT_MAX)
start_cluster = 1;
else
- block_timecode = pts_ms - glob->cluster_timecode;
+ block_timecode = (unsigned short)pts_ms - glob->cluster_timecode;
is_keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY);
if(start_cluster || is_keyframe)
/* Open the new cluster */
block_timecode = 0;
glob->cluster_open = 1;
- glob->cluster_timecode = pts_ms;
+ glob->cluster_timecode = (uint32_t)pts_ms;
glob->cluster_pos = ftello(glob->stream);
Ebml_StartSubElement(glob, &glob->startCluster, Cluster); /* cluster */
Ebml_SerializeUnsigned(glob, Timecode, glob->cluster_timecode);
/* Write the Simple Block */
Ebml_WriteID(glob, SimpleBlock);
- block_length = pkt->data.frame.sz + 4;
+ block_length = (unsigned long)pkt->data.frame.sz + 4;
block_length |= 0x10000000;
Ebml_Serialize(glob, &block_length, sizeof(block_length), 4);
flags |= 0x08;
Ebml_Write(glob, &flags, 1);
- Ebml_Write(glob, pkt->data.frame.buf, pkt->data.frame.sz);
+ Ebml_Write(glob, pkt->data.frame.buf, (unsigned long)pkt->data.frame.sz);
}
int j;
float pct;
- pct = 100.0 * (float)bucket[i].count / (float)total;
+ pct = (float)(100.0 * bucket[i].count / total);
len = HIST_BAR_MAX * bucket[i].count / scale;
if(len < 1)
len = 1;
idx = hist->frames++ % hist->samples;
hist->pts[idx] = now;
- hist->sz[idx] = pkt->data.frame.sz;
+ hist->sz[idx] = (int)pkt->data.frame.sz;
if(now < cfg->rc_buf_initial_sz)
return;
return;
avg_bitrate = sum_sz * 8 * 1000 / (now - then);
- idx = avg_bitrate * (RATE_BINS/2) / (cfg->rc_target_bitrate * 1000);
+ idx = (int)(avg_bitrate * (RATE_BINS/2) / (cfg->rc_target_bitrate * 1000));
if(idx < 0)
idx = 0;
if(idx > RATE_BINS-1)
idx = RATE_BINS-1;
if(hist->bucket[idx].low > avg_bitrate)
- hist->bucket[idx].low = avg_bitrate;
+ hist->bucket[idx].low = (int)avg_bitrate;
if(hist->bucket[idx].high < avg_bitrate)
- hist->bucket[idx].high = avg_bitrate;
+ hist->bucket[idx].high = (int)avg_bitrate;
hist->bucket[idx].count++;
hist->total++;
}
{
double framerate = (double)global->framerate.num/global->framerate.den;
if (framerate > 0.0)
- stream->config.cfg.kf_max_dist = 5.0*framerate;
+ stream->config.cfg.kf_max_dist = (unsigned int)(5.0*framerate);
}
}
/ cfg->g_timebase.num / global->framerate.num;
vpx_usec_timer_start(&timer);
vpx_codec_encode(&stream->encoder, img, frame_start,
- next_frame_start - frame_start,
+ (unsigned long)(next_frame_start - frame_start),
0, global->deadline);
vpx_usec_timer_mark(&timer);
stream->cx_time += vpx_usec_timer_elapsed(&timer);
/* Update the hash */
if(!stream->ebml.debug)
stream->hash = murmur(pkt->data.frame.buf,
- pkt->data.frame.sz, stream->hash);
+ (int)pkt->data.frame.sz,
+ stream->hash);
write_webm_block(&stream->ebml, cfg, pkt);
}
return;
fprintf(stderr, "Stream %d PSNR (Overall/Avg/Y/U/V)", stream->index);
- ovpsnr = vp8_mse2psnr(stream->psnr_samples_total, 255.0,
- stream->psnr_sse_total);
+ ovpsnr = vp8_mse2psnr((double)stream->psnr_samples_total, 255.0,
+ (double)stream->psnr_sse_total);
fprintf(stderr, " %.3f", ovpsnr);
for (i = 0; i < 4; i++)
float usec_to_fps(uint64_t usec, unsigned int frames)
{
- return usec > 0 ? (float)frames * 1000000.0 / (float)usec : 0;
+ return (float)(usec > 0 ? frames * 1000000.0 / (float)usec : 0);
}
frame_avail ? &raw : NULL,
frames_in));
vpx_usec_timer_mark(&timer);
- cx_time += vpx_usec_timer_elapsed(&timer);
+ cx_time += (unsigned long)vpx_usec_timer_elapsed(&timer);
FOREACH_STREAM(update_quantizer_histogram(stream));
_nskip--;
}
else{
- ret=fread(buffer+i,1,1,_fin);
+ ret=(int)fread(buffer+i,1,1,_fin);
if(ret<1)return -1;
}
if(buffer[i]=='\n')break;
int c_sz;
int ret;
/*Read and skip the frame header.*/
- ret=fread(frame,1,6,_fin);
+ ret=(int)fread(frame,1,6,_fin);
if(ret<6)return 0;
if(memcmp(frame,"FRAME",5)){
fprintf(stderr,"Loss of framing in Y4M input data\n");
projects / libvpx / commitdiff