src/third_party/libyuv/source/row_any.cc

   1 /*
   2  *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS. All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include "libyuv/row.h"
  12
  13 #include "libyuv/basic_types.h"
  14
  15 #ifdef __cplusplus
  16 namespace libyuv {
  17 extern "C" {
  18 #endif
  19
  20 // TODO(fbarchard): Consider 'any' functions handling any quantity of pixels.
  21 // TODO(fbarchard): Consider 'any' functions handling odd alignment.
  22 // YUV to RGB does multiple of 8 with SIMD and remainder with C.
  23 #define YANY(NAMEANY, I420TORGB_SIMD, I420TORGB_C, UV_SHIFT, BPP, MASK)        \
  24     void NAMEANY(const uint8* y_buf,                                           \
  25                  const uint8* u_buf,                                           \
  26                  const uint8* v_buf,                                           \
  27                  uint8* rgb_buf,                                               \
  28                  int width) {                                                  \
  29       int n = width & ~MASK;                                                   \
  30       I420TORGB_SIMD(y_buf, u_buf, v_buf, rgb_buf, n);                         \
  31       I420TORGB_C(y_buf + n,                                                   \
  32                   u_buf + (n >> UV_SHIFT),                                     \
  33                   v_buf + (n >> UV_SHIFT),                                     \
  34                   rgb_buf + n * BPP, width & MASK);                            \
  35     }
  36
  37 #ifdef HAS_I422TOARGBROW_SSSE3
  38 YANY(I444ToARGBRow_Any_SSSE3, I444ToARGBRow_Unaligned_SSSE3, I444ToARGBRow_C,
  39      0, 4, 7)
  40 YANY(I422ToARGBRow_Any_SSSE3, I422ToARGBRow_Unaligned_SSSE3, I422ToARGBRow_C,
  41      1, 4, 7)
  42 YANY(I411ToARGBRow_Any_SSSE3, I411ToARGBRow_Unaligned_SSSE3, I411ToARGBRow_C,
  43      2, 4, 7)
  44 YANY(I422ToBGRARow_Any_SSSE3, I422ToBGRARow_Unaligned_SSSE3, I422ToBGRARow_C,
  45      1, 4, 7)
  46 YANY(I422ToABGRRow_Any_SSSE3, I422ToABGRRow_Unaligned_SSSE3, I422ToABGRRow_C,
  47      1, 4, 7)
  48 YANY(I422ToRGBARow_Any_SSSE3, I422ToRGBARow_Unaligned_SSSE3, I422ToRGBARow_C,
  49      1, 4, 7)
  50 // I422ToRGB565Row_SSSE3 is unaligned.
  51 YANY(I422ToARGB4444Row_Any_SSSE3, I422ToARGB4444Row_SSSE3, I422ToARGB4444Row_C,
  52      1, 2, 7)
  53 YANY(I422ToARGB1555Row_Any_SSSE3, I422ToARGB1555Row_SSSE3, I422ToARGB1555Row_C,
  54      1, 2, 7)
  55 YANY(I422ToRGB565Row_Any_SSSE3, I422ToRGB565Row_SSSE3, I422ToRGB565Row_C,
  56      1, 2, 7)
  57 // I422ToRGB24Row_SSSE3 is unaligned.
  58 YANY(I422ToRGB24Row_Any_SSSE3, I422ToRGB24Row_SSSE3, I422ToRGB24Row_C, 1, 3, 7)
  59 YANY(I422ToRAWRow_Any_SSSE3, I422ToRAWRow_SSSE3, I422ToRAWRow_C, 1, 3, 7)
  60 YANY(I422ToYUY2Row_Any_SSE2, I422ToYUY2Row_SSE2, I422ToYUY2Row_C, 1, 2, 15)
  61 YANY(I422ToUYVYRow_Any_SSE2, I422ToUYVYRow_SSE2, I422ToUYVYRow_C, 1, 2, 15)
  62 #endif  // HAS_I422TOARGBROW_SSSE3
  63 #ifdef HAS_I422TOARGBROW_AVX2
  64 YANY(I422ToARGBRow_Any_AVX2, I422ToARGBRow_AVX2, I422ToARGBRow_C, 1, 4, 15)
  65 #endif  // HAS_I422TOARGBROW_AVX2
  66 #ifdef HAS_I422TOARGBROW_NEON
  67 YANY(I444ToARGBRow_Any_NEON, I444ToARGBRow_NEON, I444ToARGBRow_C, 0, 4, 7)
  68 YANY(I422ToARGBRow_Any_NEON, I422ToARGBRow_NEON, I422ToARGBRow_C, 1, 4, 7)
  69 YANY(I411ToARGBRow_Any_NEON, I411ToARGBRow_NEON, I411ToARGBRow_C, 2, 4, 7)
  70 YANY(I422ToBGRARow_Any_NEON, I422ToBGRARow_NEON, I422ToBGRARow_C, 1, 4, 7)
  71 YANY(I422ToABGRRow_Any_NEON, I422ToABGRRow_NEON, I422ToABGRRow_C, 1, 4, 7)
  72 YANY(I422ToRGBARow_Any_NEON, I422ToRGBARow_NEON, I422ToRGBARow_C, 1, 4, 7)
  73 YANY(I422ToRGB24Row_Any_NEON, I422ToRGB24Row_NEON, I422ToRGB24Row_C, 1, 3, 7)
  74 YANY(I422ToRAWRow_Any_NEON, I422ToRAWRow_NEON, I422ToRAWRow_C, 1, 3, 7)
  75 YANY(I422ToARGB4444Row_Any_NEON, I422ToARGB4444Row_NEON, I422ToARGB4444Row_C,
  76      1, 2, 7)
  77 YANY(I422ToARGB1555Row_Any_NEON, I422ToARGB1555Row_NEON, I422ToARGB1555Row_C,
  78      1, 2, 7)
  79 YANY(I422ToRGB565Row_Any_NEON, I422ToRGB565Row_NEON, I422ToRGB565Row_C, 1, 2, 7)
  80 YANY(I422ToYUY2Row_Any_NEON, I422ToYUY2Row_NEON, I422ToYUY2Row_C, 1, 2, 15)
  81 YANY(I422ToUYVYRow_Any_NEON, I422ToUYVYRow_NEON, I422ToUYVYRow_C, 1, 2, 15)
  82 #endif  // HAS_I422TOARGBROW_NEON
  83 #undef YANY
  84
  85 // Wrappers to handle odd width
  86 #define NV2NY(NAMEANY, NV12TORGB_SIMD, NV12TORGB_C, UV_SHIFT, BPP)             \
  87     void NAMEANY(const uint8* y_buf,                                           \
  88                  const uint8* uv_buf,                                          \
  89                  uint8* rgb_buf,                                               \
  90                  int width) {                                                  \
  91       int n = width & ~7;                                                      \
  92       NV12TORGB_SIMD(y_buf, uv_buf, rgb_buf, n);                               \
  93       NV12TORGB_C(y_buf + n,                                                   \
  94                   uv_buf + (n >> UV_SHIFT),                                    \
  95                   rgb_buf + n * BPP, width & 7);                               \
  96     }
  97
  98 #ifdef HAS_NV12TOARGBROW_SSSE3
  99 NV2NY(NV12ToARGBRow_Any_SSSE3, NV12ToARGBRow_Unaligned_SSSE3, NV12ToARGBRow_C,
 100       0, 4)
 101 NV2NY(NV21ToARGBRow_Any_SSSE3, NV21ToARGBRow_Unaligned_SSSE3, NV21ToARGBRow_C,
 102       0, 4)
 103 #endif  // HAS_NV12TOARGBROW_SSSE3
 104 #ifdef HAS_NV12TOARGBROW_NEON
 105 NV2NY(NV12ToARGBRow_Any_NEON, NV12ToARGBRow_NEON, NV12ToARGBRow_C, 0, 4)
 106 NV2NY(NV21ToARGBRow_Any_NEON, NV21ToARGBRow_NEON, NV21ToARGBRow_C, 0, 4)
 107 #endif  // HAS_NV12TOARGBROW_NEON
 108 #ifdef HAS_NV12TORGB565ROW_SSSE3
 109 NV2NY(NV12ToRGB565Row_Any_SSSE3, NV12ToRGB565Row_SSSE3, NV12ToRGB565Row_C,
 110       0, 2)
 111 NV2NY(NV21ToRGB565Row_Any_SSSE3, NV21ToRGB565Row_SSSE3, NV21ToRGB565Row_C,
 112       0, 2)
 113 #endif  // HAS_NV12TORGB565ROW_SSSE3
 114 #ifdef HAS_NV12TORGB565ROW_NEON
 115 NV2NY(NV12ToRGB565Row_Any_NEON, NV12ToRGB565Row_NEON, NV12ToRGB565Row_C, 0, 2)
 116 NV2NY(NV21ToRGB565Row_Any_NEON, NV21ToRGB565Row_NEON, NV21ToRGB565Row_C, 0, 2)
 117 #endif  // HAS_NV12TORGB565ROW_NEON
 118 #undef NVANY
 119
 120 #define RGBANY(NAMEANY, ARGBTORGB_SIMD, ARGBTORGB_C, MASK, SBPP, BPP)          \
 121     void NAMEANY(const uint8* src,                                             \
 122                  uint8* dst,                                                   \
 123                  int width) {                                                  \
 124       int n = width & ~MASK;                                                   \
 125       ARGBTORGB_SIMD(src, dst, n);                                             \
 126       ARGBTORGB_C(src + n * SBPP, dst + n * BPP, width & MASK);                \
 127     }
 128
 129 #if defined(HAS_ARGBTORGB24ROW_SSSE3)
 130 RGBANY(ARGBToRGB24Row_Any_SSSE3, ARGBToRGB24Row_SSSE3, ARGBToRGB24Row_C,
 131        15, 4, 3)
 132 RGBANY(ARGBToRAWRow_Any_SSSE3, ARGBToRAWRow_SSSE3, ARGBToRAWRow_C,
 133        15, 4, 3)
 134 RGBANY(ARGBToRGB565Row_Any_SSE2, ARGBToRGB565Row_SSE2, ARGBToRGB565Row_C,
 135        3, 4, 2)
 136 RGBANY(ARGBToARGB1555Row_Any_SSE2, ARGBToARGB1555Row_SSE2, ARGBToARGB1555Row_C,
 137        3, 4, 2)
 138 RGBANY(ARGBToARGB4444Row_Any_SSE2, ARGBToARGB4444Row_SSE2, ARGBToARGB4444Row_C,
 139        3, 4, 2)
 140 RGBANY(I400ToARGBRow_Any_SSE2, I400ToARGBRow_Unaligned_SSE2, I400ToARGBRow_C,
 141        7, 1, 4)
 142 RGBANY(YToARGBRow_Any_SSE2, YToARGBRow_SSE2, YToARGBRow_C,
 143        7, 1, 4)
 144 RGBANY(YUY2ToARGBRow_Any_SSSE3, YUY2ToARGBRow_Unaligned_SSSE3, YUY2ToARGBRow_C,
 145        15, 2, 4)
 146 RGBANY(UYVYToARGBRow_Any_SSSE3, UYVYToARGBRow_Unaligned_SSSE3, UYVYToARGBRow_C,
 147        15, 2, 4)
 148 // These require alignment on ARGB, so C is used for remainder.
 149 RGBANY(RGB24ToARGBRow_Any_SSSE3, RGB24ToARGBRow_SSSE3, RGB24ToARGBRow_C,
 150        15, 3, 4)
 151 RGBANY(RAWToARGBRow_Any_SSSE3, RAWToARGBRow_SSSE3, RAWToARGBRow_C,
 152        15, 3, 4)
 153 RGBANY(RGB565ToARGBRow_Any_SSE2, RGB565ToARGBRow_SSE2, RGB565ToARGBRow_C,
 154        7, 2, 4)
 155 RGBANY(ARGB1555ToARGBRow_Any_SSE2, ARGB1555ToARGBRow_SSE2, ARGB1555ToARGBRow_C,
 156        7, 2, 4)
 157 RGBANY(ARGB4444ToARGBRow_Any_SSE2, ARGB4444ToARGBRow_SSE2, ARGB4444ToARGBRow_C,
 158        7, 2, 4)
 159 #endif
 160 #if defined(HAS_ARGBTORGB24ROW_NEON)
 161 RGBANY(ARGBToRGB24Row_Any_NEON, ARGBToRGB24Row_NEON, ARGBToRGB24Row_C, 7, 4, 3)
 162 RGBANY(ARGBToRAWRow_Any_NEON, ARGBToRAWRow_NEON, ARGBToRAWRow_C, 7, 4, 3)
 163 RGBANY(ARGBToRGB565Row_Any_NEON, ARGBToRGB565Row_NEON, ARGBToRGB565Row_C,
 164        7, 4, 2)
 165 RGBANY(ARGBToARGB1555Row_Any_NEON, ARGBToARGB1555Row_NEON, ARGBToARGB1555Row_C,
 166        7, 4, 2)
 167 RGBANY(ARGBToARGB4444Row_Any_NEON, ARGBToARGB4444Row_NEON, ARGBToARGB4444Row_C,
 168        7, 4, 2)
 169 RGBANY(I400ToARGBRow_Any_NEON, I400ToARGBRow_NEON, I400ToARGBRow_C,
 170        7, 1, 4)
 171 RGBANY(YToARGBRow_Any_NEON, YToARGBRow_NEON, YToARGBRow_C,
 172        7, 1, 4)
 173 RGBANY(YUY2ToARGBRow_Any_NEON, YUY2ToARGBRow_NEON, YUY2ToARGBRow_C,
 174        7, 2, 4)
 175 RGBANY(UYVYToARGBRow_Any_NEON, UYVYToARGBRow_NEON, UYVYToARGBRow_C,
 176        7, 2, 4)
 177 #endif
 178 #undef RGBANY
 179
 180 // ARGB to Bayer does multiple of 4 pixels, SSSE3 aligned src, unaligned dst.
 181 #define BAYERANY(NAMEANY, ARGBTORGB_SIMD, ARGBTORGB_C, MASK, SBPP, BPP)        \
 182     void NAMEANY(const uint8* src,                                             \
 183                  uint8* dst, uint32 selector,                                  \
 184                  int width) {                                                  \
 185       int n = width & ~MASK;                                                   \
 186       ARGBTORGB_SIMD(src, dst, selector, n);                                   \
 187       ARGBTORGB_C(src + n * SBPP, dst + n * BPP, selector, width & MASK);      \
 188     }
 189
 190 #if defined(HAS_ARGBTOBAYERROW_SSSE3)
 191 BAYERANY(ARGBToBayerRow_Any_SSSE3, ARGBToBayerRow_SSSE3, ARGBToBayerRow_C,
 192          7, 4, 1)
 193 #endif
 194 #if defined(HAS_ARGBTOBAYERROW_NEON)
 195 BAYERANY(ARGBToBayerRow_Any_NEON, ARGBToBayerRow_NEON, ARGBToBayerRow_C,
 196          7, 4, 1)
 197 #endif
 198 #undef BAYERANY
 199
 200 // RGB/YUV to Y does multiple of 16 with SIMD and last 16 with SIMD.
 201 #define YANY(NAMEANY, ARGBTOY_SIMD, SBPP, BPP, NUM)                            \
 202     void NAMEANY(const uint8* src_argb, uint8* dst_y, int width) {             \
 203       ARGBTOY_SIMD(src_argb, dst_y, width - NUM);                              \
 204       ARGBTOY_SIMD(src_argb + (width - NUM) * SBPP,                            \
 205                    dst_y + (width - NUM) * BPP, NUM);                          \
 206     }
 207
 208 #ifdef HAS_ARGBTOYROW_AVX2
 209 YANY(ARGBToYRow_Any_AVX2, ARGBToYRow_AVX2, 4, 1, 32)
 210 YANY(ARGBToYJRow_Any_AVX2, ARGBToYJRow_AVX2, 4, 1, 32)
 211 YANY(YUY2ToYRow_Any_AVX2, YUY2ToYRow_AVX2, 2, 1, 32)
 212 YANY(UYVYToYRow_Any_AVX2, UYVYToYRow_AVX2, 2, 1, 32)
 213 #endif
 214 #ifdef HAS_ARGBTOYROW_SSSE3
 215 YANY(ARGBToYRow_Any_SSSE3, ARGBToYRow_Unaligned_SSSE3, 4, 1, 16)
 216 YANY(BGRAToYRow_Any_SSSE3, BGRAToYRow_Unaligned_SSSE3, 4, 1, 16)
 217 YANY(ABGRToYRow_Any_SSSE3, ABGRToYRow_Unaligned_SSSE3, 4, 1, 16)
 218 YANY(RGBAToYRow_Any_SSSE3, RGBAToYRow_Unaligned_SSSE3, 4, 1, 16)
 219 YANY(YUY2ToYRow_Any_SSE2, YUY2ToYRow_Unaligned_SSE2, 2, 1, 16)
 220 YANY(UYVYToYRow_Any_SSE2, UYVYToYRow_Unaligned_SSE2, 2, 1, 16)
 221 #endif
 222 #ifdef HAS_ARGBTOYJROW_SSSE3
 223 YANY(ARGBToYJRow_Any_SSSE3, ARGBToYJRow_Unaligned_SSSE3, 4, 1, 16)
 224 #endif
 225 #ifdef HAS_ARGBTOYROW_NEON
 226 YANY(ARGBToYRow_Any_NEON, ARGBToYRow_NEON, 4, 1, 8)
 227 YANY(ARGBToYJRow_Any_NEON, ARGBToYJRow_NEON, 4, 1, 8)
 228 YANY(BGRAToYRow_Any_NEON, BGRAToYRow_NEON, 4, 1, 8)
 229 YANY(ABGRToYRow_Any_NEON, ABGRToYRow_NEON, 4, 1, 8)
 230 YANY(RGBAToYRow_Any_NEON, RGBAToYRow_NEON, 4, 1, 8)
 231 YANY(RGB24ToYRow_Any_NEON, RGB24ToYRow_NEON, 3, 1, 8)
 232 YANY(RAWToYRow_Any_NEON, RAWToYRow_NEON, 3, 1, 8)
 233 YANY(RGB565ToYRow_Any_NEON, RGB565ToYRow_NEON, 2, 1, 8)
 234 YANY(ARGB1555ToYRow_Any_NEON, ARGB1555ToYRow_NEON, 2, 1, 8)
 235 YANY(ARGB4444ToYRow_Any_NEON, ARGB4444ToYRow_NEON, 2, 1, 8)
 236 YANY(YUY2ToYRow_Any_NEON, YUY2ToYRow_NEON, 2, 1, 16)
 237 YANY(UYVYToYRow_Any_NEON, UYVYToYRow_NEON, 2, 1, 16)
 238 YANY(RGB24ToARGBRow_Any_NEON, RGB24ToARGBRow_NEON, 3, 4, 8)
 239 YANY(RAWToARGBRow_Any_NEON, RAWToARGBRow_NEON, 3, 4, 8)
 240 YANY(RGB565ToARGBRow_Any_NEON, RGB565ToARGBRow_NEON, 2, 4, 8)
 241 YANY(ARGB1555ToARGBRow_Any_NEON, ARGB1555ToARGBRow_NEON, 2, 4, 8)
 242 YANY(ARGB4444ToARGBRow_Any_NEON, ARGB4444ToARGBRow_NEON, 2, 4, 8)
 243 #endif
 244 #undef YANY
 245
 246 #define YANY(NAMEANY, ARGBTOY_SIMD, ARGBTOY_C, SBPP, BPP, MASK)                \
 247     void NAMEANY(const uint8* src_argb, uint8* dst_y, int width) {             \
 248       int n = width & ~MASK;                                                   \
 249       ARGBTOY_SIMD(src_argb, dst_y, n);                                        \
 250       ARGBTOY_C(src_argb + n * SBPP,                                           \
 251                 dst_y  + n * BPP, width & MASK);                               \
 252     }
 253
 254 // Attenuate is destructive so last16 method can not be used due to overlap.
 255 #ifdef HAS_ARGBATTENUATEROW_SSSE3
 256 YANY(ARGBAttenuateRow_Any_SSSE3, ARGBAttenuateRow_SSSE3, ARGBAttenuateRow_C,
 257      4, 4, 3)
 258 #endif
 259 #ifdef HAS_ARGBATTENUATEROW_SSE2
 260 YANY(ARGBAttenuateRow_Any_SSE2, ARGBAttenuateRow_SSE2, ARGBAttenuateRow_C,
 261      4, 4, 3)
 262 #endif
 263 #ifdef HAS_ARGBUNATTENUATEROW_SSE2
 264 YANY(ARGBUnattenuateRow_Any_SSE2, ARGBUnattenuateRow_SSE2, ARGBUnattenuateRow_C,
 265      4, 4, 3)
 266 #endif
 267 #ifdef HAS_ARGBATTENUATEROW_AVX2
 268 YANY(ARGBAttenuateRow_Any_AVX2, ARGBAttenuateRow_AVX2, ARGBAttenuateRow_C,
 269      4, 4, 7)
 270 #endif
 271 #ifdef HAS_ARGBUNATTENUATEROW_AVX2
 272 YANY(ARGBUnattenuateRow_Any_AVX2, ARGBUnattenuateRow_AVX2, ARGBUnattenuateRow_C,
 273      4, 4, 7)
 274 #endif
 275 #ifdef HAS_ARGBATTENUATEROW_NEON
 276 YANY(ARGBAttenuateRow_Any_NEON, ARGBAttenuateRow_NEON, ARGBAttenuateRow_C,
 277      4, 4, 7)
 278 #endif
 279 #undef YANY
 280
 281 // RGB/YUV to UV does multiple of 16 with SIMD and remainder with C.
 282 #define UVANY(NAMEANY, ANYTOUV_SIMD, ANYTOUV_C, BPP, MASK)                     \
 283     void NAMEANY(const uint8* src_argb, int src_stride_argb,                   \
 284                  uint8* dst_u, uint8* dst_v, int width) {                      \
 285       int n = width & ~MASK;                                                   \
 286       ANYTOUV_SIMD(src_argb, src_stride_argb, dst_u, dst_v, n);                \
 287       ANYTOUV_C(src_argb  + n * BPP, src_stride_argb,                          \
 288                 dst_u + (n >> 1),                                              \
 289                 dst_v + (n >> 1),                                              \
 290                 width & MASK);                                                 \
 291     }
 292
 293 #ifdef HAS_ARGBTOYROW_AVX2
 294 UVANY(ARGBToUVRow_Any_AVX2, ARGBToUVRow_AVX2, ARGBToUVRow_C, 4, 31)
 295 UVANY(YUY2ToUVRow_Any_AVX2, YUY2ToUVRow_AVX2, YUY2ToUVRow_C, 2, 31)
 296 UVANY(UYVYToUVRow_Any_AVX2, UYVYToUVRow_AVX2, UYVYToUVRow_C, 2, 31)
 297 #endif
 298 #ifdef HAS_ARGBTOUVROW_SSSE3
 299 UVANY(ARGBToUVRow_Any_SSSE3, ARGBToUVRow_Unaligned_SSSE3, ARGBToUVRow_C, 4, 15)
 300 UVANY(ARGBToUVJRow_Any_SSSE3, ARGBToUVJRow_Unaligned_SSSE3, ARGBToUVJRow_C,
 301       4, 15)
 302 UVANY(BGRAToUVRow_Any_SSSE3, BGRAToUVRow_Unaligned_SSSE3, BGRAToUVRow_C, 4, 15)
 303 UVANY(ABGRToUVRow_Any_SSSE3, ABGRToUVRow_Unaligned_SSSE3, ABGRToUVRow_C, 4, 15)
 304 UVANY(RGBAToUVRow_Any_SSSE3, RGBAToUVRow_Unaligned_SSSE3, RGBAToUVRow_C, 4, 15)
 305 UVANY(YUY2ToUVRow_Any_SSE2, YUY2ToUVRow_Unaligned_SSE2, YUY2ToUVRow_C, 2, 15)
 306 UVANY(UYVYToUVRow_Any_SSE2, UYVYToUVRow_Unaligned_SSE2, UYVYToUVRow_C, 2, 15)
 307 #endif
 308 #ifdef HAS_ARGBTOUVROW_NEON
 309 UVANY(ARGBToUVRow_Any_NEON, ARGBToUVRow_NEON, ARGBToUVRow_C, 4, 15)
 310 UVANY(ARGBToUVJRow_Any_NEON, ARGBToUVJRow_NEON, ARGBToUVJRow_C, 4, 15)
 311 UVANY(BGRAToUVRow_Any_NEON, BGRAToUVRow_NEON, BGRAToUVRow_C, 4, 15)
 312 UVANY(ABGRToUVRow_Any_NEON, ABGRToUVRow_NEON, ABGRToUVRow_C, 4, 15)
 313 UVANY(RGBAToUVRow_Any_NEON, RGBAToUVRow_NEON, RGBAToUVRow_C, 4, 15)
 314 UVANY(RGB24ToUVRow_Any_NEON, RGB24ToUVRow_NEON, RGB24ToUVRow_C, 3, 15)
 315 UVANY(RAWToUVRow_Any_NEON, RAWToUVRow_NEON, RAWToUVRow_C, 3, 15)
 316 UVANY(RGB565ToUVRow_Any_NEON, RGB565ToUVRow_NEON, RGB565ToUVRow_C, 2, 15)
 317 UVANY(ARGB1555ToUVRow_Any_NEON, ARGB1555ToUVRow_NEON, ARGB1555ToUVRow_C, 2, 15)
 318 UVANY(ARGB4444ToUVRow_Any_NEON, ARGB4444ToUVRow_NEON, ARGB4444ToUVRow_C, 2, 15)
 319 UVANY(YUY2ToUVRow_Any_NEON, YUY2ToUVRow_NEON, YUY2ToUVRow_C, 2, 15)
 320 UVANY(UYVYToUVRow_Any_NEON, UYVYToUVRow_NEON, UYVYToUVRow_C, 2, 15)
 321 #endif
 322 #undef UVANY
 323
 324 #define UV422ANY(NAMEANY, ANYTOUV_SIMD, ANYTOUV_C, BPP, MASK, SHIFT)           \
 325     void NAMEANY(const uint8* src_uv,                                          \
 326                  uint8* dst_u, uint8* dst_v, int width) {                      \
 327       int n = width & ~MASK;                                                   \
 328       ANYTOUV_SIMD(src_uv, dst_u, dst_v, n);                                   \
 329       ANYTOUV_C(src_uv  + n * BPP,                                             \
 330                 dst_u + (n >> SHIFT),                                          \
 331                 dst_v + (n >> SHIFT),                                          \
 332                 width & MASK);                                                 \
 333     }
 334
 335 #ifdef HAS_ARGBTOUV444ROW_SSSE3
 336 UV422ANY(ARGBToUV444Row_Any_SSSE3, ARGBToUV444Row_Unaligned_SSSE3,
 337          ARGBToUV444Row_C, 4, 15, 0)
 338 #endif
 339 #ifdef HAS_YUY2TOUV422ROW_AVX2
 340 UV422ANY(YUY2ToUV422Row_Any_AVX2, YUY2ToUV422Row_AVX2,
 341          YUY2ToUV422Row_C, 2, 31, 1)
 342 UV422ANY(UYVYToUV422Row_Any_AVX2, UYVYToUV422Row_AVX2,
 343          UYVYToUV422Row_C, 2, 31, 1)
 344 #endif
 345 #ifdef HAS_ARGBTOUVROW_SSSE3
 346 UV422ANY(ARGBToUV422Row_Any_SSSE3, ARGBToUV422Row_Unaligned_SSSE3,
 347          ARGBToUV422Row_C, 4, 15, 1)
 348 UV422ANY(YUY2ToUV422Row_Any_SSE2, YUY2ToUV422Row_Unaligned_SSE2,
 349          YUY2ToUV422Row_C, 2, 15, 1)
 350 UV422ANY(UYVYToUV422Row_Any_SSE2, UYVYToUV422Row_Unaligned_SSE2,
 351          UYVYToUV422Row_C, 2, 15, 1)
 352 #endif
 353 #ifdef HAS_YUY2TOUV422ROW_NEON
 354 UV422ANY(ARGBToUV444Row_Any_NEON, ARGBToUV444Row_NEON,
 355          ARGBToUV444Row_C, 4, 7, 0)
 356 UV422ANY(ARGBToUV422Row_Any_NEON, ARGBToUV422Row_NEON,
 357          ARGBToUV422Row_C, 4, 15, 1)
 358 UV422ANY(ARGBToUV411Row_Any_NEON, ARGBToUV411Row_NEON,
 359          ARGBToUV411Row_C, 4, 31, 2)
 360 UV422ANY(YUY2ToUV422Row_Any_NEON, YUY2ToUV422Row_NEON,
 361          YUY2ToUV422Row_C, 2, 15, 1)
 362 UV422ANY(UYVYToUV422Row_Any_NEON, UYVYToUV422Row_NEON,
 363          UYVYToUV422Row_C, 2, 15, 1)
 364 #endif
 365 #undef UV422ANY
 366
 367 #define SPLITUVROWANY(NAMEANY, ANYTOUV_SIMD, ANYTOUV_C, MASK)                  \
 368     void NAMEANY(const uint8* src_uv,                                          \
 369                  uint8* dst_u, uint8* dst_v, int width) {                      \
 370       int n = width & ~MASK;                                                   \
 371       ANYTOUV_SIMD(src_uv, dst_u, dst_v, n);                                   \
 372       ANYTOUV_C(src_uv + n * 2,                                                \
 373                 dst_u + n,                                                     \
 374                 dst_v + n,                                                     \
 375                 width & MASK);                                                 \
 376     }
 377
 378 #ifdef HAS_SPLITUVROW_SSE2
 379 SPLITUVROWANY(SplitUVRow_Any_SSE2, SplitUVRow_Unaligned_SSE2, SplitUVRow_C, 15)
 380 #endif
 381 #ifdef HAS_SPLITUVROW_AVX2
 382 SPLITUVROWANY(SplitUVRow_Any_AVX2, SplitUVRow_AVX2, SplitUVRow_C, 31)
 383 #endif
 384 #ifdef HAS_SPLITUVROW_NEON
 385 SPLITUVROWANY(SplitUVRow_Any_NEON, SplitUVRow_NEON, SplitUVRow_C, 15)
 386 #endif
 387 #ifdef HAS_SPLITUVROW_MIPS_DSPR2
 388 SPLITUVROWANY(SplitUVRow_Any_MIPS_DSPR2, SplitUVRow_Unaligned_MIPS_DSPR2,
 389               SplitUVRow_C, 15)
 390 #endif
 391 #undef SPLITUVROWANY
 392
 393 #define MERGEUVROW_ANY(NAMEANY, ANYTOUV_SIMD, ANYTOUV_C, MASK)                 \
 394     void NAMEANY(const uint8* src_u, const uint8* src_v,                       \
 395                  uint8* dst_uv, int width) {                                   \
 396       int n = width & ~MASK;                                                   \
 397       ANYTOUV_SIMD(src_u, src_v, dst_uv, n);                                   \
 398       ANYTOUV_C(src_u + n,                                                     \
 399                 src_v + n,                                                     \
 400                 dst_uv + n * 2,                                                \
 401                 width & MASK);                                                 \
 402     }
 403
 404 #ifdef HAS_MERGEUVROW_SSE2
 405 MERGEUVROW_ANY(MergeUVRow_Any_SSE2, MergeUVRow_Unaligned_SSE2, MergeUVRow_C, 15)
 406 #endif
 407 #ifdef HAS_MERGEUVROW_AVX2
 408 MERGEUVROW_ANY(MergeUVRow_Any_AVX2, MergeUVRow_AVX2, MergeUVRow_C, 31)
 409 #endif
 410 #ifdef HAS_MERGEUVROW_NEON
 411 MERGEUVROW_ANY(MergeUVRow_Any_NEON, MergeUVRow_NEON, MergeUVRow_C, 15)
 412 #endif
 413 #undef MERGEUVROW_ANY
 414
 415 #define MATHROW_ANY(NAMEANY, ARGBMATH_SIMD, ARGBMATH_C, MASK)                  \
 416     void NAMEANY(const uint8* src_argb0, const uint8* src_argb1,               \
 417                  uint8* dst_argb, int width) {                                 \
 418       int n = width & ~MASK;                                                   \
 419       ARGBMATH_SIMD(src_argb0, src_argb1, dst_argb, n);                        \
 420       ARGBMATH_C(src_argb0 + n * 4,                                            \
 421                  src_argb1 + n * 4,                                            \
 422                  dst_argb + n * 4,                                             \
 423                  width & MASK);                                                \
 424     }
 425
 426 #ifdef HAS_ARGBMULTIPLYROW_SSE2
 427 MATHROW_ANY(ARGBMultiplyRow_Any_SSE2, ARGBMultiplyRow_SSE2, ARGBMultiplyRow_C,
 428             3)
 429 #endif
 430 #ifdef HAS_ARGBADDROW_SSE2
 431 MATHROW_ANY(ARGBAddRow_Any_SSE2, ARGBAddRow_SSE2, ARGBAddRow_C, 3)
 432 #endif
 433 #ifdef HAS_ARGBSUBTRACTROW_SSE2
 434 MATHROW_ANY(ARGBSubtractRow_Any_SSE2, ARGBSubtractRow_SSE2, ARGBSubtractRow_C,
 435             3)
 436 #endif
 437 #ifdef HAS_ARGBMULTIPLYROW_AVX2
 438 MATHROW_ANY(ARGBMultiplyRow_Any_AVX2, ARGBMultiplyRow_AVX2, ARGBMultiplyRow_C,
 439             7)
 440 #endif
 441 #ifdef HAS_ARGBADDROW_AVX2
 442 MATHROW_ANY(ARGBAddRow_Any_AVX2, ARGBAddRow_AVX2, ARGBAddRow_C, 7)
 443 #endif
 444 #ifdef HAS_ARGBSUBTRACTROW_AVX2
 445 MATHROW_ANY(ARGBSubtractRow_Any_AVX2, ARGBSubtractRow_AVX2, ARGBSubtractRow_C,
 446             7)
 447 #endif
 448 #ifdef HAS_ARGBMULTIPLYROW_NEON
 449 MATHROW_ANY(ARGBMultiplyRow_Any_NEON, ARGBMultiplyRow_NEON, ARGBMultiplyRow_C,
 450             7)
 451 #endif
 452 #ifdef HAS_ARGBADDROW_NEON
 453 MATHROW_ANY(ARGBAddRow_Any_NEON, ARGBAddRow_NEON, ARGBAddRow_C, 7)
 454 #endif
 455 #ifdef HAS_ARGBSUBTRACTROW_NEON
 456 MATHROW_ANY(ARGBSubtractRow_Any_NEON, ARGBSubtractRow_NEON, ARGBSubtractRow_C,
 457             7)
 458 #endif
 459 #undef MATHROW_ANY
 460
 461 // Shuffle may want to work in place, so last16 method can not be used.
 462 #define YANY(NAMEANY, ARGBTOY_SIMD, ARGBTOY_C, SBPP, BPP, MASK)                \
 463     void NAMEANY(const uint8* src_argb, uint8* dst_argb,                       \
 464                  const uint8* shuffler, int width) {                           \
 465       int n = width & ~MASK;                                                   \
 466       ARGBTOY_SIMD(src_argb, dst_argb, shuffler, n);                           \
 467       ARGBTOY_C(src_argb + n * SBPP,                                           \
 468                 dst_argb  + n * BPP, shuffler, width & MASK);                  \
 469     }
 470
 471 #ifdef HAS_ARGBSHUFFLEROW_SSSE3
 472 YANY(ARGBShuffleRow_Any_SSSE3, ARGBShuffleRow_Unaligned_SSSE3,
 473      ARGBShuffleRow_C, 4, 4, 7)
 474 #endif
 475 #ifdef HAS_ARGBSHUFFLEROW_AVX2
 476 YANY(ARGBShuffleRow_Any_AVX2, ARGBShuffleRow_AVX2,
 477      ARGBShuffleRow_C, 4, 4, 15)
 478 #endif
 479 #ifdef HAS_ARGBSHUFFLEROW_NEON
 480 YANY(ARGBShuffleRow_Any_NEON, ARGBShuffleRow_NEON,
 481      ARGBShuffleRow_C, 4, 4, 3)
 482 #endif
 483 #undef YANY
 484
 485 // Interpolate may want to work in place, so last16 method can not be used.
 486 #define NANY(NAMEANY, TERP_SIMD, TERP_C, SBPP, BPP, MASK)                      \
 487     void NAMEANY(uint8* dst_ptr, const uint8* src_ptr,                         \
 488                  ptrdiff_t src_stride_ptr, int width,                          \
 489                  int source_y_fraction) {                                      \
 490       int n = width & ~MASK;                                                   \
 491       TERP_SIMD(dst_ptr, src_ptr, src_stride_ptr,                              \
 492                 n, source_y_fraction);                                         \
 493       TERP_C(dst_ptr + n * BPP,                                                \
 494              src_ptr + n * SBPP, src_stride_ptr,                               \
 495              width & MASK, source_y_fraction);                                 \
 496     }
 497
 498 #ifdef HAS_INTERPOLATEROW_SSSE3
 499 NANY(InterpolateRow_Any_SSSE3, InterpolateRow_Unaligned_SSSE3,
 500      InterpolateRow_C, 1, 1, 15)
 501 #endif
 502 #ifdef HAS_INTERPOLATEROW_SSE2
 503 NANY(InterpolateRow_Any_SSE2, InterpolateRow_Unaligned_SSE2,
 504      InterpolateRow_C, 1, 1, 15)
 505 #endif
 506 #ifdef HAS_INTERPOLATEROW_NEON
 507 NANY(InterpolateRow_Any_NEON, InterpolateRow_NEON,
 508      InterpolateRow_C, 1, 1, 15)
 509 #endif
 510 #ifdef HAS_INTERPOLATEROW_MIPS_DSPR2
 511 NANY(InterpolateRow_Any_MIPS_DSPR2, InterpolateRow_MIPS_DSPR2,
 512      InterpolateRow_C, 1, 1, 3)
 513 #endif
 514 #undef NANY
 515
 516 #ifdef __cplusplus
 517 }  // extern "C"
 518 }  // namespace libyuv
 519 #endif