Add support for Rec709 color space videos in software YUV convert path.

media/base/yuv_convert.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.
 
 // This webpage shows layout of YV12 and other YUV formats
 // http://www.fourcc.org/yuv.php
 // The actual conversion is best described here
 // http://en.wikipedia.org/wiki/YUV
 // An article on optimizing YUV conversion using tables instead of multiplies
 // http://lestourtereaux.free.fr/papers/data/yuvrgb.pdf
 //
 // YV12 is a full plane of Y and a half height, half width chroma planes
 // YV16 is a full plane of Y and a full height, half width chroma planes
 //
 // ARGB pixel format is output, which on little endian is stored as BGRA.
 // The alpha is set to 255, allowing the application to use RGBA or RGB32.
 
 #include "media/base/yuv_convert.h"
 
 #include "base/cpu.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/macros.h"
+#include "base/memory/aligned_memory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "build/build_config.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"
 
 #if defined(ARCH_CPU_X86_FAMILY)
 #if defined(COMPILER_MSVC)
 #include <intrin.h>
 #else
 #include <mmintrin.h>
 #endif
 #endif
 
 // Assembly functions are declared without namespace.
@@ skipping 39 matching lines @@
                                       int,
                                       int,
                                       int,
                                       YUVType);
 
 typedef void (*ConvertYUVToRGB32RowProc)(const uint8*,
                                          const uint8*,
                                          const uint8*,
                                          uint8*,
                                          ptrdiff_t,
-                                         const int16[1024][4]);
+                                         const int16*);
 
 typedef void (*ConvertYUVAToARGBRowProc)(const uint8*,
                                          const uint8*,
                                          const uint8*,
                                          const uint8*,
                                          uint8*,
                                          ptrdiff_t,
-                                         const int16[1024][4]);
+                                         const int16*);
 
 typedef void (*ScaleYUVToRGB32RowProc)(const uint8*,
                                        const uint8*,
                                        const uint8*,
                                        uint8*,
                                        ptrdiff_t,
                                        ptrdiff_t,
-                                       const int16[1024][4]);
+                                       const int16*);
 
 static FilterYUVRowsProc g_filter_yuv_rows_proc_ = NULL;
 static ConvertYUVToRGB32RowProc g_convert_yuv_to_rgb32_row_proc_ = NULL;
 static ScaleYUVToRGB32RowProc g_scale_yuv_to_rgb32_row_proc_ = NULL;
 static ScaleYUVToRGB32RowProc g_linear_scale_yuv_to_rgb32_row_proc_ = NULL;
 static ConvertRGBToYUVProc g_convert_rgb32_to_yuv_proc_ = NULL;
 static ConvertRGBToYUVProc g_convert_rgb24_to_yuv_proc_ = NULL;
 static ConvertYUVToRGB32Proc g_convert_yuv_to_rgb32_proc_ = NULL;
 static ConvertYUVAToARGBProc g_convert_yuva_to_argb_proc_ = NULL;
 
+static const int kYUVToRGBTableSize = 256 * 4 * 4 * sizeof(int16);
+
+// base::AlignedMemory has a private operator new(), so wrap it in a struct so
+// that we can put it in a LazyInstance::Leaky.
+struct YUVToRGBTableWrapper {
+  base::AlignedMemory<kYUVToRGBTableSize, 16> table;
+};
+
+typedef base::LazyInstance<YUVToRGBTableWrapper>::Leaky
+    YUVToRGBTable;
+static YUVToRGBTable g_table_rec601 = LAZY_INSTANCE_INITIALIZER;
+static YUVToRGBTable g_table_jpeg = LAZY_INSTANCE_INITIALIZER;
+static YUVToRGBTable g_table_rec709 = LAZY_INSTANCE_INITIALIZER;
+static const int16* g_table_rec601_ptr = NULL;
+static const int16* g_table_jpeg_ptr = NULL;
+static const int16* g_table_rec709_ptr = NULL;
+
 // Empty SIMD registers state after using them.
 void EmptyRegisterStateStub() {}
 #if defined(MEDIA_MMX_INTRINSICS_AVAILABLE)
 void EmptyRegisterStateIntrinsic() { _mm_empty(); }
 #endif
 typedef void (*EmptyRegisterStateProc)();
 static EmptyRegisterStateProc g_empty_register_state_proc_ = NULL;
 
 // Get the appropriate value to bitshift by for vertical indices.
 int GetVerticalShift(YUVType type) {
   switch (type) {
     case YV16:
       return 0;
     case YV12:
     case YV12J:
+    case YV12HD:
       return 1;
   }
   NOTREACHED();
   return 0;
 }
 
