generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Roll chromium_revision 8af41b3..dcb0929 (324854:325030)

Browse Source 
This is a major libyuv update (almost 200 revisions):
d204db6..32ad6e0

Relevant changes:
* src/third_party/libyuv: d204db6..32ad6e0
* src/third_party/nss: d1edb68..9506806
Details: 8af41b3..dcb0929/DEPS

Since bayer and Q420 format support have been removed from libyuv, all tests related to those format are removed.

Clang version was not updated in this roll.

R=kjellander@webrtc.org
TBR=tommi

Review URL: https://webrtc-codereview.appspot.com/48989004

Cr-Commit-Position: refs/heads/master@{#9008}
This commit is contained in:
Magnus Jedvert 2015-04-15 17:22:22 +02:00
parent 3c3f646064
commit 4b76c02362
6 changed files with 1 additions and 373 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
DEPS
View File

@ -6,7 +6,7 @@
vars = {
'extra_gyp_flag': '-Dextra_gyp_flag=0',
'chromium_git': 'https://chromium.googlesource.com',
'chromium_revision': '8af41b356f3d3f97b7cbde771b039a0a46bff0de',
'chromium_revision': 'dcb092938514169fb8e285ac0286d2dcddf1ff78',
}
# NOTE: Prefer revision numbers to tags for svn deps. Use http rather than

1
talk/media/base/videocommon.h
View File

@ -83,7 +83,6 @@ enum FourCC {
// 2 Secondary YUV formats: row biplanar.
FOURCC_M420 = FOURCC('M', '4', '2', '0'),
FOURCC_Q420 = FOURCC('Q', '4', '2', '0'),
// 9 Primary RGB formats: 4 32 bpp, 2 24 bpp, 3 16 bpp.
FOURCC_ARGB = FOURCC('A', 'R', 'G', 'B'),

1
talk/media/base/videoframe.cc
View File

@ -276,7 +276,6 @@ bool VideoFrame::Validate(uint32 fourcc, int w, int h,
case FOURCC_YU12:
case FOURCC_YV12:
case FOURCC_M420:
case FOURCC_Q420:
case FOURCC_NV21:
case FOURCC_NV12:
expected_bpp = 12;

242
talk/media/base/videoframe_unittest.h
View File

@ -33,7 +33,6 @@
#include "libyuv/convert.h"
#include "libyuv/convert_from.h"
#include "libyuv/format_conversion.h"
#include "libyuv/planar_functions.h"
#include "libyuv/rotate.h"
#include "talk/media/base/testutils.h"
@ -630,15 +629,6 @@ class VideoFrameTest : public testing::Test {
kWidth, kHeight, &frame));
}
void ConstructQ420() {
T frame;
rtc::scoped_ptr<rtc::MemoryStream> ms(
CreateYuvSample(kWidth, kHeight, 12));
ASSERT_TRUE(ms.get() != NULL);
EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_Q420,
kWidth, kHeight, &frame));
}
void ConstructNV21() {
T frame;
rtc::scoped_ptr<rtc::MemoryStream> ms(
@ -789,38 +779,6 @@ class VideoFrameTest : public testing::Test {
EXPECT_TRUE(IsEqual(frame1, frame2, 20));
}
// Macro to help test different Bayer formats.
// Error threshold of 60 allows for Bayer format subsampling.
// TODO(fbarchard): Refactor this test to go from Bayer to I420 and
// back to bayer, which would be less lossy.
#define TEST_BYR(NAME, BAYER) \
void NAME() { \
size_t bayer_size = kWidth * kHeight; \
rtc::scoped_ptr<uint8[]> bayerbuf(new uint8[ \
bayer_size + kAlignment]); \
uint8* bayer = ALIGNP(bayerbuf.get(), kAlignment); \
T frame1, frame2; \
rtc::scoped_ptr<rtc::MemoryStream> ms( \
CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight)); \
ASSERT_TRUE(ms.get() != NULL); \
libyuv::ARGBToBayer##BAYER(reinterpret_cast<uint8* >(ms->GetBuffer()), \
kWidth * 4, \
bayer, kWidth, \
kWidth, kHeight); \
EXPECT_TRUE(LoadFrame(bayer, bayer_size, cricket::FOURCC_##BAYER, \
kWidth, kHeight, &frame1)); \
EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ARGB, kWidth, kHeight, \
&frame2)); \
EXPECT_TRUE(IsEqual(frame1, frame2, 60)); \
}
// Test constructing an image from Bayer formats.
TEST_BYR(ConstructBayerGRBG, GRBG)
TEST_BYR(ConstructBayerGBRG, GBRG)
TEST_BYR(ConstructBayerBGGR, BGGR)
TEST_BYR(ConstructBayerRGGB, RGGB)
// Macro to help test different rotations
#define TEST_MIRROR(FOURCC, BPP) \
void Construct##FOURCC##Mirror() { \
@ -1547,22 +1505,6 @@ class VideoFrameTest : public testing::Test {
ConvertToBuffer(2, 0, false, TO, kError,
cricket::FOURCC_R444, libyuv::ARGB4444ToI420);
}
void ConvertToBayerBGGRBuffer() {
ConvertToBuffer(1, 0, false, TO, kErrorHigh,
cricket::FOURCC_BGGR, libyuv::BayerBGGRToI420);
}
void ConvertToBayerGBRGBuffer() {
ConvertToBuffer(1, 0, false, TO, kErrorHigh,
cricket::FOURCC_GBRG, libyuv::BayerGBRGToI420);
}
void ConvertToBayerGRBGBuffer() {
ConvertToBuffer(1, 0, false, TO, kErrorHigh,
cricket::FOURCC_GRBG, libyuv::BayerGRBGToI420);
}
void ConvertToBayerRGGBBuffer() {
ConvertToBuffer(1, 0, false, TO, kErrorHigh,
cricket::FOURCC_RGGB, libyuv::BayerRGGBToI420);
}
void ConvertToI400Buffer() {
ConvertToBuffer(1, 0, false, TO, 128,
cricket::FOURCC_I400, libyuv::I400ToI420);
@ -1609,22 +1551,6 @@ class VideoFrameTest : public testing::Test {
ConvertToBuffer(2, kOddStride, false, TO, kError,
cricket::FOURCC_R444, libyuv::ARGB4444ToI420);
}
void ConvertToBayerBGGRBufferStride() {
ConvertToBuffer(1, kOddStride, false, TO, kErrorHigh,
cricket::FOURCC_BGGR, libyuv::BayerBGGRToI420);
}
void ConvertToBayerGBRGBufferStride() {
ConvertToBuffer(1, kOddStride, false, TO, kErrorHigh,
cricket::FOURCC_GBRG, libyuv::BayerGBRGToI420);
}
void ConvertToBayerGRBGBufferStride() {
ConvertToBuffer(1, kOddStride, false, TO, kErrorHigh,
cricket::FOURCC_GRBG, libyuv::BayerGRBGToI420);
}
void ConvertToBayerRGGBBufferStride() {
ConvertToBuffer(1, kOddStride, false, TO, kErrorHigh,
cricket::FOURCC_RGGB, libyuv::BayerRGGBToI420);
}
void ConvertToI400BufferStride() {
ConvertToBuffer(1, kOddStride, false, TO, 128,
cricket::FOURCC_I400, libyuv::I400ToI420);
@ -1671,22 +1597,6 @@ class VideoFrameTest : public testing::Test {
ConvertToBuffer(2, 0, true, TO, kError,
cricket::FOURCC_R444, libyuv::ARGB4444ToI420);
}
void ConvertToBayerBGGRBufferInverted() {
ConvertToBuffer(1, 0, true, TO, kErrorHigh,
cricket::FOURCC_BGGR, libyuv::BayerBGGRToI420);
}
void ConvertToBayerGBRGBufferInverted() {
ConvertToBuffer(1, 0, true, TO, kErrorHigh,
cricket::FOURCC_GBRG, libyuv::BayerGBRGToI420);
}
void ConvertToBayerGRBGBufferInverted() {
ConvertToBuffer(1, 0, true, TO, kErrorHigh,
cricket::FOURCC_GRBG, libyuv::BayerGRBGToI420);
}
void ConvertToBayerRGGBBufferInverted() {
ConvertToBuffer(1, 0, true, TO, kErrorHigh,
cricket::FOURCC_RGGB, libyuv::BayerRGGBToI420);
}
void ConvertToI400BufferInverted() {
ConvertToBuffer(1, 0, true, TO, 128,
cricket::FOURCC_I400, libyuv::I400ToI420);
@ -1733,22 +1643,6 @@ class VideoFrameTest : public testing::Test {
ConvertToBuffer(2, 0, false, FROM, kError,
cricket::FOURCC_R444, libyuv::ARGB4444ToI420);
}
void ConvertFromBayerBGGRBuffer() {
ConvertToBuffer(1, 0, false, FROM, kErrorHigh,
cricket::FOURCC_BGGR, libyuv::BayerBGGRToI420);
}
void ConvertFromBayerGBRGBuffer() {
ConvertToBuffer(1, 0, false, FROM, kErrorHigh,
cricket::FOURCC_GBRG, libyuv::BayerGBRGToI420);
}
void ConvertFromBayerGRBGBuffer() {
ConvertToBuffer(1, 0, false, FROM, kErrorHigh,
cricket::FOURCC_GRBG, libyuv::BayerGRBGToI420);
}
void ConvertFromBayerRGGBBuffer() {
ConvertToBuffer(1, 0, false, FROM, kErrorHigh,
cricket::FOURCC_RGGB, libyuv::BayerRGGBToI420);
}
void ConvertFromI400Buffer() {
ConvertToBuffer(1, 0, false, FROM, 128,
cricket::FOURCC_I400, libyuv::I400ToI420);
@ -1795,22 +1689,6 @@ class VideoFrameTest : public testing::Test {
ConvertToBuffer(2, kOddStride, false, FROM, kError,
cricket::FOURCC_R444, libyuv::ARGB4444ToI420);
}
void ConvertFromBayerBGGRBufferStride() {
ConvertToBuffer(1, kOddStride, false, FROM, kErrorHigh,
cricket::FOURCC_BGGR, libyuv::BayerBGGRToI420);
}
void ConvertFromBayerGBRGBufferStride() {
ConvertToBuffer(1, kOddStride, false, FROM, kErrorHigh,
cricket::FOURCC_GBRG, libyuv::BayerGBRGToI420);
}
void ConvertFromBayerGRBGBufferStride() {
ConvertToBuffer(1, kOddStride, false, FROM, kErrorHigh,
cricket::FOURCC_GRBG, libyuv::BayerGRBGToI420);
}
void ConvertFromBayerRGGBBufferStride() {
ConvertToBuffer(1, kOddStride, false, FROM, kErrorHigh,
cricket::FOURCC_RGGB, libyuv::BayerRGGBToI420);
}
void ConvertFromI400BufferStride() {
ConvertToBuffer(1, kOddStride, false, FROM, 128,
cricket::FOURCC_I400, libyuv::I400ToI420);
@ -1857,22 +1735,6 @@ class VideoFrameTest : public testing::Test {
ConvertToBuffer(2, 0, true, FROM, kError,
cricket::FOURCC_R444, libyuv::ARGB4444ToI420);
}
void ConvertFromBayerBGGRBufferInverted() {
ConvertToBuffer(1, 0, true, FROM, kErrorHigh,
cricket::FOURCC_BGGR, libyuv::BayerBGGRToI420);
}
void ConvertFromBayerGBRGBufferInverted() {
ConvertToBuffer(1, 0, true, FROM, kErrorHigh,
cricket::FOURCC_GBRG, libyuv::BayerGBRGToI420);
}
void ConvertFromBayerGRBGBufferInverted() {
ConvertToBuffer(1, 0, true, FROM, kErrorHigh,
cricket::FOURCC_GRBG, libyuv::BayerGRBGToI420);
}
void ConvertFromBayerRGGBBufferInverted() {
ConvertToBuffer(1, 0, true, FROM, kErrorHigh,
cricket::FOURCC_RGGB, libyuv::BayerRGGBToI420);
}
void ConvertFromI400BufferInverted() {
ConvertToBuffer(1, 0, true, FROM, 128,
cricket::FOURCC_I400, libyuv::I400ToI420);
@ -1910,110 +1772,6 @@ class VideoFrameTest : public testing::Test {
EXPECT_TRUE(IsEqual(frame1, frame2, 1));
}
#define TEST_TOBYR(NAME, BAYER) \
void NAME() { \
size_t bayer_size = kWidth * kHeight; \
rtc::scoped_ptr<uint8[]> bayerbuf(new uint8[ \
bayer_size + kAlignment]); \
uint8* bayer = ALIGNP(bayerbuf.get(), kAlignment); \
T frame; \
rtc::scoped_ptr<rtc::MemoryStream> ms( \
CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight)); \
ASSERT_TRUE(ms.get() != NULL); \
for (int i = 0; i < repeat_; ++i) { \
libyuv::ARGBToBayer##BAYER(reinterpret_cast<uint8*>(ms->GetBuffer()), \
kWidth * 4, \
bayer, kWidth, \
kWidth, kHeight); \
} \
rtc::scoped_ptr<rtc::MemoryStream> ms2( \
CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight)); \
size_t data_size; \
bool ret = ms2->GetSize(&data_size); \
EXPECT_TRUE(ret); \
libyuv::Bayer##BAYER##ToARGB(bayer, kWidth, \
reinterpret_cast<uint8*>(ms2->GetBuffer()), \
kWidth * 4, \
kWidth, kHeight); \
EXPECT_TRUE(IsPlaneEqual("argb", \
reinterpret_cast<uint8*>(ms->GetBuffer()), kWidth * 4, \
reinterpret_cast<uint8*>(ms2->GetBuffer()), kWidth * 4, \
kWidth * 4, kHeight, 240)); \
} \
void NAME##Unaligned() { \
size_t bayer_size = kWidth * kHeight; \
rtc::scoped_ptr<uint8[]> bayerbuf(new uint8[ \
bayer_size + 1 + kAlignment]); \
uint8* bayer = ALIGNP(bayerbuf.get(), kAlignment) + 1; \
T frame; \
rtc::scoped_ptr<rtc::MemoryStream> ms( \
CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight)); \
ASSERT_TRUE(ms.get() != NULL); \
for (int i = 0; i < repeat_; ++i) { \
libyuv::ARGBToBayer##BAYER(reinterpret_cast<uint8*>(ms->GetBuffer()), \
kWidth * 4, \
bayer, kWidth, \
kWidth, kHeight); \
} \
rtc::scoped_ptr<rtc::MemoryStream> ms2( \
CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight)); \
size_t data_size; \
bool ret = ms2->GetSize(&data_size); \
EXPECT_TRUE(ret); \
libyuv::Bayer##BAYER##ToARGB(bayer, kWidth, \
reinterpret_cast<uint8*>(ms2->GetBuffer()), \
kWidth * 4, \
kWidth, kHeight); \
EXPECT_TRUE(IsPlaneEqual("argb", \
reinterpret_cast<uint8*>(ms->GetBuffer()), kWidth * 4, \
reinterpret_cast<uint8*>(ms2->GetBuffer()), kWidth * 4, \
kWidth * 4, kHeight, 240)); \
}
// Tests ARGB to Bayer formats.
TEST_TOBYR(ConvertARGBToBayerGRBG, GRBG)
TEST_TOBYR(ConvertARGBToBayerGBRG, GBRG)
TEST_TOBYR(ConvertARGBToBayerBGGR, BGGR)
TEST_TOBYR(ConvertARGBToBayerRGGB, RGGB)
#define TEST_BYRTORGB(NAME, BAYER) \
void NAME() { \
size_t bayer_size = kWidth * kHeight; \
rtc::scoped_ptr<uint8[]> bayerbuf(new uint8[ \
bayer_size + kAlignment]); \
uint8* bayer1 = ALIGNP(bayerbuf.get(), kAlignment); \
for (int i = 0; i < kWidth * kHeight; ++i) { \
bayer1[i] = static_cast<uint8>(i * 33u + 183u); \
} \
T frame; \
rtc::scoped_ptr<rtc::MemoryStream> ms( \
CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight)); \
ASSERT_TRUE(ms.get() != NULL); \
for (int i = 0; i < repeat_; ++i) { \
libyuv::Bayer##BAYER##ToARGB(bayer1, kWidth, \
reinterpret_cast<uint8*>(ms->GetBuffer()), \
kWidth * 4, \
kWidth, kHeight); \
} \
rtc::scoped_ptr<uint8[]> bayer2buf(new uint8[ \
bayer_size + kAlignment]); \
uint8* bayer2 = ALIGNP(bayer2buf.get(), kAlignment); \
libyuv::ARGBToBayer##BAYER(reinterpret_cast<uint8*>(ms->GetBuffer()), \
kWidth * 4, \
bayer2, kWidth, \
kWidth, kHeight); \
EXPECT_TRUE(IsPlaneEqual("bayer", \
bayer1, kWidth, \
bayer2, kWidth, \
kWidth, kHeight, 0)); \
}
// Tests Bayer formats to ARGB.
TEST_BYRTORGB(ConvertBayerGRBGToARGB, GRBG)
TEST_BYRTORGB(ConvertBayerGBRGToARGB, GBRG)
TEST_BYRTORGB(ConvertBayerBGGRToARGB, BGGR)
TEST_BYRTORGB(ConvertBayerRGGBToARGB, RGGB)
///////////////////
// General tests //
///////////////////

