fix for yuv to rgb on arm64.

source/row_common.cc

 /*
  *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS. All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 999 matching lines @@
 #define VR -102 /* round(-1.596 * 64) */
 
 // Bias values to subtract 16 from Y and 128 from U and V.
 #define BB (UB * 128            + YGB)
 #define BG (UG * 128 + VG * 128 + YGB)
 #define BR            (VR * 128 + YGB)
 
 // BT.601 constants for YUV to RGB.
 // TODO(fbarchard): Unify these structures to be platform independent.
 // TODO(fbarchard): Generate SIMD structures from float matrix.
+
+// BT601 constants for YUV to RGB.
 #if defined(__aarch64__)
 const YuvConstants SIMD_ALIGNED(kYuvIConstants) = {
-  { -UB, 0, -UB, 0, -UB, 0, -UB, 0, -VR, 0, -VR, 0, -VR, 0, -VR, 0 },
-  { UG, 0, UG, 0, UG, 0, UG, 0, VG, 0, VG, 0, VG, 0, VG, 0 },
+  { -UB, -VR, -UB, -VR, -UB, -VR, -UB, -VR },
+  { -UB, -VR, -UB, -VR, -UB, -VR, -UB, -VR },
+  { UG, VG, UG, VG, UG, VG, UG, VG },
+  { UG, VG, UG, VG, UG, VG, UG, VG },
   { BB, BG, BR, 0, 0, 0, 0, 0 },
   { 0x0101 * YG, 0, 0, 0 }
- };
+};
 
 #elif defined(__arm__)
 const YuvConstants SIMD_ALIGNED(kYuvIConstants) = {
   { -UB, -UB, -UB, -UB, -VR, -VR, -VR, -VR, 0, 0, 0, 0, 0, 0, 0, 0 },
   { UG, UG, UG, UG, VG, VG, VG, VG, 0, 0, 0, 0, 0, 0, 0, 0 },
   { BB, BG, BR, 0, 0, 0, 0, 0 },
   { 0x0101 * YG, 0, 0, 0 }
 };
 #else
 const YuvConstants SIMD_ALIGNED(kYuvIConstants) = {
@@ skipping 28 matching lines @@
 #undef VR
 #undef YG
 
 // C reference code that mimics the YUV assembly.
 static __inline void YuvPixel(uint8 y, uint8 u, uint8 v,
                               uint8* b, uint8* g, uint8* r,
                               const struct YuvConstants* yuvconstants) {
 #if defined(__aarch64__)
   int UB = -yuvconstants->kUVToRB[0];
   int UG = yuvconstants->kUVToG[0];
-  int VG = yuvconstants->kUVToG[8];
-  int VR = -yuvconstants->kUVToRB[8];
+  int VG = yuvconstants->kUVToG[1];
+  int VR = -yuvconstants->kUVToRB[1];
   int BB = yuvconstants->kUVBiasBGR[0];
   int BG = yuvconstants->kUVBiasBGR[1];
   int BR = yuvconstants->kUVBiasBGR[2];
   int YG = yuvconstants->kYToRgb[0];
 #elif defined(__arm__)
   int UB = -yuvconstants->kUVToRB[0];
   int UG = yuvconstants->kUVToG[0];
   int VG = yuvconstants->kUVToG[4];
   int VR = -yuvconstants->kUVToRB[4];
   int BB = yuvconstants->kUVBiasBGR[0];
@@ skipping 32 matching lines @@
 #define VRJ -90 /* round(-1.40200 * 64) */
 
 // Bias values to round, and subtract 128 from U and V.
 #define BBJ (UBJ * 128             + YGBJ)
 #define BGJ (UGJ * 128 + VGJ * 128 + YGBJ)
 #define BRJ             (VRJ * 128 + YGBJ)
 
 // JPEG constants for YUV to RGB.
 #if defined(__aarch64__)
 const YuvConstants SIMD_ALIGNED(kYuvJConstants) = {
-  { -UBJ, 0, -UBJ, 0, -UBJ, 0, -UBJ, 0, -VRJ, 0, -VRJ, 0, -VRJ, 0, -VRJ, 0 },
-  { UGJ, 0, UGJ, 0, UGJ, 0, UGJ, 0, VGJ, 0, VGJ, 0, VGJ, 0, VGJ, 0 },
+  { -UBJ, -VRJ, -UBJ, -VRJ, -UBJ, -VRJ, -UBJ, -VRJ },
+  { -UBJ, -VRJ, -UBJ, -VRJ, -UBJ, -VRJ, -UBJ, -VRJ },
+  { UGJ, VGJ, UGJ, VGJ, UGJ, VGJ, UGJ, VGJ },
+  { UGJ, VGJ, UGJ, VGJ, UGJ, VGJ, UGJ, VGJ },
   { BBJ, BGJ, BRJ, 0, 0, 0, 0, 0 },
   { 0x0101 * YGJ, 0, 0, 0 }
- };
+};
 
 #elif defined(__arm__)
 const YuvConstants SIMD_ALIGNED(kYuvJConstants) = {
   { -UBJ, -UBJ, -UBJ, -UBJ, -VRJ, -VRJ, -VRJ, -VRJ, 0, 0, 0, 0, 0, 0, 0, 0 },
   { UGJ, UGJ, UGJ, UGJ, VGJ, VGJ, VGJ, VGJ, 0, 0, 0, 0, 0, 0, 0, 0 },
   { BBJ, BGJ, BRJ, 0, 0, 0, 0, 0 },
   { 0x0101 * YGJ, 0, 0, 0 }
 };
 #else
 const YuvConstants SIMD_ALIGNED(kYuvJConstants) = {
@@ skipping 43 matching lines @@
 #define VRH -82 /* round(-1.28033 * 64) */
 
 // Bias values to round, and subtract 128 from U and V.
 #define BBH (UBH * 128 + YGBH)
 #define BGH (UGH * 128 + VGH * 128 + YGBH)
 #define BRH (VRH * 128 + YGBH)
 
 // BT.709 constants for YUV to RGB.
 #if defined(__aarch64__)
 const YuvConstants SIMD_ALIGNED(kYuvHConstants) = {
-  { -UBH, 0, -UBH, 0, -UBH, 0, -UBH, 0, -VRH, 0, -VRH, 0, -VRH, 0, -VRH, 0 },
-  { UGH, 0, UGH, 0, UGH, 0, UGH, 0, VGH, 0, VGH, 0, VGH, 0, VGH, 0 },
+  { -UBH, -VRH, -UBH, -VRH, -UBH, -VRH, -UBH, -VRH },
+  { -UBH, -VRH, -UBH, -VRH, -UBH, -VRH, -UBH, -VRH },
+  { UGH, VGH, UGH, VGH, UGH, VGH, UGH, VGH },
+  { UGH, VGH, UGH, VGH, UGH, VGH, UGH, VGH },
   { BBH, BGH, BRH, 0, 0, 0, 0, 0 },
   { 0x0101 * YGH, 0, 0, 0 }
- };
+};
 
 #elif defined(__arm__)
 const YuvConstants SIMD_ALIGNED(kYuvHConstants) = {
   { -UBH, -UBH, -UBH, -UBH, -VRH, -VRH, -VRH, -VRH, 0, 0, 0, 0, 0, 0, 0, 0 },
   { UGH, UGH, UGH, UGH, VGH, VGH, VGH, VGH, 0, 0, 0, 0, 0, 0, 0, 0 },
   { BBH, BGH, BRH, 0, 0, 0, 0, 0 },
   { 0x0101 * YGH, 0, 0, 0 }
 };
 #else
 const YuvConstants SIMD_ALIGNED(kYuvHConstants) = {
@@ skipping 1479 matching lines @@
     dst_rgb565 += twidth * 2;
     width -= twidth;
   }
 }
 #endif
 
 #ifdef __cplusplus
 }  // extern "C"
 }  // namespace libyuv
 #endif