Add correct support for videos with YUVJ420P color format, in the software conversion 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/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 34 matching lines @@
                                       int,
                                       int,
                                       int,
                                       int,
                                       YUVType);
 
 typedef void (*ConvertYUVToRGB32RowProc)(const uint8*,
                                          const uint8*,
                                          const uint8*,
                                          uint8*,
-                                         ptrdiff_t);
+                                         ptrdiff_t,
+                                         const int16[1024][4]);
 
 typedef void (*ConvertYUVAToARGBRowProc)(const uint8*,
                                          const uint8*,
                                          const uint8*,
                                          const uint8*,
                                          uint8*,
-                                         ptrdiff_t);
+                                         ptrdiff_t,
+                                         const int16[1024][4]);
 
 typedef void (*ScaleYUVToRGB32RowProc)(const uint8*,
                                        const uint8*,
                                        const uint8*,
                                        uint8*,
                                        ptrdiff_t,
-                                       ptrdiff_t);
+                                       ptrdiff_t,
+                                       const int16[1024][4]);
 
 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;
 
 // 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:
+      return 1;
+  }
+}
+
 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_);
   CHECK(!g_convert_yuva_to_argb_proc_);
   CHECK(!g_empty_register_state_proc_);
@@ skipping 90 matching lines @@
   // 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;
 
-  unsigned int y_shift = yuv_type;
+  unsigned int y_shift = GetVerticalShift(yuv_type);
   // Diagram showing origin and direction of source sampling.
   // ->0   4<-
   // 7       3
   //
   // 6       5
   // ->1   2<-
   // Rotations that start at right side of image.
   if ((view_rotate == ROTATE_180) || (view_rotate == ROTATE_270) ||
       (view_rotate == MIRROR_ROTATE_0) || (view_rotate == MIRROR_ROTATE_90)) {
     y_buf += source_width - 1;
@@ skipping 111 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);
+      g_convert_yuv_to_rgb32_row_proc_(
+          y_ptr, u_ptr, v_ptr, dest_pixel, width, kCoefficientsRgbY);
     } 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);
+        g_linear_scale_yuv_to_rgb32_row_proc_(y_ptr,
+                                              u_ptr,
+                                              v_ptr,
+                                              dest_pixel,
+                                              width,
+                                              source_dx,
+                                              kCoefficientsRgbY);
       } else {
-        g_scale_yuv_to_rgb32_row_proc_(
-            y_ptr, u_ptr, v_ptr, dest_pixel, width, source_dx);
+        g_scale_yuv_to_rgb32_row_proc_(y_ptr,
+                                       u_ptr,
+                                       v_ptr,
+                                       dest_pixel,
+                                       width,
+                                       source_dx,
+                                       kCoefficientsRgbY);
       }
     }
   }
 
   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 123 matching lines @@
           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);
+                                          x_step,
+                                          kCoefficientsRgbY);
     } 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);
+                                          x_step,
+                                          kCoefficientsRgbY);
     }
 
     // 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