move constants into common

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 982 matching lines @@
     ++src_y;
   }
 }
 
 // BT.601 YUV to RGB reference
 //  R = (Y - 16) * 1.164              - V * -1.596
 //  G = (Y - 16) * 1.164 - U *  0.391 - V *  0.813
 //  B = (Y - 16) * 1.164 - U * -2.018
 
 // Y contribution to R,G,B.  Scale and bias.
-// TODO(fbarchard): Consider moving constants into a common header.
 #define YG 18997 /* round(1.164 * 64 * 256 * 256 / 257) */
 #define YGB -1160 /* 1.164 * 64 * -16 + 64 / 2 */
 
 // U and V contributions to R,G,B.
 #define UB -128 /* max(-128, round(-2.018 * 64)) */
 #define UG 25 /* round(0.391 * 64) */
 #define VG 52 /* round(0.813 * 64) */
 #define VR -102 /* round(-1.596 * 64) */
 
-// Bias values to subtract 16 from Y and 128 from U and V, with rounding.
-#define BB (UB * 128 + YGB)
+// 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)
+#define BR            (VR * 128 + YGB)
+
+// BT601 constants for YUV to RGB.
+YuvConstants SIMD_ALIGNED(kYuvConstants) = {
+  { UB, 0, UB, 0, UB, 0, UB, 0, UB, 0, UB, 0, UB, 0, UB, 0,
+    UB, 0, UB, 0, UB, 0, UB, 0, UB, 0, UB, 0, UB, 0, UB, 0 },
+  { UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG,
+    UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG },
+  { 0, VR, 0, VR, 0, VR, 0, VR, 0, VR, 0, VR, 0, VR, 0, VR,
+    0, VR, 0, VR, 0, VR, 0, VR, 0, VR, 0, VR, 0, VR, 0, VR },
+  { BB, BB, BB, BB, BB, BB, BB, BB, BB, BB, BB, BB, BB, BB, BB, BB },
+  { BG, BG, BG, BG, BG, BG, BG, BG, BG, BG, BG, BG, BG, BG, BG, BG },
+  { BR, BR, BR, BR, BR, BR, BR, BR, BR, BR, BR, BR, BR, BR, BR, BR },
+  { YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG }
+};
+
+// BT601 constants for NV21 where chroma plane is VU instead of UV.
+YuvConstants SIMD_ALIGNED(kYvuConstants) = {
+  { 0, UB, 0, UB, 0, UB, 0, UB, 0, UB, 0, UB, 0, UB, 0, UB,
+    0, UB, 0, UB, 0, UB, 0, UB, 0, UB, 0, UB, 0, UB, 0, UB },
+  { VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG,
+    VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG },
+  { VR, 0, VR, 0, VR, 0, VR, 0, VR, 0, VR, 0, VR, 0, VR, 0,
+    VR, 0, VR, 0, VR, 0, VR, 0, VR, 0, VR, 0, VR, 0, VR, 0 },
+  { BB, BB, BB, BB, BB, BB, BB, BB, BB, BB, BB, BB, BB, BB, BB, BB },
+  { BG, BG, BG, BG, BG, BG, BG, BG, BG, BG, BG, BG, BG, BG, BG, BG },
+  { BR, BR, BR, BR, BR, BR, BR, BR, BR, BR, BR, BR, BR, BR, BR, BR },
+  { YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG }
+};
+
+YuvConstantsNEON SIMD_ALIGNED(kYuvConstantsNEON) = {
+  { -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 }
+};
 
 // C reference code that mimics the YUV assembly.
 static __inline void YuvPixel(uint8 y, uint8 u, uint8 v,
                               uint8* b, uint8* g, uint8* r) {
   uint32 y1 = (uint32)(y * 0x0101 * YG) >> 16;
   *b = Clamp((int32)(-(u * UB) + y1 + BB) >> 6);
   *g = Clamp((int32)(-(v * VG + u * UG) + y1 + BG) >> 6);
   *r = Clamp((int32)(-(v * VR)+ y1 + BR) >> 6);
 }
 
 // C reference code that mimics the YUV assembly.
 static __inline void YPixel(uint8 y, uint8* b, uint8* g, uint8* r) {
   uint32 y1 = (uint32)(y * 0x0101 * YG) >> 16;
   *b = Clamp((int32)(y1 + YGB) >> 6);
   *g = Clamp((int32)(y1 + YGB) >> 6);
   *r = Clamp((int32)(y1 + YGB) >> 6);
 }
