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