scale_test.cc File Reference

#include <stdlib.h>
#include <time.h>
#include "libyuv/cpu_id.h"
#include "libyuv/scale.h"
#include "../unit_test/unit_test.h"

Namespaces
	libyuv

Macros
#define	STRINGIZE(line)   #line
#define	FILELINESTR(file, line)   file ":" STRINGIZE(line)
#define	DX(x, nom, denom)   static_cast<int>(((Abs(x) / nom + 1) / 2) * nom * 2)
#define	SX(x, nom, denom)   static_cast<int>(((x / nom + 1) / 2) * denom * 2)
#define	TEST_FACTOR1(name, filter, nom, denom, max_diff)
#define	TEST_FACTOR(name, nom, denom, boxdiff)
#define	TEST_SCALETO1(name, width, height, filter, max_diff)
#define	TEST_SCALETO(name, width, height)

Macro Definition Documentation

DX

#define DX	(		x,
			nom,
			denom
	)		static_cast<int>(((Abs(x) / nom + 1) / 2) * nom * 2)

FILELINESTR

#define FILELINESTR	(		file,
			line
	)		file ":" STRINGIZE(line)

STRINGIZE

#define STRINGIZE

(

line

)

#line

SX

#define SX	(		x,
			nom,
			denom
	)		static_cast<int>(((x / nom + 1) / 2) * denom * 2)

TEST_FACTOR

#define TEST_FACTOR	(		name,
			nom,
			denom,
			boxdiff
	)

Value:

TEST_FACTOR1(name, None, nom, denom, 0)                                    \
    TEST_FACTOR1(name, Linear, nom, denom, 3)                                  \
    TEST_FACTOR1(name, Bilinear, nom, denom, 3)                                \
    TEST_FACTOR1(name, Box, nom, denom, boxdiff)

TEST_FACTOR1

#define TEST_FACTOR1	(		name,
			filter,
			nom,
			denom,
			max_diff
	)

Value:

TEST_F(LibYUVScaleTest, ScaleDownBy##name##_##filter) {                    \
      int diff = TestFilter(SX(benchmark_width_, nom, denom),                  \
                            SX(benchmark_height_, nom, denom),                 \
                            DX(benchmark_width_, nom, denom),                  \
                            DX(benchmark_height_, nom, denom),                 \
                            kFilter##filter, benchmark_iterations_,            \
                            disable_cpu_flags_, benchmark_cpu_info_);          \
      EXPECT_LE(diff, max_diff);                                               \
    }                                                                          \
    TEST_F(LibYUVScaleTest, DISABLED_ScaleDownBy##name##_##filter##_16) {      \
      int diff = TestFilter_16(SX(benchmark_width_, nom, denom),               \
                               SX(benchmark_height_, nom, denom),              \
                               DX(benchmark_width_, nom, denom),               \
                               DX(benchmark_height_, nom, denom),              \
                               kFilter##filter, benchmark_iterations_);        \
      EXPECT_LE(diff, max_diff);                                               \
    }

TEST_SCALETO

#define TEST_SCALETO	(		name,
			width,
			height
	)

Value:

TEST_SCALETO1(name, width, height, None, 0)                                \
    TEST_SCALETO1(name, width, height, Linear, 0)                              \
    TEST_SCALETO1(name, width, height, Bilinear, 0)                            \
    TEST_SCALETO1(name, width, height, Box, 0)

TEST_SCALETO1

#define TEST_SCALETO1	(		name,
			width,
			height,
			filter,
			max_diff
	)

Value:

TEST_F(LibYUVScaleTest, name##To##width##x##height##_##filter) {           \
      int diff = TestFilter(benchmark_width_, benchmark_height_,               \
                            width, height,                                     \
                            kFilter##filter, benchmark_iterations_,            \
                            disable_cpu_flags_, benchmark_cpu_info_);          \
      EXPECT_LE(diff, max_diff);                                               \
    }                                                                          \
    TEST_F(LibYUVScaleTest, name##From##width##x##height##_##filter) {         \
      int diff = TestFilter(width, height,                                     \
                            Abs(benchmark_width_), Abs(benchmark_height_),     \
                            kFilter##filter, benchmark_iterations_,            \
                            disable_cpu_flags_, benchmark_cpu_info_);          \
      EXPECT_LE(diff, max_diff);                                               \
    }                                                                          \
    TEST_F(LibYUVScaleTest,                                                    \
        DISABLED_##name##To##width##x##height##_##filter##_16) {               \
      int diff = TestFilter_16(benchmark_width_, benchmark_height_,            \
                               width, height,                                  \
                               kFilter##filter, benchmark_iterations_);        \
      EXPECT_LE(diff, max_diff);                                               \
    }                                                                          \
    TEST_F(LibYUVScaleTest,                                                    \
        DISABLED_##name##From##width##x##height##_##filter##_16) {             \
      int diff = TestFilter_16(width, height,                                  \
                               Abs(benchmark_width_), Abs(benchmark_height_),  \
                               kFilter##filter, benchmark_iterations_);        \
      EXPECT_LE(diff, max_diff);                                               \
    }