Add plumbing for video pixel formats with JPEG color range.

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 87 matching lines @@
 
   // 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);
+                           media::YV12,
+                           media::YUV_RANGE_RESTRICTED);
 
 #if defined(OS_ANDROID)
   SwapRedAndBlueChannels(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);
+                           media::YV16,
+                           media::YUV_RANGE_RESTRICTED);
 
 #if defined(OS_ANDROID)
   SwapRedAndBlueChannels(rgb_converted_bytes.get(), kRGBSizeConverted);
 #endif
 
   uint32 rgb_hash = DJB2Hash(rgb_converted_bytes.get(), kRGBSizeConverted,
                              kDJB2HashSeed);
   EXPECT_EQ(4222342047u, rgb_hash);
 }
 
@@ skipping 45 matching lines @@
   media::ScaleYUVToRGB32(y_plane(),                    // Y
                          u_plane(),                    // U
                          v_plane(),                    // V
                          rgb_bytes_.get(),             // RGB output
                          kSourceWidth, kSourceHeight,  // Dimensions
                          kSourceWidth, kSourceHeight,  // Dimensions
                          kSourceWidth,                 // YStride
                          kSourceWidth / 2,             // UvStride
                          kSourceWidth * kBpp,          // RgbStride
                          GetParam().yuv_type,
+                         media::YUV_RANGE_RESTRICTED,
                          media::ROTATE_0,
                          GetParam().scale_filter);
 
   uint32 yuv_hash = DJB2Hash(rgb_bytes_.get(), kRGBSize, kDJB2HashSeed);
 
   media::ConvertYUVToRGB32(y_plane(),                    // Y
                            u_plane(),                    // U
                            v_plane(),                    // V
                            rgb_bytes_.get(),             // RGB output
                            kSourceWidth, kSourceHeight,  // Dimensions
                            kSourceWidth,                 // YStride
                            kSourceWidth / 2,             // UVStride
                            kSourceWidth * kBpp,          // RGBStride
-                           GetParam().yuv_type);
+                           GetParam().yuv_type,
+                           media::YUV_RANGE_RESTRICTED);
 
   uint32 rgb_hash = DJB2Hash(rgb_bytes_.get(), kRGBSize, kDJB2HashSeed);
 
   EXPECT_EQ(yuv_hash, rgb_hash);
 }
 
 TEST_P(YUVScaleTest, Normal) {
   media::ScaleYUVToRGB32(y_plane(),                    // Y
                          u_plane(),                    // U
                          v_plane(),                    // V
                          rgb_bytes_.get(),             // RGB output
                          kSourceWidth, kSourceHeight,  // Dimensions
                          kScaledWidth, kScaledHeight,  // Dimensions
                          kSourceWidth,                 // YStride
                          kSourceWidth / 2,             // UvStride
                          kScaledWidth * kBpp,          // RgbStride
                          GetParam().yuv_type,
+                         media::YUV_RANGE_RESTRICTED,
                          media::ROTATE_0,
                          GetParam().scale_filter);
 
 #if defined(OS_ANDROID)
   SwapRedAndBlueChannels(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
                          kScaledWidth, kScaledHeight,  // Dimensions
                          kSourceWidth,                 // YStride
                          kSourceWidth / 2,             // UvStride
                          kScaledWidth * kBpp,          // RgbStride
                          GetParam().yuv_type,
+                         media::YUV_RANGE_RESTRICTED,
                          media::ROTATE_0,
                          GetParam().scale_filter);
 
   // Testing for out-of-bound read/writes with AddressSanitizer.
 }
 
 TEST_P(YUVScaleTest, ZeroDestinationSize) {
   media::ScaleYUVToRGB32(y_plane(),                    // Y
                          u_plane(),                    // U
                          v_plane(),                    // V
                          rgb_bytes_.get(),             // RGB output
                          kSourceWidth, kSourceHeight,  // Dimensions
                          0, 0,                         // Dimensions
                          kSourceWidth,                 // YStride
                          kSourceWidth / 2,             // UvStride
                          kScaledWidth * kBpp,          // RgbStride
                          GetParam().yuv_type,
+                         media::YUV_RANGE_RESTRICTED,
                          media::ROTATE_0,
                          GetParam().scale_filter);
 
   // Testing for out-of-bound read/writes with AddressSanitizer.
 }
 
 TEST_P(YUVScaleTest, OddWidthAndHeightNotCrash) {
   media::ScaleYUVToRGB32(y_plane(),                    // Y
                          u_plane(),                    // U
                          v_plane(),                    // V
                          rgb_bytes_.get(),             // RGB output
                          kSourceWidth, kSourceHeight,  // Dimensions
                          3, 3,                         // Dimensions
                          kSourceWidth,                 // YStride
                          kSourceWidth / 2,             // UvStride
                          kScaledWidth * kBpp,          // RgbStride
                          GetParam().yuv_type,
+                         media::YUV_RANGE_RESTRICTED,
                          media::ROTATE_0,
                          GetParam().scale_filter);
 }
 
 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),