29
talk/media/webrtc/webrtcvideoframe_unittest.cc
View File

@ -120,7 +120,6 @@ TEST_WEBRTCVIDEOFRAME(ConstructYuy2Wide)
TEST_WEBRTCVIDEOFRAME(ConstructYV12)
TEST_WEBRTCVIDEOFRAME(ConstructUyvy)
TEST_WEBRTCVIDEOFRAME(ConstructM420)
TEST_WEBRTCVIDEOFRAME(ConstructQ420)
TEST_WEBRTCVIDEOFRAME(ConstructNV21)
TEST_WEBRTCVIDEOFRAME(ConstructNV12)
TEST_WEBRTCVIDEOFRAME(ConstructABGR)
@ -217,18 +216,6 @@ TEST_WEBRTCVIDEOFRAME(ConvertToRGB24BufferInverted)
TEST_WEBRTCVIDEOFRAME(ConvertToRGB565Buffer)
TEST_WEBRTCVIDEOFRAME(ConvertToRGB565BufferStride)
TEST_WEBRTCVIDEOFRAME(ConvertToRGB565BufferInverted)
TEST_WEBRTCVIDEOFRAME(ConvertToBayerBGGRBuffer)
TEST_WEBRTCVIDEOFRAME(ConvertToBayerBGGRBufferStride)
TEST_WEBRTCVIDEOFRAME(ConvertToBayerBGGRBufferInverted)
TEST_WEBRTCVIDEOFRAME(ConvertToBayerGRBGBuffer)
TEST_WEBRTCVIDEOFRAME(ConvertToBayerGRBGBufferStride)
TEST_WEBRTCVIDEOFRAME(ConvertToBayerGRBGBufferInverted)
TEST_WEBRTCVIDEOFRAME(ConvertToBayerGBRGBuffer)
TEST_WEBRTCVIDEOFRAME(ConvertToBayerGBRGBufferStride)
TEST_WEBRTCVIDEOFRAME(ConvertToBayerGBRGBufferInverted)
TEST_WEBRTCVIDEOFRAME(ConvertToBayerRGGBBuffer)
TEST_WEBRTCVIDEOFRAME(ConvertToBayerRGGBBufferStride)
TEST_WEBRTCVIDEOFRAME(ConvertToBayerRGGBBufferInverted)
TEST_WEBRTCVIDEOFRAME(ConvertToI400Buffer)
TEST_WEBRTCVIDEOFRAME(ConvertToI400BufferStride)
TEST_WEBRTCVIDEOFRAME(ConvertToI400BufferInverted)
@ -262,18 +249,6 @@ TEST_WEBRTCVIDEOFRAME(ConvertFromRGB24BufferInverted)
TEST_WEBRTCVIDEOFRAME(ConvertFromRGB565Buffer)
TEST_WEBRTCVIDEOFRAME(ConvertFromRGB565BufferStride)
TEST_WEBRTCVIDEOFRAME(ConvertFromRGB565BufferInverted)
TEST_WEBRTCVIDEOFRAME(ConvertFromBayerBGGRBuffer)
TEST_WEBRTCVIDEOFRAME(ConvertFromBayerBGGRBufferStride)
TEST_WEBRTCVIDEOFRAME(ConvertFromBayerBGGRBufferInverted)
TEST_WEBRTCVIDEOFRAME(ConvertFromBayerGRBGBuffer)
TEST_WEBRTCVIDEOFRAME(ConvertFromBayerGRBGBufferStride)
TEST_WEBRTCVIDEOFRAME(ConvertFromBayerGRBGBufferInverted)
TEST_WEBRTCVIDEOFRAME(ConvertFromBayerGBRGBuffer)
TEST_WEBRTCVIDEOFRAME(ConvertFromBayerGBRGBufferStride)
TEST_WEBRTCVIDEOFRAME(ConvertFromBayerGBRGBufferInverted)
TEST_WEBRTCVIDEOFRAME(ConvertFromBayerRGGBBuffer)
TEST_WEBRTCVIDEOFRAME(ConvertFromBayerRGGBBufferStride)
TEST_WEBRTCVIDEOFRAME(ConvertFromBayerRGGBBufferInverted)
TEST_WEBRTCVIDEOFRAME(ConvertFromI400Buffer)
TEST_WEBRTCVIDEOFRAME(ConvertFromI400BufferStride)
TEST_WEBRTCVIDEOFRAME(ConvertFromI400BufferInverted)
@ -284,10 +259,6 @@ TEST_WEBRTCVIDEOFRAME(ConvertFromUYVYBuffer)
TEST_WEBRTCVIDEOFRAME(ConvertFromUYVYBufferStride)
TEST_WEBRTCVIDEOFRAME(ConvertFromUYVYBufferInverted)
// TEST_WEBRTCVIDEOFRAME(ConvertToI422Buffer)
TEST_WEBRTCVIDEOFRAME(ConvertARGBToBayerGRBG)
TEST_WEBRTCVIDEOFRAME(ConvertARGBToBayerGBRG)
TEST_WEBRTCVIDEOFRAME(ConvertARGBToBayerBGGR)
TEST_WEBRTCVIDEOFRAME(ConvertARGBToBayerRGGB)
TEST_WEBRTCVIDEOFRAME(CopyToBuffer)
TEST_WEBRTCVIDEOFRAME(CopyToFrame)
TEST_WEBRTCVIDEOFRAME(Write)