-
 #undef YG
 #undef YGB
 #undef UB
 #undef UG
 #undef VG
 #undef VR
 #undef BB
 #undef BG
 #undef BR
 
 // JPEG YUV to RGB reference
 // *  R = Y                - V * -1.40200
 // *  G = Y - U *  0.34414 - V *  0.71414
 // *  B = Y - U * -1.77200
 
 // Y contribution to R,G,B.  Scale and bias.
-// TODO(fbarchard): Consider moving constants into a common header.
 #define YGJ 16320 /* round(1.000 * 64 * 256 * 256 / 257) */
 #define YGBJ 32  /* 64 / 2 */
 
 // U and V contributions to R,G,B.
 #define UBJ -113 /* round(-1.77200 * 64) */
 #define UGJ 22 /* round(0.34414 * 64) */
 #define VGJ 46 /* round(0.71414  * 64) */
 #define VRJ -90 /* round(-1.40200 * 64) */
 
-// Bias values to round Y and subtract 128 from U and V.
-#define BBJ (UBJ * 128 + YGBJ)
+// 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)
+#define BRJ             (VRJ * 128 + YGBJ)
+
+// JPEG constants for YUV to RGB.
+YuvConstants SIMD_ALIGNED(kYuvJConstants) = {
+  { UBJ, 0, UBJ, 0, UBJ, 0, UBJ, 0, UBJ, 0, UBJ, 0, UBJ, 0, UBJ, 0,
+    UBJ, 0, UBJ, 0, UBJ, 0, UBJ, 0, UBJ, 0, UBJ, 0, UBJ, 0, UBJ, 0 },
+  { UGJ, VGJ, UGJ, VGJ, UGJ, VGJ, UGJ, VGJ,
+    UGJ, VGJ, UGJ, VGJ, UGJ, VGJ, UGJ, VGJ,
+    UGJ, VGJ, UGJ, VGJ, UGJ, VGJ, UGJ, VGJ,
+    UGJ, VGJ, UGJ, VGJ, UGJ, VGJ, UGJ, VGJ },
+  { 0, VRJ, 0, VRJ, 0, VRJ, 0, VRJ, 0, VRJ, 0, VRJ, 0, VRJ, 0, VRJ,
+    0, VRJ, 0, VRJ, 0, VRJ, 0, VRJ, 0, VRJ, 0, VRJ, 0, VRJ, 0, VRJ },
+  { BBJ, BBJ, BBJ, BBJ, BBJ, BBJ, BBJ, BBJ,
+    BBJ, BBJ, BBJ, BBJ, BBJ, BBJ, BBJ, BBJ },
+  { BGJ, BGJ, BGJ, BGJ, BGJ, BGJ, BGJ, BGJ,
+    BGJ, BGJ, BGJ, BGJ, BGJ, BGJ, BGJ, BGJ },
+  { BRJ, BRJ, BRJ, BRJ, BRJ, BRJ, BRJ, BRJ,
+    BRJ, BRJ, BRJ, BRJ, BRJ, BRJ, BRJ, BRJ },
+  { YGJ, YGJ, YGJ, YGJ, YGJ, YGJ, YGJ, YGJ,
+    YGJ, YGJ, YGJ, YGJ, YGJ, YGJ, YGJ, YGJ }
+};
+
+// JPEG constants for YUV to RGB.
+YuvConstantsNEON SIMD_ALIGNED(kYuvJConstantsNEON) = {
+  { -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 }
+};
 
 // C reference code that mimics the YUV assembly.
 static __inline void YuvJPixel(uint8 y, uint8 u, uint8 v,
                                uint8* b, uint8* g, uint8* r) {
   uint32 y1 = (uint32)(y * 0x0101 * YGJ) >> 16;
   *b = Clamp((int32)(-(u * UBJ) + y1 + BBJ) >> 6);
   *g = Clamp((int32)(-(v * VGJ + u * UGJ) + y1 + BGJ) >> 6);
   *r = Clamp((int32)(-(v * VRJ) + y1 + BRJ) >> 6);
 }
 
 #undef YGJ
 #undef YGBJ
 #undef UBJ
 #undef UGJ
 #undef VGJ
 #undef VRJ
 #undef BBJ
 #undef BGJ
 #undef BRJ
 
 // BT.709 YUV to RGB reference
 // *  R = Y                - V * -1.28033
 // *  G = Y - U *  0.21482 - V *  0.38059
 // *  B = Y - U * -2.12798
 
 // Y contribution to R,G,B.  Scale and bias.