@@ skipping 16 matching lines @@
   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);
+                           media::YV12,
+                           media::YUV_RANGE_RESTRICTED);
 
 #if defined(OS_ANDROID)
   SwapRedAndBlueChannels(rgb, kBpp);
 #endif
 
   int expected_test = memcmp(rgb, expected, sizeof(expected));
   EXPECT_EQ(0, expected_test);
 }
 
 TEST(YUVConvertTest, RGB24ToYUV) {
@@ skipping 40 matching lines @@
 
   // Convert a frame of YUV to 32 bit ARGB.
   media::ConvertYUVToRGB32(yuv_bytes.get(),
                            yuv_bytes.get() + kSourceUOffset,
                            yuv_bytes.get() + kSourceVOffset,
                            rgb_bytes.get(),            // RGB output
                            kSourceWidth, kSourceHeight,          // Dimensions
                            kSourceWidth,                         // YStride
                            kSourceWidth / 2,                     // UVStride
                            kSourceWidth * kBpp,                  // RGBStride
-                           media::YV12);
+                           media::YV12,
+                           media::YUV_RANGE_RESTRICTED);
 
   // Convert RGB32 to YV12.
   media::ConvertRGB32ToYUV(rgb_bytes.get(),
                            yuv_converted_bytes.get(),
                            yuv_converted_bytes.get() + kSourceUOffset,
                            yuv_converted_bytes.get() + kSourceVOffset,
                            kSourceWidth, kSourceHeight,        // Dimensions
                            kSourceWidth * 4,                   // RGBStride
                            kSourceWidth,                       // YStride
                            kSourceWidth / 2);                  // UVStride
 
   // Convert YV12 back to RGB32.
   media::ConvertYUVToRGB32(yuv_converted_bytes.get(),
                            yuv_converted_bytes.get() + kSourceUOffset,
                            yuv_converted_bytes.get() + kSourceVOffset,
                            rgb_converted_bytes.get(),            // RGB output
                            kSourceWidth, kSourceHeight,          // Dimensions
                            kSourceWidth,                         // YStride
                            kSourceWidth / 2,                     // UVStride
                            kSourceWidth * kBpp,                  // RGBStride
-                           media::YV12);
+                           media::YV12,
+                           media::YUV_RANGE_RESTRICTED);
 
   int error = 0;
   for (int i = 0; i < kRGBSize; ++i) {
     int diff = rgb_converted_bytes[i] - rgb_bytes[i];
     if (diff < 0)
       diff = -diff;
     error += diff;
   }
 
   // Make sure error is within bound.
@@ skipping 113 matching lines @@
   // Convert a frame of YUV to 32 bit ARGB.
   media::ConvertYUVToRGB32(
       yuv_bytes.get(),
       yuv_bytes.get() + kSourceUOffset,
       yuv_bytes.get() + kSourceVOffset,
       rgb_bytes.get(),            // RGB output
       kSourceWidth, kSourceHeight,          // Dimensions
       kSourceWidth,                         // YStride
       kSourceWidth / 2,                     // UVStride
       kSourceWidth * kBpp,                  // RGBStride
-      media::YV12);
+      media::YV12,
+      media::YUV_RANGE_RESTRICTED);
 
   // Convert RGB32 to YV12 with SSE2 version.
   media::ConvertRGB32ToYUV_SSE2(
       rgb_bytes.get(),
       yuv_converted_bytes.get(),
       yuv_converted_bytes.get() + kSourceUOffset,
       yuv_converted_bytes.get() + kSourceVOffset,
       kSourceWidth, kSourceHeight,        // Dimensions
       kSourceWidth * 4,                   // RGBStride
       kSourceWidth,                       // YStride
@@ skipping 408 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