-const int16 (&GetLookupTable(YUVType type))[1024][4] {
+const int16* GetLookupTable(YUVType type) {
   switch (type) {
     case YV12:
     case YV16:
-      return kCoefficientsRgbY;
+      return g_table_rec601_ptr;
     case YV12J:
-      return kCoefficientsRgbY_JPEG;
+      return g_table_jpeg_ptr;
+    case YV12HD:
+      return g_table_rec709_ptr;
   }
   NOTREACHED();
-  return kCoefficientsRgbY;
+  return NULL;
+}
+
+// Populates a pre-allocated lookup table from a YUV->RGB matrix.
+const int16* PopulateYUVToRGBTable(const double matrix[3][3],
+                                   bool full_range,
+                                   int16* table) {
+  // We'll have 4 sub-tables that lie contiguous in memory, one for each of Y,
+  // U, V and A.
+  const int kNumTables = 4;
+  // Each table has 256 rows (for all possible 8-bit values).
+  const int kNumRows = 256;
+  // Each row has 4 columns, for contributions to each of R, G, B and A.
+  const int kNumColumns = 4;
+  // Each element is a fixed-point (10.6) 16-bit signed value.
+  const int kElementSize = sizeof(int16);
+
+  // Sanity check that our constants here match the size of the statically
+  // allocated tables.
+  COMPILE_ASSERT(
+      kNumTables * kNumRows * kNumColumns * kElementSize == kYUVToRGBTableSize,
+      "YUV lookup table size doesn't match expectation.");
+
+  // Y needs an offset of -16 for color ranges that ignore the lower 16 values,
+  // U and V get -128 to put them in [-128, 127] from [0, 255].
+  int offsets[3] = {(full_range ? 0 : -16), -128, -128};
+
+  for (int i = 0; i < kNumRows; ++i) {
+    // Y, U, and V contributions to each of R, G, B and A.
+    for (int j = 0; j < 3; ++j) {
+#if defined(OS_ANDROID)
+      // Android is RGBA.
+      table[(j * kNumRows + i) * kNumColumns + 0] =
+          matrix[j][0] * 64 * (i + offsets[j]) + 0.5;
+      table[(j * kNumRows + i) * kNumColumns + 1] =
+          matrix[j][1] * 64 * (i + offsets[j]) + 0.5;
+      table[(j * kNumRows + i) * kNumColumns + 2] =
+          matrix[j][2] * 64 * (i + offsets[j]) + 0.5;
+#else
+      // Other platforms are BGRA.
+      table[(j * kNumRows + i) * kNumColumns + 0] =
+          matrix[j][2] * 64 * (i + offsets[j]) + 0.5;
+      table[(j * kNumRows + i) * kNumColumns + 1] =
+          matrix[j][1] * 64 * (i + offsets[j]) + 0.5;
+      table[(j * kNumRows + i) * kNumColumns + 2] =
+          matrix[j][0] * 64 * (i + offsets[j]) + 0.5;
+#endif
+      // Alpha contributions from Y and V are always 0. U is set such that
+      // all values result in a full '255' alpha value.
+      table[(j * kNumRows + i) * kNumColumns + 3] = (j == 1) ? 256 * 64 - 1 : 0;
+    }
+    // And YUVA alpha is passed through as-is.
+    for (int k = 0; k < kNumTables; ++k)
+      table[((kNumTables - 1) * kNumRows + i) * kNumColumns + k] = i;
+  }
+
+  return table;
 }
 
 void InitializeCPUSpecificYUVConversions() {
   CHECK(!g_filter_yuv_rows_proc_);
   CHECK(!g_convert_yuv_to_rgb32_row_proc_);
   CHECK(!g_scale_yuv_to_rgb32_row_proc_);
   CHECK(!g_linear_scale_yuv_to_rgb32_row_proc_);
   CHECK(!g_convert_rgb32_to_yuv_proc_);
   CHECK(!g_convert_rgb24_to_yuv_proc_);
   CHECK(!g_convert_yuv_to_rgb32_proc_);
@@ skipping 40 matching lines @@
 #endif
 
   base::CPU cpu;
   if (cpu.has_ssse3()) {
     g_convert_rgb24_to_yuv_proc_ = &ConvertRGB24ToYUV_SSSE3;
 
     // TODO(hclam): Add ConvertRGB32ToYUV_SSSE3 when the cyan problem is solved.
     // See: crbug.com/100462
   }
 #endif
+
+  // Initialize YUV conversion lookup tables.
+
+  // SD Rec601 YUV->RGB matrix, see http://www.fourcc.org/fccyvrgb.php
+  const double kRec601ConvertMatrix[3][3] = {
+      {1.164, 1.164, 1.164}, {0.0, -0.391, 2.018}, {1.596, -0.813, 0.0},
+  };
+
+  // JPEG table, values from above link.
+  const double kJPEGConvertMatrix[3][3] = {
+      {1.0, 1.0, 1.0}, {0.0, -0.34414, 1.772}, {1.402, -0.71414, 0.0},
+  };
+
+  // Rec709 "HD" color space, values from:
+  // http://www.equasys.de/colorconversion.html
+  const double kRec709ConvertMatrix[3][3] = {
+      {1.164, 1.164, 1.164}, {0.0, -0.213, 2.112}, {1.793, -0.533, 0.0},
+  };
+
+  PopulateYUVToRGBTable(kRec601ConvertMatrix, false,
+                        g_table_rec601.Get().table.data_as<int16>());
+  PopulateYUVToRGBTable(kJPEGConvertMatrix, true,
+                        g_table_jpeg.Get().table.data_as<int16>());
+  PopulateYUVToRGBTable(kRec709ConvertMatrix, false,
+                        g_table_rec709.Get().table.data_as<int16>());
+  g_table_rec601_ptr = g_table_rec601.Get().table.data_as<int16>();
+  g_table_rec709_ptr = g_table_rec709.Get().table.data_as<int16>();
+  g_table_jpeg_ptr = g_table_jpeg.Get().table.data_as<int16>();
 }
 
 // Empty SIMD registers state after using them.
 void EmptyRegisterState() { g_empty_register_state_proc_(); }
 
 // 16.16 fixed point arithmetic
 const int kFractionBits = 16;
 const int kFractionMax = 1 << kFractionBits;
 const int kFractionMask = ((1 << kFractionBits) - 1);
 
@@ skipping 11 matching lines @@
                      int rgb_pitch,
                      YUVType yuv_type,
                      Rotate view_rotate,
                      ScaleFilter filter) {
   // Handle zero sized sources and destinations.
   if ((yuv_type == YV12 && (source_width < 2 || source_height < 2)) ||
       (yuv_type == YV16 && (source_width < 2 || source_height < 1)) ||
       width == 0 || height == 0)
     return;
 
+  const int16* lookup_table = GetLookupTable(yuv_type);
+
   // 4096 allows 3 buffers to fit in 12k.
   // Helps performance on CPU with 16K L1 cache.
   // Large enough for 3830x2160 and 30" displays which are 2560x1600.
   const int kFilterBufferSize = 4096;
   // Disable filtering if the screen is too big (to avoid buffer overflows).
   // This should never happen to regular users: they don't have monitors
   // wider than 4096 pixels.
   // TODO(fbarchard): Allow rotated videos to filter.
   if (source_width > kFilterBufferSize || view_rotate)
     filter = FILTER_NONE;
@@ skipping 123 matching lines @@
       ubuf[uv_source_width] = ubuf[uv_source_width - 1];
       vbuf[uv_source_width] = vbuf[uv_source_width - 1];
     } else {
       // Offset by 1/2 pixel for center sampling.
       int source_y = (source_y_subpixel + (kFractionMax / 2)) >> kFractionBits;
       y_ptr = y_buf + source_y * y_pitch;
       u_ptr = u_buf + (source_y >> y_shift) * uv_pitch;
       v_ptr = v_buf + (source_y >> y_shift) * uv_pitch;
     }
     if (source_dx == kFractionMax) {  // Not scaled
-      g_convert_yuv_to_rgb32_row_proc_(
-          y_ptr, u_ptr, v_ptr, dest_pixel, width, kCoefficientsRgbY);
+      g_convert_yuv_to_rgb32_row_proc_(y_ptr, u_ptr, v_ptr, dest_pixel, width,
+                                       lookup_table);
     } else {
       if (filter & FILTER_BILINEAR_H) {
-        g_linear_scale_yuv_to_rgb32_row_proc_(y_ptr,
-                                              u_ptr,
-                                              v_ptr,
-                                              dest_pixel,
-                                              width,
-                                              source_dx,
-                                              kCoefficientsRgbY);
+        g_linear_scale_yuv_to_rgb32_row_proc_(y_ptr, u_ptr, v_ptr, dest_pixel,
+                                              width, source_dx,
+                                              lookup_table);
       } else {
-        g_scale_yuv_to_rgb32_row_proc_(y_ptr,
-                                       u_ptr,
-                                       v_ptr,
-                                       dest_pixel,
-                                       width,
-                                       source_dx,
-                                       kCoefficientsRgbY);
+        g_scale_yuv_to_rgb32_row_proc_(y_ptr, u_ptr, v_ptr, dest_pixel, width,
+                                       source_dx, lookup_table);
       }
     }
   }
 
   g_empty_register_state_proc_();
 }
 
 // Scale a frame of YV12 to 32 bit ARGB for a specific rectangle.
 void ScaleYUVToRGB32WithRect(const uint8* y_buf,
                              const uint8* u_buf,
@@ skipping 13 matching lines @@
   // This routine doesn't currently support up-scaling.
   CHECK_LE(dest_width, source_width);
   CHECK_LE(dest_height, source_height);
 
   // Sanity-check the destination rectangle.
   DCHECK(dest_rect_left >= 0 && dest_rect_right <= dest_width);
   DCHECK(dest_rect_top >= 0 && dest_rect_bottom <= dest_height);
   DCHECK(dest_rect_right > dest_rect_left);
   DCHECK(dest_rect_bottom > dest_rect_top);
 
+  const int16* lookup_table = GetLookupTable(YV12);
+
   // Fixed-point value of vertical and horizontal scale down factor.
   // Values are in the format 16.16.
   int y_step = kFractionMax * source_height / dest_height;
   int x_step = kFractionMax * source_width / dest_width;
 
   // Determine the coordinates of the rectangle in 16.16 coords.
   // NB: Our origin is the *center* of the top/left pixel, NOT its top/left.
   // If we're down-scaling by more than a factor of two, we start with a 50%
   // fraction to avoid degenerating to point-sampling - we should really just
   // fix the fraction at 50% for all pixels in that case.
@@ skipping 84 matching lines @@
       uint8 fraction = (source_top & kFractionMask) >> 8;
       g_filter_yuv_rows_proc_(
           y_temp + source_y_left, y0_ptr, y1_ptr, source_y_width, fraction);
       g_filter_yuv_rows_proc_(
           u_temp + source_uv_left, u0_ptr, u1_ptr, source_uv_width, fraction);
       g_filter_yuv_rows_proc_(
           v_temp + source_uv_left, v0_ptr, v1_ptr, source_uv_width, fraction);
 
       // Perform horizontal interpolation and color space conversion.
       // TODO(hclam): Use the MMX version after more testing.
-      LinearScaleYUVToRGB32RowWithRange_C(y_temp,
-                                          u_temp,
-                                          v_temp,
-                                          rgb_buf,
-                                          dest_rect_width,
-                                          source_left,
-                                          x_step,
-                                          kCoefficientsRgbY);
+      LinearScaleYUVToRGB32RowWithRange_C(y_temp, u_temp, v_temp, rgb_buf,
+                                          dest_rect_width, source_left, x_step,
+                                          lookup_table);
     } else {
       // If the frame is too large then we linear scale a single row.
-      LinearScaleYUVToRGB32RowWithRange_C(y0_ptr,
-                                          u0_ptr,
-                                          v0_ptr,
-                                          rgb_buf,
-                                          dest_rect_width,
-                                          source_left,
-                                          x_step,
-                                          kCoefficientsRgbY);
+      LinearScaleYUVToRGB32RowWithRange_C(y0_ptr, u0_ptr, v0_ptr, rgb_buf,
+                                          dest_rect_width, source_left, x_step,
+                                          lookup_table);
     }
 
     // Advance vertically in the source and destination image.
     source_top += y_step;
     rgb_buf += rgb_pitch;
   }
 
   g_empty_register_state_proc_();
 }
 
@@ skipping 122 matching lines @@
                                width,
                                height,
                                ystride,
                                uvstride,
                                astride,
                                rgbstride,
                                yuv_type);
 }
 
 }  // namespace media