-// TODO(fbarchard): Consider moving constants into a common header.
 #define YGH 16320 /* round(1.000 * 64 * 256 * 256 / 257) */
 #define YGBH 32  /* 64 / 2 */
 
 // U and V contributions to R,G,B.
 #define UBH -128 /* max(-128, round(-2.12798 * 64)) */
 #define UGH 14 /* round(0.21482 * 64) */
 #define VGH 24 /* round(0.38059  * 64) */
 #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.
+YuvConstants SIMD_ALIGNED(kYuvHConstants) = {
+  { UBH, 0, UBH, 0, UBH, 0, UBH, 0, UBH, 0, UBH, 0, UBH, 0, UBH, 0,
+    UBH, 0, UBH, 0, UBH, 0, UBH, 0, UBH, 0, UBH, 0, UBH, 0, UBH, 0 },
+  { UGH, VGH, UGH, VGH, UGH, VGH, UGH, VGH,
+    UGH, VGH, UGH, VGH, UGH, VGH, UGH, VGH,
+    UGH, VGH, UGH, VGH, UGH, VGH, UGH, VGH,
+    UGH, VGH, UGH, VGH, UGH, VGH, UGH, VGH },
+  { 0, VRH, 0, VRH, 0, VRH, 0, VRH, 0, VRH, 0, VRH, 0, VRH, 0, VRH,
+    0, VRH, 0, VRH, 0, VRH, 0, VRH, 0, VRH, 0, VRH, 0, VRH, 0, VRH },
+  { BBH, BBH, BBH, BBH, BBH, BBH, BBH, BBH,
+    BBH, BBH, BBH, BBH, BBH, BBH, BBH, BBH },
+  { BGH, BGH, BGH, BGH, BGH, BGH, BGH, BGH,
+    BGH, BGH, BGH, BGH, BGH, BGH, BGH, BGH },
+  { BRH, BRH, BRH, BRH, BRH, BRH, BRH, BRH,
+    BRH, BRH, BRH, BRH, BRH, BRH, BRH, BRH },
+  { YGH, YGH, YGH, YGH, YGH, YGH, YGH, YGH,
+    YGH, YGH, YGH, YGH, YGH, YGH, YGH, YGH }
+};
+
+// BT.709 constants for YUV to RGB.
+YuvConstantsNEON SIMD_ALIGNED(kYuvHConstantsNEON) = {
+  { -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 }
+};
+
 // C reference code that mimics the YUV assembly.
 static __inline void YuvHPixel(uint8 y, uint8 u, uint8 v,
                                uint8* b, uint8* g, uint8* r) {
   uint32 y1 = (uint32)(y * 0x0101 * YGH) >> 16;
   *b = Clamp((int32)(-(u * UBH) + y1 + BBH) >> 6);
   *g = Clamp((int32)(-(v * VGH + u * UGH) + y1 + BGH) >> 6);
   *r = Clamp((int32)(-(v * VRH) + y1 + BRH) >> 6);
 }
 
 #undef YGH
@@ skipping 1191 matching lines @@
     src_v += 1;
   }
   if (width & 1) {
     dst_frame[0] = src_u[0];
     dst_frame[1] = src_y[0];
     dst_frame[2] = src_v[0];
     dst_frame[3] = 0;
   }
 }
 
-extern struct YuvConstants kYuvConstants;
-extern struct YuvConstants kYuvJConstants;
-extern struct YuvConstants kYuvHConstants;
-extern struct YuvConstantsNEON kYuvConstantsNEON;
-extern struct YuvConstantsNEON kYuvJConstantsNEON;
-extern struct YuvConstantsNEON kYuvHConstantsNEON;
-
 #define ANYYUV(NAMEANY, ANY_SIMD, YUVCONSTANTS)                                \
     void NAMEANY(const uint8* y_buf,                                           \
                  const uint8* u_buf,                                           \
                  const uint8* v_buf,                                           \
                  uint8* dst_argb,                                              \
                  int width) {                                                  \
       ANY_SIMD(y_buf, u_buf, v_buf, dst_argb, &YUVCONSTANTS, width);           \
     }
 
 #ifdef HAS_I422TOARGBMATRIXROW_NEON
@@ skipping 451 matching lines @@
   }
   if (width & 1) {
     dst[3] = src[0];
   }
 }
 
 #ifdef __cplusplus
 }  // extern "C"
 }  // namespace libyuv
 #endif