Fix the WebRTC color bug.

media/base/yuv_convert_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/base_paths.h"
 #include "base/cpu.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "media/base/djb2.h"
@@ skipping 82 matching lines @@
                            yuv_bytes.get() + kSourceVOffset,
                            rgb_converted_bytes.get(),            // RGB output
                            kSourceWidth, kSourceHeight,          // Dimensions
                            kSourceWidth,                         // YStride
                            kSourceWidth / 2,                     // UVStride
                            kSourceWidth * kBpp,                  // RGBStride
                            media::YV12);
 
   uint32 rgb_hash = DJB2Hash(rgb_converted_bytes.get(), kRGBSizeConverted,
                              kDJB2HashSeed);
+#if defined(OS_ANDROID)
+  EXPECT_EQ(815021082u, rgb_hash);

[scherkus (not reviewing), 2013/06/19 19:49:50]

what about writing and using a BGRA->RGBA swizzler so that we don't need to
maintain two sets of hashes?

[hkuang1, 2013/06/19 23:21:11]

Done. Wrote a helper function to convert BGRA->RGBA every time before
calculating hash.

+#else
   EXPECT_EQ(2413171226u, rgb_hash);
+#endif
 }
 
 TEST(YUVConvertTest, YV16) {
   // Allocate all surfaces.
   scoped_ptr<uint8[]> yuv_bytes;
   scoped_ptr<uint8[]> rgb_bytes(new uint8[kRGBSize]);
   scoped_ptr<uint8[]> rgb_converted_bytes(new uint8[kRGBSizeConverted]);
 
   // Read YUV reference data from file.
   ReadYV16Data(&yuv_bytes);
 
   // Convert a frame of YUV to 32 bit ARGB.
   media::ConvertYUVToRGB32(yuv_bytes.get(),                        // Y
                            yuv_bytes.get() + kSourceUOffset,       // U
                            yuv_bytes.get() + kSourceYSize * 3 / 2, // V
                            rgb_converted_bytes.get(),              // RGB output
                            kSourceWidth, kSourceHeight,            // Dimensions
                            kSourceWidth,                           // YStride
                            kSourceWidth / 2,                       // UVStride
                            kSourceWidth * kBpp,                    // RGBStride
                            media::YV16);
 
   uint32 rgb_hash = DJB2Hash(rgb_converted_bytes.get(), kRGBSizeConverted,
                              kDJB2HashSeed);
+#if defined(OS_ANDROID)
+  EXPECT_EQ(3370743199u, rgb_hash);
+#else
   EXPECT_EQ(4222342047u, rgb_hash);
+#endif
 }
 
 struct YUVScaleTestData {
   YUVScaleTestData(media::YUVType y, media::ScaleFilter s, uint32 r)
       : yuv_type(y),
         scale_filter(s),
         rgb_hash(r) {
   }
 
   media::YUVType yuv_type;
@@ skipping 124 matching lines @@
                          kSourceWidth, kSourceHeight,  // Dimensions
                          3, 3,                         // Dimensions
                          kSourceWidth,                 // YStride
                          kSourceWidth / 2,             // UvStride
                          kScaledWidth * kBpp,          // RgbStride
                          GetParam().yuv_type,
                          media::ROTATE_0,
                          GetParam().scale_filter);
 }
 
+#if defined(OS_ANDROID)
 INSTANTIATE_TEST_CASE_P(
     YUVScaleFormats, YUVScaleTest,
     ::testing::Values(
+        YUVScaleTestData(media::YV12, media::FILTER_NONE, 2593983416u),
+        YUVScaleTestData(media::YV16, media::FILTER_NONE, 246995851u),
+        YUVScaleTestData(media::YV12, media::FILTER_BILINEAR, 293331713u),
+        YUVScaleTestData(media::YV16, media::FILTER_BILINEAR, 123521758u)));
+#else
+INSTANTIATE_TEST_CASE_P(
+    YUVScaleFormats, YUVScaleTest,
+    ::testing::Values(
         YUVScaleTestData(media::YV12, media::FILTER_NONE, 4136904952u),
         YUVScaleTestData(media::YV16, media::FILTER_NONE, 1501777547u),
         YUVScaleTestData(media::YV12, media::FILTER_BILINEAR, 3164274689u),
         YUVScaleTestData(media::YV16, media::FILTER_BILINEAR, 3095878046u)));
