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 58 matching lines @@
 }
 
 static void ReadRGB24Data(scoped_ptr<uint8[]>* data) {
   ReadData(FILE_PATH_LITERAL("bali_640x360_RGB24.rgb"), kRGB24Size, data);
 }
 
 static void ReadYUY2Data(scoped_ptr<uint8[]>* data) {
   ReadData(FILE_PATH_LITERAL("bali_640x360_YUY2.yuv"), kYUY2Size, data);
 }
 
+// Helper for converting image format from BGRA to RGBA.
+static void ConvertBGRAToRGBA(unsigned char* pixels, size_t buffer_size) {

[scherkus (not reviewing), 2013/06/20 00:28:08]

wait ... isn't this backwards?

your comment in media/base/simd/convert_yuv_to_rgb_c.cc says that desktop is
BGRA and Android is RGBA

regardless, I suggest sidestepping the issue by renaming this function
"SwapRedAndBlueChannels" since it can be used to convert to AND from BGRA<->RGBA
;)

[hkuang1, 2013/06/20 03:45:33]

Yes, my bad. Should be RGBA to BGRA. "SwapRedAndBlueChannels" is a better name.
Change the name to be SwapRedAndBlueChannels

+  // Swizzle red and blue channels.
+  for (size_t i = 0; i < buffer_size; i += 4) {
+    std::swap(pixels[i], pixels[i + 2]);
+  }
+}
+
 namespace media {
 
 TEST(YUVConvertTest, YV12) {
   // 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.
   ReadYV12Data(&yuv_bytes);
 
   // Convert a frame of YUV to 32 bit ARGB.
   media::ConvertYUVToRGB32(yuv_bytes.get(),
                            yuv_bytes.get() + kSourceUOffset,
                            yuv_bytes.get() + kSourceVOffset,
                            rgb_converted_bytes.get(),            // RGB output
                            kSourceWidth, kSourceHeight,          // Dimensions
                            kSourceWidth,                         // YStride
                            kSourceWidth / 2,                     // UVStride
                            kSourceWidth * kBpp,                  // RGBStride
                            media::YV12);
 
+#if defined(OS_ANDROID)
+  ConvertBGRAToRGBA(rgb_converted_bytes.get(), kRGBSizeConverted);
+#endif
+
   uint32 rgb_hash = DJB2Hash(rgb_converted_bytes.get(), kRGBSizeConverted,
                              kDJB2HashSeed);
   EXPECT_EQ(2413171226u, rgb_hash);
 }
 
 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);
 
+#if defined(OS_ANDROID)
+  ConvertBGRAToRGBA(rgb_converted_bytes.get(), kRGBSizeConverted);
+#endif
+
   uint32 rgb_hash = DJB2Hash(rgb_converted_bytes.get(), kRGBSizeConverted,
                              kDJB2HashSeed);
   EXPECT_EQ(4222342047u, rgb_hash);
 }
 
 struct YUVScaleTestData {
   YUVScaleTestData(media::YUVType y, media::ScaleFilter s, uint32 r)
       : yuv_type(y),
         scale_filter(s),
         rgb_hash(r) {
@@ skipping 74 matching lines @@
                          rgb_bytes_.get(),             // RGB output
                          kSourceWidth, kSourceHeight,  // Dimensions
                          kScaledWidth, kScaledHeight,  // Dimensions
                          kSourceWidth,                 // YStride
                          kSourceWidth / 2,             // UvStride
                          kScaledWidth * kBpp,          // RgbStride
                          GetParam().yuv_type,
                          media::ROTATE_0,
                          GetParam().scale_filter);
 
+#if defined(OS_ANDROID)
+  ConvertBGRAToRGBA(rgb_bytes_.get(), kRGBSizeScaled);
+#endif
+
   uint32 rgb_hash = DJB2Hash(rgb_bytes_.get(), kRGBSizeScaled, kDJB2HashSeed);
   EXPECT_EQ(GetParam().rgb_hash, rgb_hash);
 }
 
 TEST_P(YUVScaleTest, ZeroSourceSize) {
   media::ScaleYUVToRGB32(y_plane(),                    // Y
                          u_plane(),                    // U
                          v_plane(),                    // V
                          rgb_bytes_.get(),             // RGB output
                          0, 0,                         // Dimensions
@@ skipping 67 matching lines @@
   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)
+  ConvertBGRAToRGBA(rgb, kBpp);
+#endif
+
   int expected_test = memcmp(rgb, expected, sizeof(expected));
   EXPECT_EQ(0, expected_test);
 }
 
 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);
+

[scherkus (not reviewing), 2013/06/20 00:28:08]

remove extra line that snuck in

[hkuang1, 2013/06/20 03:45:33]

Done.

   EXPECT_EQ(320824432u, rgb_hash);
 }
 
 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]);
 
@@ skipping 595 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