99
talk/session/media/planarfunctions_unittest.cc
View File

@ -30,7 +30,6 @@
#include "libyuv/convert.h"
#include "libyuv/convert_from.h"
#include "libyuv/convert_from_argb.h"
#include "libyuv/format_conversion.h"
#include "libyuv/mjpeg_decoder.h"
#include "libyuv/planar_functions.h"
#include "talk/media/base/testutils.h"
@ -255,57 +254,6 @@ class PlanarFunctionsTest : public testing::TestWithParam<int> {
}
return image_pointer;
}
// Generate a Red-Green-Blue inter-weaving chessboard-like
// Q420 testing image.
// The pattern looks like c0 c1 c2 c3 ...
// c1 c2 c3 c4 ...
// c2 c3 c4 c5 ...
// ...............
// The size of each chrome block is (block_size) x (block_size).
uint8* CreateFakeQ420TestingImage(int height, int width, int block_size,
uint8* &y_pointer, uint8* &yuy2_pointer) {
if (height <= 0 || width <= 0 || block_size <= 0) { return NULL; }
// Regularize the width of the output to be even.
int awidth = (width + 1) & ~1;
uint8* image_pointer = new uint8[(height / 2) * awidth * 2 +
((height + 1) / 2) * width + kAlignment];
y_pointer = ALIGNP(image_pointer, kAlignment);
yuy2_pointer = y_pointer + ((height + 1) / 2) * width;
uint8* current_yuy2_pointer = yuy2_pointer;
uint8* current_y_pointer = y_pointer;
for (int j = 0; j < height; ++j) {
if (j % 2 == 0) {
for (int i = 0; i < width; ++i) {
int color = ((i / block_size) + (j / block_size)) %
kTestingColorNum;
*(current_y_pointer++) = testing_color_y_[color];
}
} else {
for (int i = 0; i < awidth; i += 2, current_yuy2_pointer += 4) {
int color1 = ((i / block_size) + (j / block_size)) %
kTestingColorNum;
int color2 = (((i + 1) / block_size) + (j / block_size)) %
kTestingColorNum;
current_yuy2_pointer[0] = testing_color_y_[color1];
if (i < width) {
current_yuy2_pointer[1] = static_cast<uint8>(
(static_cast<uint32>(testing_color_u_[color1]) +
static_cast<uint32>(testing_color_u_[color2])) / 2);
current_yuy2_pointer[2] = testing_color_y_[color2];
current_yuy2_pointer[3] = static_cast<uint8>(
(static_cast<uint32>(testing_color_v_[color1]) +
static_cast<uint32>(testing_color_v_[color2])) / 2);
} else {
current_yuy2_pointer[1] = testing_color_u_[color1];
current_yuy2_pointer[2] = 0;
current_yuy2_pointer[3] = testing_color_v_[color1];
}
}
}
}
return image_pointer;
}
// Generate a Red-Green-Blue inter-weaving chessboard-like
// NV12 testing image.
@ -605,53 +553,6 @@ TEST_F(PlanarFunctionsTest, I422ToI420) {
if (dump_) { DumpYuvImage(y_output_pointer, kWidth, kHeight); }
}
TEST_P(PlanarFunctionsTest, Q420ToI420) {
// Get the unalignment offset
int unalignment = GetParam();
uint8 *y_pointer = NULL, *yuy2_pointer = NULL;
int y_pitch = kWidth;
int yuy2_pitch = 2 * ((kWidth + 1) & ~1);
int u_pitch = (kWidth + 1) >> 1;
int v_pitch = (kWidth + 1) >> 1;
int y_size = kHeight * kWidth;
int uv_size = ((kHeight + 1) >> 1) * ((kWidth + 1) >> 1);
int block_size = 2;
// Generate a fake input image.
rtc::scoped_ptr<uint8[]> yuv_input(
CreateFakeQ420TestingImage(kHeight, kWidth, block_size,
y_pointer, yuy2_pointer));
// Allocate space for the output image.
rtc::scoped_ptr<uint8[]> yuv_output(
new uint8[I420_SIZE(kHeight, kWidth) + kAlignment + unalignment]);
uint8 *y_output_pointer = ALIGNP(yuv_output.get(), kAlignment) +
unalignment;
uint8 *u_output_pointer = y_output_pointer + y_size;
uint8 *v_output_pointer = u_output_pointer + uv_size;
// Generate the expected output.
uint8 *y_expected_pointer = NULL, *u_expected_pointer = NULL,
*v_expected_pointer = NULL;
rtc::scoped_ptr<uint8[]> yuv_output_expected(
CreateFakeYuvTestingImage(kHeight, kWidth, block_size,
libyuv::kJpegYuv420,
y_expected_pointer, u_expected_pointer, v_expected_pointer));
for (int i = 0; i < repeat_; ++i) {
libyuv::Q420ToI420(y_pointer, y_pitch,
yuy2_pointer, yuy2_pitch,
y_output_pointer, y_pitch,
u_output_pointer, u_pitch,
v_output_pointer, v_pitch,
kWidth, kHeight);
}
// Compare the output frame with what is expected; expect exactly the same.
// Note: MSE should be set to a larger threshold if an odd block width
// is used, since the conversion will be lossy.
EXPECT_TRUE(IsMemoryEqual(y_output_pointer, y_expected_pointer,
I420_SIZE(kHeight, kWidth), 1.e-6));
if (dump_) { DumpYuvImage(y_output_pointer, kWidth, kHeight); }
}
TEST_P(PlanarFunctionsTest, M420ToI420) {
// Get the unalignment offset
int unalignment = GetParam();