webrtc/pc/yuvscaler_unittest.cc - Issue 2058043002: Delete GetExecutablePath and related unused code.

Unified Diff: webrtc/pc/yuvscaler_unittest.cc

Issue 2058043002: Delete GetExecutablePath and related unused code. (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master

Patch Set: Trivial rebase. Created 4 years, 6 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: webrtc/pc/yuvscaler_unittest.cc

diff --git a/webrtc/pc/yuvscaler_unittest.cc b/webrtc/pc/yuvscaler_unittest.cc

deleted file mode 100644

index a33d49523d799447a11144252dbe9979adf10b31..0000000000000000000000000000000000000000

--- a/webrtc/pc/yuvscaler_unittest.cc

+++ /dev/null

@@ -1,602 +0,0 @@

-/*

- *

- * 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 <memory>

-#include <sstream>

-#include "libyuv/cpu_id.h"

-#include "libyuv/scale.h"

-#include "webrtc/base/basictypes.h"

-#include "webrtc/base/flags.h"

-#include "webrtc/base/gunit.h"

-#include "webrtc/media/base/testutils.h"

-#if defined(_MSC_VER)

-#define ALIGN16(var) __declspec(align(16)) var

-#else

-#define ALIGN16(var) var __attribute__((aligned(16)))

-#endif

-using cricket::LoadPlanarYuvTestImage;

-using cricket::DumpPlanarYuvTestImage;

-DEFINE_bool(yuvscaler_dump, false,

- "whether to write out scaled images for inspection");

-DEFINE_int(yuvscaler_repeat, 1,

- "how many times to perform each scaling operation (for perf testing)");

-static const int kAlignment = 16;

-// TEST_UNCACHED flushes cache to test real memory performance.

-// TEST_RSTSC uses cpu cycles for more accurate benchmark of the scale function.

-#ifndef __arm__

-// #define TEST_UNCACHED 1

-// #define TEST_RSTSC 1

-#endif

-#if defined(TEST_UNCACHED) || defined(TEST_RSTSC)

-#ifdef _MSC_VER

-#include <emmintrin.h> // NOLINT

-#endif

-#if defined(__GNUC__) && defined(__i386__)

-static inline uint64_t __rdtsc(void) {

- uint32_t a, d;

- __asm__ volatile("rdtsc" : "=a" (a), "=d" (d));

- return (reinterpret_cast<uint64_t>(d) << 32) + a;

-static inline void _mm_clflush(volatile void *__p) {

- asm volatile("clflush %0" : "+m" (*(volatile char *)__p));

-#endif

-static void FlushCache(uint8_t* dst, int count) {

- while (count >= 32) {

- _mm_clflush(dst);

- dst += 32;

- count -= 32;

- }

-#endif

-class YuvScalerTest : public testing::Test {

- protected:

- virtual void SetUp() {

- dump_ = *rtc::FlagList::Lookup("yuvscaler_dump")->bool_variable();

- repeat_ = *rtc::FlagList::Lookup("yuvscaler_repeat")->int_variable();

- }

- // Scale an image and compare against a Lanczos-filtered test image.

- // Lanczos is considered to be the "ideal" image resampling method, so we try

- // to get as close to that as possible, while being as fast as possible.

- bool TestScale(int iw, int ih, int ow, int oh, int offset, bool usefile,

- bool optimize, int cpuflags, bool interpolate,

- int memoffset, double* error) {

- *error = 0.;

- size_t isize = I420_SIZE(iw, ih);

- size_t osize = I420_SIZE(ow, oh);

- std::unique_ptr<uint8_t[]> ibuffer(

- new uint8_t[isize + kAlignment + memoffset]());

- std::unique_ptr<uint8_t[]> obuffer(

- new uint8_t[osize + kAlignment + memoffset]());

- std::unique_ptr<uint8_t[]> xbuffer(

- new uint8_t[osize + kAlignment + memoffset]());

- uint8_t* ibuf = ALIGNP(ibuffer.get(), kAlignment) + memoffset;

- uint8_t* obuf = ALIGNP(obuffer.get(), kAlignment) + memoffset;

- uint8_t* xbuf = ALIGNP(xbuffer.get(), kAlignment) + memoffset;

- if (usefile) {

- if (!LoadPlanarYuvTestImage("faces", iw, ih, ibuf) ||

- !LoadPlanarYuvTestImage("faces", ow, oh, xbuf)) {

- LOG(LS_ERROR) << "Failed to load image";

- return false;

- }

- } else {

- // These are used to test huge images.

- memset(ibuf, 213, isize); // Input is constant color.

- memset(obuf, 100, osize); // Output set to something wrong for now.

- memset(xbuf, 213, osize); // Expected result.

- }

-#ifdef TEST_UNCACHED

- FlushCache(ibuf, isize);

- FlushCache(obuf, osize);

- FlushCache(xbuf, osize);

-#endif

- // Scale down.

- // If cpu true, disable cpu optimizations. Else allow auto detect

- // TODO(fbarchard): set flags for libyuv

- libyuv::MaskCpuFlags(cpuflags);

-#ifdef TEST_RSTSC

- uint64_t t = 0;

-#endif

- for (int i = 0; i < repeat_; ++i) {

-#ifdef TEST_UNCACHED

- FlushCache(ibuf, isize);

- FlushCache(obuf, osize);

-#endif

-#ifdef TEST_RSTSC

- uint64_t t1 = __rdtsc();

-#endif

- EXPECT_EQ(0, libyuv::ScaleOffset(ibuf, iw, ih, obuf, ow, oh,

- offset, interpolate));

-#ifdef TEST_RSTSC

- uint64_t t2 = __rdtsc();

- t += t2 - t1;

-#endif

- }

-#ifdef TEST_RSTSC

- LOG(LS_INFO) << "Time: " << std::setw(9) << t;

-#endif

- if (dump_) {

- const testing::TestInfo* const test_info =

- testing::UnitTest::GetInstance()->current_test_info();

- std::string test_name(test_info->name());

- DumpPlanarYuvTestImage(test_name, obuf, ow, oh);

- }

- double sse = cricket::ComputeSumSquareError(obuf, xbuf, osize);

- *error = sse / osize; // Mean Squared Error.

- double PSNR = cricket::ComputePSNR(sse, osize);

- LOG(LS_INFO) << "Image MSE: " <<

- std::setw(6) << std::setprecision(4) << *error <<

- " Image PSNR: " << PSNR;

- return true;

- }

- // Returns the index of the first differing byte. Easier to debug than memcmp.

- static int FindDiff(const uint8_t* buf1, const uint8_t* buf2, int len) {

- int i = 0;

- while (i < len && buf1[i] == buf2[i]) {

- i++;

- }

- return (i < len) ? i : -1;

- }

- protected:

- bool dump_;

- int repeat_;

-};

-// Tests straight copy of data.

-TEST_F(YuvScalerTest, TestCopy) {

- const int iw = 640, ih = 360;

- const int ow = 640, oh = 360;

- ALIGN16(uint8_t ibuf[I420_SIZE(iw, ih)]);

- ALIGN16(uint8_t obuf[I420_SIZE(ow, oh)]);

- // Load the frame, scale it, check it.

- ASSERT_TRUE(LoadPlanarYuvTestImage("faces", iw, ih, ibuf));

- for (int i = 0; i < repeat_; ++i) {

- libyuv::ScaleOffset(ibuf, iw, ih, obuf, ow, oh, 0, false);

- }

- if (dump_) DumpPlanarYuvTestImage("TestCopy", obuf, ow, oh);

- EXPECT_EQ(-1, FindDiff(obuf, ibuf, sizeof(ibuf)));

-// Tests copy from 4:3 to 16:9.

-TEST_F(YuvScalerTest, TestOffset16_10Copy) {

- const int iw = 640, ih = 360;

- const int ow = 640, oh = 480;

- const int offset = (480 - 360) / 2;

- std::unique_ptr<uint8_t[]> ibuffer(

- new uint8_t[I420_SIZE(iw, ih) + kAlignment]);

- std::unique_ptr<uint8_t[]> obuffer(

- new uint8_t[I420_SIZE(ow, oh) + kAlignment]);

- uint8_t* ibuf = ALIGNP(ibuffer.get(), kAlignment);

- uint8_t* obuf = ALIGNP(obuffer.get(), kAlignment);

- // Load the frame, scale it, check it.

- ASSERT_TRUE(LoadPlanarYuvTestImage("faces", iw, ih, ibuf));

- // Clear to black, which is Y = 0 and U and V = 128

- memset(obuf, 0, ow * oh);

- memset(obuf + ow * oh, 128, ow * oh / 2);

- for (int i = 0; i < repeat_; ++i) {

- libyuv::ScaleOffset(ibuf, iw, ih, obuf, ow, oh, offset, false);

- }

- if (dump_) DumpPlanarYuvTestImage("TestOffsetCopy16_9", obuf, ow, oh);

- EXPECT_EQ(-1, FindDiff(obuf + ow * offset,

- ibuf,

- iw * ih));

- EXPECT_EQ(-1, FindDiff(obuf + ow * oh + ow * offset / 4,

- ibuf + iw * ih,

- iw * ih / 4));

- EXPECT_EQ(-1, FindDiff(obuf + ow * oh * 5 / 4 + ow * offset / 4,

- ibuf + iw * ih * 5 / 4,

- iw * ih / 4));

-// The following are 'cpu' flag values:

-// Allow all SIMD optimizations

-#define ALLFLAGS -1

-// Disable SSSE3 but allow other forms of SIMD (SSE2)

-#define NOSSSE3 ~libyuv::kCpuHasSSSE3

-// Disable SSE2 and SSSE3

-#define NOSSE ~libyuv::kCpuHasSSE2 & ~libyuv::kCpuHasSSSE3

-// TEST_M scale factor with variations of opt, align, int

-#define TEST_M(name, iwidth, iheight, owidth, oheight, mse) \

-TEST_F(YuvScalerTest, name##Ref) { \

- double error; \