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/logging.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 int16* g_table_rec601 = 0;

[DaleCurtis, 2015/01/08 01:36:57]

NULL here and below.

[rileya (GONE FROM CHROMIUM), 2015/01/12 21:46:20]

I made each table a lazy instance, so no longer relevant.

+static const int16* g_table_jpeg = 0;
+static const int16* g_table_rec709 = 0;
+
 // 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;
     case YV12J:
-      return kCoefficientsRgbY_JPEG;
+      return g_table_jpeg;
+    case YV12HD:
+      return g_table_rec709;
   }
   NOTREACHED();
-  return kCoefficientsRgbY;
+  return g_table_rec601;
+}
+
+const int16* CreateYUVToRGBTable(const double matrix[3][3], bool full_range) {
+  // We'll have 4 sub-tables that lie contiguous in memory, one for each of Y,
+  // U, V and A.
+  int kNumTables = 4;
+  // Each table has 256 rows (for all possible 8-bit values).
+  int kNumRows = 256;
+  // Each row has 4 columns, for contributions to each of R, G, B and A.
+  int kNumColumns = 4;
+  // Each element is a fixed-point (10.6) 16-bit signed value.
+  int kElementSize = sizeof(int16);
+
+  // An RGB value can be computed by looking up the Y, U, V and A values in each
+  // table, adding them up, dropping the lower 6 bits and clamping into [0,255].
+  // We align to 16 bytes to make it more SIMD-friendly.
+  int16* table = static_cast<int16*>(base::AlignedAlloc(

[DaleCurtis, 2015/01/08 01:36:57]

You'll either need to use a LazyInstance::Leaky which contains
base::AlignedMemory<16, #size> member variables and point the global variables
at that or modify the valgrind/memcheck/lsan suppressions to let them know this
is an intentional leak.

If you go the suppression route you can submit this CL as is to the lsan,
drmemory, and valgrind bots to figure out what suppression to use and then add
them to the appropriate files under tools/valgrind as well as adding
ANNOTATE_LEAKING_OBJECT_PTR() for the allocations to keep lsan happy.

Using a LazyInstance::Leaky already has all of that suppressed.

[rileya (GONE FROM CHROMIUM), 2015/01/12 21:46:20]

I made each table a LazyInstance::Leaky of a struct that wraps over
base::AlignedMemory (it lacks a new() operator, so LazyInstance doesn't accept
it as a template arg). Does this look about right?

+      kNumTables * kNumRows * kNumColumns * kElementSize, 16));
+
+  // 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
+  static const double kRec601ConvertMatrix[3][3] = {

[DaleCurtis, 2015/01/08 01:36:57]

const is fine for all of these. Typically we want to avoid using static const
within function scope;

[rileya (GONE FROM CHROMIUM), 2015/01/12 21:46:20]

Done.

+      {1.164, 1.164, 1.164}, {0.0, -0.391, 2.018}, {1.596, -0.813, 0.0},
+  };
+
+  // JPEG table, values from above link.
+  static 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
+  static const double kRec709ConvertMatrix[3][3] = {
+      {1.164, 1.164, 1.164}, {0.0, -0.213, 2.112}, {1.793, -0.533, 0.0},
+  };
+
+  g_table_rec601 = CreateYUVToRGBTable(kRec601ConvertMatrix, false);
+  g_table_jpeg = CreateYUVToRGBTable(kJPEGConvertMatrix, true);
+  g_table_rec709 = CreateYUVToRGBTable(kRec709ConvertMatrix, false);
 }
 
 // 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 154 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,
+                                       GetLookupTable(yuv_type));

[DaleCurtis, 2015/01/08 01:36:57]

Call this one outside of the loops? Ditto for all the other users.

[rileya (GONE FROM CHROMIUM), 2015/01/12 21:46:21]

Done.

     } 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,
+                                              GetLookupTable(yuv_type));
       } 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, GetLookupTable(yuv_type));
       }
     }
   }
 
   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 117 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,
+                                          GetLookupTable(YV12));
     } 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,
+                                          GetLookupTable(YV12));
     }
 
     // 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