Add correct support for videos with YUVJ420P color format, in the software conversion path.

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"
 #include "media/base/simd/convert_rgb_to_yuv.h"
 #include "media/base/simd/convert_yuv_to_rgb.h"
 #include "media/base/simd/filter_yuv.h"
+#include "media/base/simd/yuv_to_rgb_table.h"
 #include "media/base/yuv_convert.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/rect.h"
 
 // Size of raw image.
 static const int kSourceWidth = 640;
 static const int kSourceHeight = 360;
 static const int kSourceYSize = kSourceWidth * kSourceHeight;
 static const int kSourceUOffset = kSourceYSize;
 static const int kSourceVOffset = kSourceYSize * 5 / 4;
@@ skipping 131 matching lines @@
   media::YUVType yuv_type;
   media::ScaleFilter scale_filter;
   uint32 rgb_hash;
 };
 
 class YUVScaleTest : public ::testing::TestWithParam<YUVScaleTestData> {
  public:
   YUVScaleTest() {
     switch (GetParam().yuv_type) {
       case media::YV12:
+      case media::YV12J:
         ReadYV12Data(&yuv_bytes_);
         break;
       case media::YV16:
         ReadYV16Data(&yuv_bytes_);
         break;
     }
 
     rgb_bytes_.reset(new uint8[kRGBSizeScaled]);
   }
 
   // Helpers for getting the proper Y, U and V plane offsets.
   uint8* y_plane() { return yuv_bytes_.get(); }
   uint8* u_plane() { return yuv_bytes_.get() + kSourceYSize; }
   uint8* v_plane() {
     switch (GetParam().yuv_type) {
       case media::YV12:
+      case media::YV12J:
         return yuv_bytes_.get() + kSourceVOffset;
       case media::YV16:
         return yuv_bytes_.get() + kSourceYSize * 3 / 2;
     }
     return NULL;
   }
 
   scoped_ptr<uint8[]> yuv_bytes_;
   scoped_ptr<uint8[]> rgb_bytes_;
 };