+#endif
 
 // This tests a known worst case YUV value, and for overflow.
 TEST(YUVConvertTest, Clamp) {
   // Allocate all surfaces.
   scoped_ptr<uint8[]> yuv_bytes(new uint8[1]);
   scoped_ptr<uint8[]> rgb_bytes(new uint8[1]);
   scoped_ptr<uint8[]> rgb_converted_bytes(new uint8[1]);
 
   // Values that failed previously in bug report.
   unsigned char y = 255u;
   unsigned char u = 255u;
   unsigned char v = 19u;
 
   // Prefill extra large destination buffer to test for overflow.
   unsigned char rgb[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
   unsigned char expected[8] = { 255, 255, 104, 255, 4, 5, 6, 7 };
   // Convert a frame of YUV to 32 bit ARGB.
   media::ConvertYUVToRGB32(&y,       // Y
                            &u,       // U
                            &v,       // V
                            &rgb[0],  // RGB output
                            1, 1,     // Dimensions
                            0,        // YStride
                            0,        // UVStride
                            0,        // RGBStride
                            media::YV12);
 
+#if defined(OS_ANDROID)
+  unsigned char expectedAndroid[8] = { 104, 255, 255, 255, 4, 5, 6, 7 };
+  int expected_test = memcmp(rgb, expectedAndroid, sizeof(expected));
+  EXPECT_EQ(0, expected_test);
+#else
   int expected_test = memcmp(rgb, expected, sizeof(expected));
   EXPECT_EQ(0, expected_test);
+#endif
 }
 
 TEST(YUVConvertTest, RGB24ToYUV) {
   // Allocate all surfaces.
   scoped_ptr<uint8[]> rgb_bytes;
   scoped_ptr<uint8[]> yuv_converted_bytes(new uint8[kYUV12Size]);
 
   // Read RGB24 reference data from file.
   ReadRGB24Data(&rgb_bytes);
 
   // Convert to I420.
   media::ConvertRGB24ToYUV(rgb_bytes.get(),
                            yuv_converted_bytes.get(),
                            yuv_converted_bytes.get() + kSourceUOffset,
                            yuv_converted_bytes.get() + kSourceVOffset,
                            kSourceWidth, kSourceHeight,        // Dimensions
                            kSourceWidth * 3,                   // RGBStride
                            kSourceWidth,                       // YStride
                            kSourceWidth / 2);                  // UVStride
 
   uint32 rgb_hash = DJB2Hash(yuv_converted_bytes.get(), kYUV12Size,
                              kDJB2HashSeed);
+#if defined(OS_ANDROID)
   EXPECT_EQ(320824432u, rgb_hash);
+#else
+  EXPECT_EQ(320824432u, rgb_hash);

[scherkus (not reviewing), 2013/06/19 19:49:50]

these values are the same

[hkuang1, 2013/06/19 23:21:11]

A mistake. Delete it. 

+#endif
 }
 
 TEST(YUVConvertTest, RGB32ToYUV) {
   // Allocate all surfaces.
   scoped_ptr<uint8[]> yuv_bytes(new uint8[kYUV12Size]);
   scoped_ptr<uint8[]> rgb_bytes(new uint8[kRGBSize]);
   scoped_ptr<uint8[]> yuv_converted_bytes(new uint8[kYUV12Size]);
   scoped_ptr<uint8[]> rgb_converted_bytes(new uint8[kRGBSize]);
 
   // Read YUV reference data from file.
@@ skipping 594 matching lines @@
   EXPECT_EQ(0, memcmp(rgb_bytes_reference.get(),
                       rgb_bytes_converted.get(),
                       kWidth * kBpp));
 }
 
 #endif  // defined(ARCH_CPU_X86_64)
 
 #endif  // defined(ARCH_CPU_X86_FAMILY)
 
 }  // namespace media