@@ skipping 420 matching lines @@
   scoped_ptr<uint8[]> yuv_bytes(new uint8[kYUV12Size]);
   scoped_ptr<uint8[]> rgb_bytes_reference(new uint8[kRGBSize]);
   scoped_ptr<uint8[]> rgb_bytes_converted(new uint8[kRGBSize]);
   ReadYV12Data(&yuv_bytes);
 
   const int kWidth = 167;
   ConvertYUVToRGB32Row_C(yuv_bytes.get(),
                          yuv_bytes.get() + kSourceUOffset,
                          yuv_bytes.get() + kSourceVOffset,
                          rgb_bytes_reference.get(),
-                         kWidth);
+                         kWidth,
+                         kCoefficientsRgbY);
   ConvertYUVToRGB32Row_MMX(yuv_bytes.get(),
                            yuv_bytes.get() + kSourceUOffset,
                            yuv_bytes.get() + kSourceVOffset,
                            rgb_bytes_converted.get(),
-                           kWidth);
+                           kWidth,
+                           kCoefficientsRgbY);
   media::EmptyRegisterState();
   EXPECT_EQ(0, memcmp(rgb_bytes_reference.get(),
                       rgb_bytes_converted.get(),
                       kWidth * kBpp));
 }
 
 TEST(YUVConvertTest, ConvertYUVToRGB32Row_SSE) {
   base::CPU cpu;
   if (!cpu.has_sse()) {
     LOG(WARNING) << "System not supported. Test skipped.";
     return;
   }
 
   scoped_ptr<uint8[]> yuv_bytes(new uint8[kYUV12Size]);
   scoped_ptr<uint8[]> rgb_bytes_reference(new uint8[kRGBSize]);
   scoped_ptr<uint8[]> rgb_bytes_converted(new uint8[kRGBSize]);
   ReadYV12Data(&yuv_bytes);
 
   const int kWidth = 167;
   ConvertYUVToRGB32Row_C(yuv_bytes.get(),
                          yuv_bytes.get() + kSourceUOffset,
                          yuv_bytes.get() + kSourceVOffset,
                          rgb_bytes_reference.get(),
-                         kWidth);
+                         kWidth,
+                         kCoefficientsRgbY);
   ConvertYUVToRGB32Row_SSE(yuv_bytes.get(),
                            yuv_bytes.get() + kSourceUOffset,
                            yuv_bytes.get() + kSourceVOffset,
                            rgb_bytes_converted.get(),
-                           kWidth);
+                           kWidth,
+                           kCoefficientsRgbY);
   media::EmptyRegisterState();
   EXPECT_EQ(0, memcmp(rgb_bytes_reference.get(),
                       rgb_bytes_converted.get(),
                       kWidth * kBpp));
 }
 
 TEST(YUVConvertTest, ScaleYUVToRGB32Row_MMX) {
   base::CPU cpu;
   if (!cpu.has_mmx()) {
     LOG(WARNING) << "System not supported. Test skipped.";
     return;
   }
 
   scoped_ptr<uint8[]> yuv_bytes(new uint8[kYUV12Size]);
   scoped_ptr<uint8[]> rgb_bytes_reference(new uint8[kRGBSize]);
   scoped_ptr<uint8[]> rgb_bytes_converted(new uint8[kRGBSize]);
   ReadYV12Data(&yuv_bytes);
 
   const int kWidth = 167;
   const int kSourceDx = 80000;  // This value means a scale down.
   ScaleYUVToRGB32Row_C(yuv_bytes.get(),
                        yuv_bytes.get() + kSourceUOffset,
                        yuv_bytes.get() + kSourceVOffset,
                        rgb_bytes_reference.get(),
                        kWidth,
-                       kSourceDx);
+                       kSourceDx,
+                       kCoefficientsRgbY);
   ScaleYUVToRGB32Row_MMX(yuv_bytes.get(),
                          yuv_bytes.get() + kSourceUOffset,
                          yuv_bytes.get() + kSourceVOffset,
                          rgb_bytes_converted.get(),
                          kWidth,
-                         kSourceDx);
+                         kSourceDx,
+                         kCoefficientsRgbY);
   media::EmptyRegisterState();
   EXPECT_EQ(0, memcmp(rgb_bytes_reference.get(),
                       rgb_bytes_converted.get(),
                       kWidth * kBpp));
 }
 
 TEST(YUVConvertTest, ScaleYUVToRGB32Row_SSE) {
   base::CPU cpu;
   if (!cpu.has_sse()) {
     LOG(WARNING) << "System not supported. Test skipped.";
     return;
   }
 
   scoped_ptr<uint8[]> yuv_bytes(new uint8[kYUV12Size]);
   scoped_ptr<uint8[]> rgb_bytes_reference(new uint8[kRGBSize]);
   scoped_ptr<uint8[]> rgb_bytes_converted(new uint8[kRGBSize]);
   ReadYV12Data(&yuv_bytes);
 
   const int kWidth = 167;
   const int kSourceDx = 80000;  // This value means a scale down.
   ScaleYUVToRGB32Row_C(yuv_bytes.get(),
                        yuv_bytes.get() + kSourceUOffset,
                        yuv_bytes.get() + kSourceVOffset,
                        rgb_bytes_reference.get(),
                        kWidth,
-                       kSourceDx);
+                       kSourceDx,
+                       kCoefficientsRgbY);
   ScaleYUVToRGB32Row_SSE(yuv_bytes.get(),
                          yuv_bytes.get() + kSourceUOffset,
                          yuv_bytes.get() + kSourceVOffset,
                          rgb_bytes_converted.get(),
                          kWidth,
-                         kSourceDx);
+                         kSourceDx,
+                         kCoefficientsRgbY);
   media::EmptyRegisterState();
   EXPECT_EQ(0, memcmp(rgb_bytes_reference.get(),
                       rgb_bytes_converted.get(),
                       kWidth * kBpp));
 }
 
 TEST(YUVConvertTest, LinearScaleYUVToRGB32Row_MMX) {
   base::CPU cpu;
   if (!cpu.has_mmx()) {
     LOG(WARNING) << "System not supported. Test skipped.";
     return;
   }
 
   scoped_ptr<uint8[]> yuv_bytes(new uint8[kYUV12Size]);
   scoped_ptr<uint8[]> rgb_bytes_reference(new uint8[kRGBSize]);
   scoped_ptr<uint8[]> rgb_bytes_converted(new uint8[kRGBSize]);
   ReadYV12Data(&yuv_bytes);
 
   const int kWidth = 167;
   const int kSourceDx = 80000;  // This value means a scale down.
   LinearScaleYUVToRGB32Row_C(yuv_bytes.get(),
                              yuv_bytes.get() + kSourceUOffset,
                              yuv_bytes.get() + kSourceVOffset,
                              rgb_bytes_reference.get(),
                              kWidth,
-                             kSourceDx);
+                             kSourceDx,
+                             kCoefficientsRgbY);
   LinearScaleYUVToRGB32Row_MMX(yuv_bytes.get(),
                                yuv_bytes.get() + kSourceUOffset,
                                yuv_bytes.get() + kSourceVOffset,
                                rgb_bytes_converted.get(),
                                kWidth,
-                               kSourceDx);
+                               kSourceDx,
+                               kCoefficientsRgbY);
   media::EmptyRegisterState();
   EXPECT_EQ(0, memcmp(rgb_bytes_reference.get(),
                       rgb_bytes_converted.get(),
                       kWidth * kBpp));
 }
 
 TEST(YUVConvertTest, LinearScaleYUVToRGB32Row_SSE) {
   base::CPU cpu;
   if (!cpu.has_sse()) {
     LOG(WARNING) << "System not supported. Test skipped.";
     return;
   }
 
   scoped_ptr<uint8[]> yuv_bytes(new uint8[kYUV12Size]);
   scoped_ptr<uint8[]> rgb_bytes_reference(new uint8[kRGBSize]);
   scoped_ptr<uint8[]> rgb_bytes_converted(new uint8[kRGBSize]);
   ReadYV12Data(&yuv_bytes);
 
   const int kWidth = 167;
   const int kSourceDx = 80000;  // This value means a scale down.
   LinearScaleYUVToRGB32Row_C(yuv_bytes.get(),
                              yuv_bytes.get() + kSourceUOffset,
                              yuv_bytes.get() + kSourceVOffset,
                              rgb_bytes_reference.get(),
                              kWidth,
-                             kSourceDx);
+                             kSourceDx,
+                             kCoefficientsRgbY);
   LinearScaleYUVToRGB32Row_SSE(yuv_bytes.get(),
                                yuv_bytes.get() + kSourceUOffset,
                                yuv_bytes.get() + kSourceVOffset,
                                rgb_bytes_converted.get(),
                                kWidth,
-                               kSourceDx);
+                               kSourceDx,
+                               kCoefficientsRgbY);
   media::EmptyRegisterState();
   EXPECT_EQ(0, memcmp(rgb_bytes_reference.get(),
                       rgb_bytes_converted.get(),
                       kWidth * kBpp));
 }
 
 TEST(YUVConvertTest, FilterYUVRows_C_OutOfBounds) {
   scoped_ptr<uint8[]> src(new uint8[16]);
   scoped_ptr<uint8[]> dst(new uint8[16]);
 
@@ skipping 123 matching lines @@
   scoped_ptr<uint8[]> rgb_bytes_converted(new uint8[kRGBSize]);
   ReadYV12Data(&yuv_bytes);
 
   const int kWidth = 167;
   const int kSourceDx = 80000;  // This value means a scale down.
   ScaleYUVToRGB32Row_C(yuv_bytes.get(),
                        yuv_bytes.get() + kSourceUOffset,
                        yuv_bytes.get() + kSourceVOffset,
                        rgb_bytes_reference.get(),
                        kWidth,
-                       kSourceDx);
+                       kSourceDx,
+                       kCoefficientsRgbY);
   ScaleYUVToRGB32Row_SSE2_X64(yuv_bytes.get(),
                               yuv_bytes.get() + kSourceUOffset,
                               yuv_bytes.get() + kSourceVOffset,
                               rgb_bytes_converted.get(),
                               kWidth,
-                              kSourceDx);
+                              kSourceDx,
+                              kCoefficientsRgbY);
   media::EmptyRegisterState();
   EXPECT_EQ(0, memcmp(rgb_bytes_reference.get(),
                       rgb_bytes_converted.get(),
                       kWidth * kBpp));
 }
 
 TEST(YUVConvertTest, LinearScaleYUVToRGB32Row_MMX_X64) {
   scoped_ptr<uint8[]> yuv_bytes(new uint8[kYUV12Size]);
   scoped_ptr<uint8[]> rgb_bytes_reference(new uint8[kRGBSize]);
   scoped_ptr<uint8[]> rgb_bytes_converted(new uint8[kRGBSize]);
   ReadYV12Data(&yuv_bytes);
 
   const int kWidth = 167;
   const int kSourceDx = 80000;  // This value means a scale down.
   LinearScaleYUVToRGB32Row_C(yuv_bytes.get(),
                              yuv_bytes.get() + kSourceUOffset,
                              yuv_bytes.get() + kSourceVOffset,
                              rgb_bytes_reference.get(),
                              kWidth,
-                             kSourceDx);
+                             kSourceDx,
+                             kCoefficientsRgbY);
   LinearScaleYUVToRGB32Row_MMX_X64(yuv_bytes.get(),
                                    yuv_bytes.get() + kSourceUOffset,
                                    yuv_bytes.get() + kSourceVOffset,
                                    rgb_bytes_converted.get(),
                                    kWidth,
-                                   kSourceDx);
+                                   kSourceDx,
+                                   kCoefficientsRgbY);
   media::EmptyRegisterState();
   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