1/* 2 * Copyright 2011 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/convert.h" 12 13#include "libyuv/basic_types.h" 14#include "libyuv/cpu_id.h" 15#include "libyuv/planar_functions.h" 16#include "libyuv/rotate.h" 17#include "libyuv/scale.h" // For ScalePlane() 18#include "libyuv/row.h" 19 20#ifdef __cplusplus 21namespace libyuv { 22extern "C" { 23#endif 24 25#define SUBSAMPLE(v, a, s) (v < 0) ? (-((-v + a) >> s)) : ((v + a) >> s) 26static __inline int Abs(int v) { 27 return v >= 0 ? v : -v; 28} 29 30// Any I4xx To I420 format with mirroring. 31static int I4xxToI420(const uint8* src_y, int src_stride_y, 32 const uint8* src_u, int src_stride_u, 33 const uint8* src_v, int src_stride_v, 34 uint8* dst_y, int dst_stride_y, 35 uint8* dst_u, int dst_stride_u, 36 uint8* dst_v, int dst_stride_v, 37 int src_y_width, int src_y_height, 38 int src_uv_width, int src_uv_height) { 39 const int dst_y_width = Abs(src_y_width); 40 const int dst_y_height = Abs(src_y_height); 41 const int dst_uv_width = SUBSAMPLE(dst_y_width, 1, 1); 42 const int dst_uv_height = SUBSAMPLE(dst_y_height, 1, 1); 43 if (src_y_width == 0 || src_y_height == 0 || 44 src_uv_width == 0 || src_uv_height == 0) { 45 return -1; 46 } 47 ScalePlane(src_y, src_stride_y, src_y_width, src_y_height, 48 dst_y, dst_stride_y, dst_y_width, dst_y_height, 49 kFilterBilinear); 50 ScalePlane(src_u, src_stride_u, src_uv_width, src_uv_height, 51 dst_u, dst_stride_u, dst_uv_width, dst_uv_height, 52 kFilterBilinear); 53 ScalePlane(src_v, src_stride_v, src_uv_width, src_uv_height, 54 dst_v, dst_stride_v, dst_uv_width, dst_uv_height, 55 kFilterBilinear); 56 return 0; 57} 58 59// Copy I420 with optional flipping 60// TODO(fbarchard): Use Scale plane which supports mirroring, but ensure 61// is does row coalescing. 62LIBYUV_API 63int I420Copy(const uint8* src_y, int src_stride_y, 64 const uint8* src_u, int src_stride_u, 65 const uint8* src_v, int src_stride_v, 66 uint8* dst_y, int dst_stride_y, 67 uint8* dst_u, int dst_stride_u, 68 uint8* dst_v, int dst_stride_v, 69 int width, int height) { 70 int halfwidth = (width + 1) >> 1; 71 int halfheight = (height + 1) >> 1; 72 if (!src_y || !src_u || !src_v || 73 !dst_y || !dst_u || !dst_v || 74 width <= 0 || height == 0) { 75 return -1; 76 } 77 // Negative height means invert the image. 78 if (height < 0) { 79 height = -height; 80 halfheight = (height + 1) >> 1; 81 src_y = src_y + (height - 1) * src_stride_y; 82 src_u = src_u + (halfheight - 1) * src_stride_u; 83 src_v = src_v + (halfheight - 1) * src_stride_v; 84 src_stride_y = -src_stride_y; 85 src_stride_u = -src_stride_u; 86 src_stride_v = -src_stride_v; 87 } 88 89 if (dst_y) { 90 CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height); 91 } 92 // Copy UV planes. 93 CopyPlane(src_u, src_stride_u, dst_u, dst_stride_u, halfwidth, halfheight); 94 CopyPlane(src_v, src_stride_v, dst_v, dst_stride_v, halfwidth, halfheight); 95 return 0; 96} 97 98// 422 chroma is 1/2 width, 1x height 99// 420 chroma is 1/2 width, 1/2 height 100LIBYUV_API 101int I422ToI420(const uint8* src_y, int src_stride_y, 102 const uint8* src_u, int src_stride_u, 103 const uint8* src_v, int src_stride_v, 104 uint8* dst_y, int dst_stride_y, 105 uint8* dst_u, int dst_stride_u, 106 uint8* dst_v, int dst_stride_v, 107 int width, int height) { 108 const int src_uv_width = SUBSAMPLE(width, 1, 1); 109 return I4xxToI420(src_y, src_stride_y, 110 src_u, src_stride_u, 111 src_v, src_stride_v, 112 dst_y, dst_stride_y, 113 dst_u, dst_stride_u, 114 dst_v, dst_stride_v, 115 width, height, 116 src_uv_width, height); 117} 118 119// 444 chroma is 1x width, 1x height 120// 420 chroma is 1/2 width, 1/2 height 121LIBYUV_API 122int I444ToI420(const uint8* src_y, int src_stride_y, 123 const uint8* src_u, int src_stride_u, 124 const uint8* src_v, int src_stride_v, 125 uint8* dst_y, int dst_stride_y, 126 uint8* dst_u, int dst_stride_u, 127 uint8* dst_v, int dst_stride_v, 128 int width, int height) { 129 return I4xxToI420(src_y, src_stride_y, 130 src_u, src_stride_u, 131 src_v, src_stride_v, 132 dst_y, dst_stride_y, 133 dst_u, dst_stride_u, 134 dst_v, dst_stride_v, 135 width, height, 136 width, height); 137} 138 139// 411 chroma is 1/4 width, 1x height 140// 420 chroma is 1/2 width, 1/2 height 141LIBYUV_API 142int I411ToI420(const uint8* src_y, int src_stride_y, 143 const uint8* src_u, int src_stride_u, 144 const uint8* src_v, int src_stride_v, 145 uint8* dst_y, int dst_stride_y, 146 uint8* dst_u, int dst_stride_u, 147 uint8* dst_v, int dst_stride_v, 148 int width, int height) { 149 const int src_uv_width = SUBSAMPLE(width, 3, 2); 150 return I4xxToI420(src_y, src_stride_y, 151 src_u, src_stride_u, 152 src_v, src_stride_v, 153 dst_y, dst_stride_y, 154 dst_u, dst_stride_u, 155 dst_v, dst_stride_v, 156 width, height, 157 src_uv_width, height); 158} 159 160// I400 is greyscale typically used in MJPG 161LIBYUV_API 162int I400ToI420(const uint8* src_y, int src_stride_y, 163 uint8* dst_y, int dst_stride_y, 164 uint8* dst_u, int dst_stride_u, 165 uint8* dst_v, int dst_stride_v, 166 int width, int height) { 167 int halfwidth = (width + 1) >> 1; 168 int halfheight = (height + 1) >> 1; 169 if (!src_y || !dst_y || !dst_u || !dst_v || 170 width <= 0 || height == 0) { 171 return -1; 172 } 173 // Negative height means invert the image. 174 if (height < 0) { 175 height = -height; 176 halfheight = (height + 1) >> 1; 177 src_y = src_y + (height - 1) * src_stride_y; 178 src_stride_y = -src_stride_y; 179 } 180 CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height); 181 SetPlane(dst_u, dst_stride_u, halfwidth, halfheight, 128); 182 SetPlane(dst_v, dst_stride_v, halfwidth, halfheight, 128); 183 return 0; 184} 185 186static void CopyPlane2(const uint8* src, int src_stride_0, int src_stride_1, 187 uint8* dst, int dst_stride, 188 int width, int height) { 189 int y; 190 void (*CopyRow)(const uint8* src, uint8* dst, int width) = CopyRow_C; 191#if defined(HAS_COPYROW_X86) 192 if (TestCpuFlag(kCpuHasX86) && IS_ALIGNED(width, 4)) { 193 CopyRow = CopyRow_X86; 194 } 195#endif 196#if defined(HAS_COPYROW_SSE2) 197 if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(width, 32) && 198 IS_ALIGNED(src, 16) && 199 IS_ALIGNED(src_stride_0, 16) && IS_ALIGNED(src_stride_1, 16) && 200 IS_ALIGNED(dst, 16) && IS_ALIGNED(dst_stride, 16)) { 201 CopyRow = CopyRow_SSE2; 202 } 203#endif 204#if defined(HAS_COPYROW_ERMS) 205 if (TestCpuFlag(kCpuHasERMS)) { 206 CopyRow = CopyRow_ERMS; 207 } 208#endif 209#if defined(HAS_COPYROW_NEON) 210 if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 32)) { 211 CopyRow = CopyRow_NEON; 212 } 213#endif 214#if defined(HAS_COPYROW_MIPS) 215 if (TestCpuFlag(kCpuHasMIPS)) { 216 CopyRow = CopyRow_MIPS; 217 } 218#endif 219 220 // Copy plane 221 for (y = 0; y < height - 1; y += 2) { 222 CopyRow(src, dst, width); 223 CopyRow(src + src_stride_0, dst + dst_stride, width); 224 src += src_stride_0 + src_stride_1; 225 dst += dst_stride * 2; 226 } 227 if (height & 1) { 228 CopyRow(src, dst, width); 229 } 230} 231 232// Support converting from FOURCC_M420 233// Useful for bandwidth constrained transports like USB 1.0 and 2.0 and for 234// easy conversion to I420. 235// M420 format description: 236// M420 is row biplanar 420: 2 rows of Y and 1 row of UV. 237// Chroma is half width / half height. (420) 238// src_stride_m420 is row planar. Normally this will be the width in pixels. 239// The UV plane is half width, but 2 values, so src_stride_m420 applies to 240// this as well as the two Y planes. 241static int X420ToI420(const uint8* src_y, 242 int src_stride_y0, int src_stride_y1, 243 const uint8* src_uv, int src_stride_uv, 244 uint8* dst_y, int dst_stride_y, 245 uint8* dst_u, int dst_stride_u, 246 uint8* dst_v, int dst_stride_v, 247 int width, int height) { 248 int y; 249 int halfwidth = (width + 1) >> 1; 250 int halfheight = (height + 1) >> 1; 251 void (*SplitUVRow)(const uint8* src_uv, uint8* dst_u, uint8* dst_v, int pix) = 252 SplitUVRow_C; 253 if (!src_y || !src_uv || 254 !dst_y || !dst_u || !dst_v || 255 width <= 0 || height == 0) { 256 return -1; 257 } 258 // Negative height means invert the image. 259 if (height < 0) { 260 height = -height; 261 halfheight = (height + 1) >> 1; 262 dst_y = dst_y + (height - 1) * dst_stride_y; 263 dst_u = dst_u + (halfheight - 1) * dst_stride_u; 264 dst_v = dst_v + (halfheight - 1) * dst_stride_v; 265 dst_stride_y = -dst_stride_y; 266 dst_stride_u = -dst_stride_u; 267 dst_stride_v = -dst_stride_v; 268 } 269 // Coalesce rows. 270 if (src_stride_y0 == width && 271 src_stride_y1 == width && 272 dst_stride_y == width) { 273 width *= height; 274 height = 1; 275 src_stride_y0 = src_stride_y1 = dst_stride_y = 0; 276 } 277 // Coalesce rows. 278 if (src_stride_uv == halfwidth * 2 && 279 dst_stride_u == halfwidth && 280 dst_stride_v == halfwidth) { 281 halfwidth *= halfheight; 282 halfheight = 1; 283 src_stride_uv = dst_stride_u = dst_stride_v = 0; 284 } 285#if defined(HAS_SPLITUVROW_SSE2) 286 if (TestCpuFlag(kCpuHasSSE2) && halfwidth >= 16) { 287 SplitUVRow = SplitUVRow_Any_SSE2; 288 if (IS_ALIGNED(halfwidth, 16)) { 289 SplitUVRow = SplitUVRow_Unaligned_SSE2; 290 if (IS_ALIGNED(src_uv, 16) && IS_ALIGNED(src_stride_uv, 16) && 291 IS_ALIGNED(dst_u, 16) && IS_ALIGNED(dst_stride_u, 16) && 292 IS_ALIGNED(dst_v, 16) && IS_ALIGNED(dst_stride_v, 16)) { 293 SplitUVRow = SplitUVRow_SSE2; 294 } 295 } 296 } 297#endif 298#if defined(HAS_SPLITUVROW_AVX2) 299 if (TestCpuFlag(kCpuHasAVX2) && halfwidth >= 32) { 300 SplitUVRow = SplitUVRow_Any_AVX2; 301 if (IS_ALIGNED(halfwidth, 32)) { 302 SplitUVRow = SplitUVRow_AVX2; 303 } 304 } 305#endif 306#if defined(HAS_SPLITUVROW_NEON) 307 if (TestCpuFlag(kCpuHasNEON) && halfwidth >= 16) { 308 SplitUVRow = SplitUVRow_Any_NEON; 309 if (IS_ALIGNED(halfwidth, 16)) { 310 SplitUVRow = SplitUVRow_NEON; 311 } 312 } 313#endif 314#if defined(HAS_SPLITUVROW_MIPS_DSPR2) 315 if (TestCpuFlag(kCpuHasMIPS_DSPR2) && halfwidth >= 16) { 316 SplitUVRow = SplitUVRow_Any_MIPS_DSPR2; 317 if (IS_ALIGNED(halfwidth, 16)) { 318 SplitUVRow = SplitUVRow_Unaligned_MIPS_DSPR2; 319 if (IS_ALIGNED(src_uv, 4) && IS_ALIGNED(src_stride_uv, 4) && 320 IS_ALIGNED(dst_u, 4) && IS_ALIGNED(dst_stride_u, 4) && 321 IS_ALIGNED(dst_v, 4) && IS_ALIGNED(dst_stride_v, 4)) { 322 SplitUVRow = SplitUVRow_MIPS_DSPR2; 323 } 324 } 325 } 326#endif 327 328 if (dst_y) { 329 if (src_stride_y0 == src_stride_y1) { 330 CopyPlane(src_y, src_stride_y0, dst_y, dst_stride_y, width, height); 331 } else { 332 CopyPlane2(src_y, src_stride_y0, src_stride_y1, dst_y, dst_stride_y, 333 width, height); 334 } 335 } 336 337 for (y = 0; y < halfheight; ++y) { 338 // Copy a row of UV. 339 SplitUVRow(src_uv, dst_u, dst_v, halfwidth); 340 dst_u += dst_stride_u; 341 dst_v += dst_stride_v; 342 src_uv += src_stride_uv; 343 } 344 return 0; 345} 346 347// Convert NV12 to I420. 348LIBYUV_API 349int NV12ToI420(const uint8* src_y, int src_stride_y, 350 const uint8* src_uv, int src_stride_uv, 351 uint8* dst_y, int dst_stride_y, 352 uint8* dst_u, int dst_stride_u, 353 uint8* dst_v, int dst_stride_v, 354 int width, int height) { 355 return X420ToI420(src_y, src_stride_y, src_stride_y, 356 src_uv, src_stride_uv, 357 dst_y, dst_stride_y, 358 dst_u, dst_stride_u, 359 dst_v, dst_stride_v, 360 width, height); 361} 362 363// Convert NV21 to I420. Same as NV12 but u and v pointers swapped. 364LIBYUV_API 365int NV21ToI420(const uint8* src_y, int src_stride_y, 366 const uint8* src_vu, int src_stride_vu, 367 uint8* dst_y, int dst_stride_y, 368 uint8* dst_u, int dst_stride_u, 369 uint8* dst_v, int dst_stride_v, 370 int width, int height) { 371 return X420ToI420(src_y, src_stride_y, src_stride_y, 372 src_vu, src_stride_vu, 373 dst_y, dst_stride_y, 374 dst_v, dst_stride_v, 375 dst_u, dst_stride_u, 376 width, height); 377} 378 379// Convert M420 to I420. 380LIBYUV_API 381int M420ToI420(const uint8* src_m420, int src_stride_m420, 382 uint8* dst_y, int dst_stride_y, 383 uint8* dst_u, int dst_stride_u, 384 uint8* dst_v, int dst_stride_v, 385 int width, int height) { 386 return X420ToI420(src_m420, src_stride_m420, src_stride_m420 * 2, 387 src_m420 + src_stride_m420 * 2, src_stride_m420 * 3, 388 dst_y, dst_stride_y, 389 dst_u, dst_stride_u, 390 dst_v, dst_stride_v, 391 width, height); 392} 393 394// Convert Q420 to I420. 395// Format is rows of YY/YUYV 396LIBYUV_API 397int Q420ToI420(const uint8* src_y, int src_stride_y, 398 const uint8* src_yuy2, int src_stride_yuy2, 399 uint8* dst_y, int dst_stride_y, 400 uint8* dst_u, int dst_stride_u, 401 uint8* dst_v, int dst_stride_v, 402 int width, int height) { 403 int y; 404 int halfheight = (height + 1) >> 1; 405 void (*CopyRow)(const uint8* src, uint8* dst, int width) = CopyRow_C; 406 void (*YUY2ToUV422Row)(const uint8* src_yuy2, uint8* dst_u, uint8* dst_v, 407 int pix) = YUY2ToUV422Row_C; 408 void (*YUY2ToYRow)(const uint8* src_yuy2, uint8* dst_y, int pix) = 409 YUY2ToYRow_C; 410 if (!src_y || !src_yuy2 || 411 !dst_y || !dst_u || !dst_v || 412 width <= 0 || height == 0) { 413 return -1; 414 } 415 // Negative height means invert the image. 416 if (height < 0) { 417 height = -height; 418 halfheight = (height + 1) >> 1; 419 dst_y = dst_y + (height - 1) * dst_stride_y; 420 dst_u = dst_u + (halfheight - 1) * dst_stride_u; 421 dst_v = dst_v + (halfheight - 1) * dst_stride_v; 422 dst_stride_y = -dst_stride_y; 423 dst_stride_u = -dst_stride_u; 424 dst_stride_v = -dst_stride_v; 425 } 426 // CopyRow for rows of just Y in Q420 copied to Y plane of I420. 427#if defined(HAS_COPYROW_NEON) 428 if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 32)) { 429 CopyRow = CopyRow_NEON; 430 } 431#endif 432#if defined(HAS_COPYROW_X86) 433 if (IS_ALIGNED(width, 4)) { 434 CopyRow = CopyRow_X86; 435 } 436#endif 437#if defined(HAS_COPYROW_SSE2) 438 if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(width, 32) && 439 IS_ALIGNED(src_y, 16) && IS_ALIGNED(src_stride_y, 16) && 440 IS_ALIGNED(dst_y, 16) && IS_ALIGNED(dst_stride_y, 16)) { 441 CopyRow = CopyRow_SSE2; 442 } 443#endif 444#if defined(HAS_COPYROW_ERMS) 445 if (TestCpuFlag(kCpuHasERMS)) { 446 CopyRow = CopyRow_ERMS; 447 } 448#endif 449#if defined(HAS_COPYROW_MIPS) 450 if (TestCpuFlag(kCpuHasMIPS)) { 451 CopyRow = CopyRow_MIPS; 452 } 453#endif 454 455#if defined(HAS_YUY2TOYROW_SSE2) 456 if (TestCpuFlag(kCpuHasSSE2) && width >= 16) { 457 YUY2ToUV422Row = YUY2ToUV422Row_Any_SSE2; 458 YUY2ToYRow = YUY2ToYRow_Any_SSE2; 459 if (IS_ALIGNED(width, 16)) { 460 YUY2ToUV422Row = YUY2ToUV422Row_Unaligned_SSE2; 461 YUY2ToYRow = YUY2ToYRow_Unaligned_SSE2; 462 if (IS_ALIGNED(src_yuy2, 16) && IS_ALIGNED(src_stride_yuy2, 16)) { 463 YUY2ToUV422Row = YUY2ToUV422Row_SSE2; 464 if (IS_ALIGNED(dst_y, 16) && IS_ALIGNED(dst_stride_y, 16)) { 465 YUY2ToYRow = YUY2ToYRow_SSE2; 466 } 467 } 468 } 469 } 470#endif 471#if defined(HAS_YUY2TOYROW_AVX2) 472 if (TestCpuFlag(kCpuHasAVX2) && width >= 32) { 473 YUY2ToUV422Row = YUY2ToUV422Row_Any_AVX2; 474 YUY2ToYRow = YUY2ToYRow_Any_AVX2; 475 if (IS_ALIGNED(width, 32)) { 476 YUY2ToUV422Row = YUY2ToUV422Row_AVX2; 477 YUY2ToYRow = YUY2ToYRow_AVX2; 478 } 479 } 480#endif 481#if defined(HAS_YUY2TOYROW_NEON) 482 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 483 YUY2ToYRow = YUY2ToYRow_Any_NEON; 484 if (width >= 16) { 485 YUY2ToUV422Row = YUY2ToUV422Row_Any_NEON; 486 } 487 if (IS_ALIGNED(width, 16)) { 488 YUY2ToYRow = YUY2ToYRow_NEON; 489 YUY2ToUV422Row = YUY2ToUV422Row_NEON; 490 } 491 } 492#endif 493 494 for (y = 0; y < height - 1; y += 2) { 495 CopyRow(src_y, dst_y, width); 496 src_y += src_stride_y; 497 dst_y += dst_stride_y; 498 499 YUY2ToUV422Row(src_yuy2, dst_u, dst_v, width); 500 YUY2ToYRow(src_yuy2, dst_y, width); 501 src_yuy2 += src_stride_yuy2; 502 dst_y += dst_stride_y; 503 dst_u += dst_stride_u; 504 dst_v += dst_stride_v; 505 } 506 if (height & 1) { 507 CopyRow(src_y, dst_y, width); 508 YUY2ToUV422Row(src_yuy2, dst_u, dst_v, width); 509 } 510 return 0; 511} 512 513// Convert YUY2 to I420. 514LIBYUV_API 515int YUY2ToI420(const uint8* src_yuy2, int src_stride_yuy2, 516 uint8* dst_y, int dst_stride_y, 517 uint8* dst_u, int dst_stride_u, 518 uint8* dst_v, int dst_stride_v, 519 int width, int height) { 520 int y; 521 void (*YUY2ToUVRow)(const uint8* src_yuy2, int src_stride_yuy2, 522 uint8* dst_u, uint8* dst_v, int pix) = YUY2ToUVRow_C; 523 void (*YUY2ToYRow)(const uint8* src_yuy2, 524 uint8* dst_y, int pix) = YUY2ToYRow_C; 525 // Negative height means invert the image. 526 if (height < 0) { 527 height = -height; 528 src_yuy2 = src_yuy2 + (height - 1) * src_stride_yuy2; 529 src_stride_yuy2 = -src_stride_yuy2; 530 } 531#if defined(HAS_YUY2TOYROW_SSE2) 532 if (TestCpuFlag(kCpuHasSSE2) && width >= 16) { 533 YUY2ToUVRow = YUY2ToUVRow_Any_SSE2; 534 YUY2ToYRow = YUY2ToYRow_Any_SSE2; 535 if (IS_ALIGNED(width, 16)) { 536 YUY2ToUVRow = YUY2ToUVRow_Unaligned_SSE2; 537 YUY2ToYRow = YUY2ToYRow_Unaligned_SSE2; 538 if (IS_ALIGNED(src_yuy2, 16) && IS_ALIGNED(src_stride_yuy2, 16)) { 539 YUY2ToUVRow = YUY2ToUVRow_SSE2; 540 if (IS_ALIGNED(dst_y, 16) && IS_ALIGNED(dst_stride_y, 16)) { 541 YUY2ToYRow = YUY2ToYRow_SSE2; 542 } 543 } 544 } 545 } 546#endif 547#if defined(HAS_YUY2TOYROW_AVX2) 548 if (TestCpuFlag(kCpuHasAVX2) && width >= 32) { 549 YUY2ToUVRow = YUY2ToUVRow_Any_AVX2; 550 YUY2ToYRow = YUY2ToYRow_Any_AVX2; 551 if (IS_ALIGNED(width, 32)) { 552 YUY2ToUVRow = YUY2ToUVRow_AVX2; 553 YUY2ToYRow = YUY2ToYRow_AVX2; 554 } 555 } 556#endif 557#if defined(HAS_YUY2TOYROW_NEON) 558 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 559 YUY2ToYRow = YUY2ToYRow_Any_NEON; 560 if (width >= 16) { 561 YUY2ToUVRow = YUY2ToUVRow_Any_NEON; 562 } 563 if (IS_ALIGNED(width, 16)) { 564 YUY2ToYRow = YUY2ToYRow_NEON; 565 YUY2ToUVRow = YUY2ToUVRow_NEON; 566 } 567 } 568#endif 569 570 for (y = 0; y < height - 1; y += 2) { 571 YUY2ToUVRow(src_yuy2, src_stride_yuy2, dst_u, dst_v, width); 572 YUY2ToYRow(src_yuy2, dst_y, width); 573 YUY2ToYRow(src_yuy2 + src_stride_yuy2, dst_y + dst_stride_y, width); 574 src_yuy2 += src_stride_yuy2 * 2; 575 dst_y += dst_stride_y * 2; 576 dst_u += dst_stride_u; 577 dst_v += dst_stride_v; 578 } 579 if (height & 1) { 580 YUY2ToUVRow(src_yuy2, 0, dst_u, dst_v, width); 581 YUY2ToYRow(src_yuy2, dst_y, width); 582 } 583 return 0; 584} 585 586// Convert UYVY to I420. 587LIBYUV_API 588int UYVYToI420(const uint8* src_uyvy, int src_stride_uyvy, 589 uint8* dst_y, int dst_stride_y, 590 uint8* dst_u, int dst_stride_u, 591 uint8* dst_v, int dst_stride_v, 592 int width, int height) { 593 int y; 594 void (*UYVYToUVRow)(const uint8* src_uyvy, int src_stride_uyvy, 595 uint8* dst_u, uint8* dst_v, int pix) = UYVYToUVRow_C; 596 void (*UYVYToYRow)(const uint8* src_uyvy, 597 uint8* dst_y, int pix) = UYVYToYRow_C; 598 // Negative height means invert the image. 599 if (height < 0) { 600 height = -height; 601 src_uyvy = src_uyvy + (height - 1) * src_stride_uyvy; 602 src_stride_uyvy = -src_stride_uyvy; 603 } 604#if defined(HAS_UYVYTOYROW_SSE2) 605 if (TestCpuFlag(kCpuHasSSE2) && width >= 16) { 606 UYVYToUVRow = UYVYToUVRow_Any_SSE2; 607 UYVYToYRow = UYVYToYRow_Any_SSE2; 608 if (IS_ALIGNED(width, 16)) { 609 UYVYToUVRow = UYVYToUVRow_Unaligned_SSE2; 610 UYVYToYRow = UYVYToYRow_Unaligned_SSE2; 611 if (IS_ALIGNED(src_uyvy, 16) && IS_ALIGNED(src_stride_uyvy, 16)) { 612 UYVYToUVRow = UYVYToUVRow_SSE2; 613 if (IS_ALIGNED(dst_y, 16) && IS_ALIGNED(dst_stride_y, 16)) { 614 UYVYToYRow = UYVYToYRow_SSE2; 615 } 616 } 617 } 618 } 619#endif 620#if defined(HAS_UYVYTOYROW_AVX2) 621 if (TestCpuFlag(kCpuHasAVX2) && width >= 32) { 622 UYVYToUVRow = UYVYToUVRow_Any_AVX2; 623 UYVYToYRow = UYVYToYRow_Any_AVX2; 624 if (IS_ALIGNED(width, 32)) { 625 UYVYToUVRow = UYVYToUVRow_AVX2; 626 UYVYToYRow = UYVYToYRow_AVX2; 627 } 628 } 629#endif 630#if defined(HAS_UYVYTOYROW_NEON) 631 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 632 UYVYToYRow = UYVYToYRow_Any_NEON; 633 if (width >= 16) { 634 UYVYToUVRow = UYVYToUVRow_Any_NEON; 635 } 636 if (IS_ALIGNED(width, 16)) { 637 UYVYToYRow = UYVYToYRow_NEON; 638 UYVYToUVRow = UYVYToUVRow_NEON; 639 } 640 } 641#endif 642 643 for (y = 0; y < height - 1; y += 2) { 644 UYVYToUVRow(src_uyvy, src_stride_uyvy, dst_u, dst_v, width); 645 UYVYToYRow(src_uyvy, dst_y, width); 646 UYVYToYRow(src_uyvy + src_stride_uyvy, dst_y + dst_stride_y, width); 647 src_uyvy += src_stride_uyvy * 2; 648 dst_y += dst_stride_y * 2; 649 dst_u += dst_stride_u; 650 dst_v += dst_stride_v; 651 } 652 if (height & 1) { 653 UYVYToUVRow(src_uyvy, 0, dst_u, dst_v, width); 654 UYVYToYRow(src_uyvy, dst_y, width); 655 } 656 return 0; 657} 658 659// Convert ARGB to I420. 660LIBYUV_API 661int ARGBToI420(const uint8* src_argb, int src_stride_argb, 662 uint8* dst_y, int dst_stride_y, 663 uint8* dst_u, int dst_stride_u, 664 uint8* dst_v, int dst_stride_v, 665 int width, int height) { 666 int y; 667 void (*ARGBToUVRow)(const uint8* src_argb0, int src_stride_argb, 668 uint8* dst_u, uint8* dst_v, int width) = ARGBToUVRow_C; 669 void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int pix) = 670 ARGBToYRow_C; 671 if (!src_argb || 672 !dst_y || !dst_u || !dst_v || 673 width <= 0 || height == 0) { 674 return -1; 675 } 676 // Negative height means invert the image. 677 if (height < 0) { 678 height = -height; 679 src_argb = src_argb + (height - 1) * src_stride_argb; 680 src_stride_argb = -src_stride_argb; 681 } 682#if defined(HAS_ARGBTOYROW_SSSE3) && defined(HAS_ARGBTOUVROW_SSSE3) 683 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) { 684 ARGBToUVRow = ARGBToUVRow_Any_SSSE3; 685 ARGBToYRow = ARGBToYRow_Any_SSSE3; 686 if (IS_ALIGNED(width, 16)) { 687 ARGBToUVRow = ARGBToUVRow_Unaligned_SSSE3; 688 ARGBToYRow = ARGBToYRow_Unaligned_SSSE3; 689 if (IS_ALIGNED(src_argb, 16) && IS_ALIGNED(src_stride_argb, 16)) { 690 ARGBToUVRow = ARGBToUVRow_SSSE3; 691 if (IS_ALIGNED(dst_y, 16) && IS_ALIGNED(dst_stride_y, 16)) { 692 ARGBToYRow = ARGBToYRow_SSSE3; 693 } 694 } 695 } 696 } 697#endif 698#if defined(HAS_ARGBTOYROW_AVX2) && defined(HAS_ARGBTOUVROW_AVX2) 699 if (TestCpuFlag(kCpuHasAVX2) && width >= 32) { 700 ARGBToUVRow = ARGBToUVRow_Any_AVX2; 701 ARGBToYRow = ARGBToYRow_Any_AVX2; 702 if (IS_ALIGNED(width, 32)) { 703 ARGBToUVRow = ARGBToUVRow_AVX2; 704 ARGBToYRow = ARGBToYRow_AVX2; 705 } 706 } 707#endif 708#if defined(HAS_ARGBTOYROW_NEON) 709 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 710 ARGBToYRow = ARGBToYRow_Any_NEON; 711 if (IS_ALIGNED(width, 8)) { 712 ARGBToYRow = ARGBToYRow_NEON; 713 } 714 if (width >= 16) { 715 ARGBToUVRow = ARGBToUVRow_Any_NEON; 716 if (IS_ALIGNED(width, 16)) { 717 ARGBToUVRow = ARGBToUVRow_NEON; 718 } 719 } 720 } 721#endif 722 723 for (y = 0; y < height - 1; y += 2) { 724 ARGBToUVRow(src_argb, src_stride_argb, dst_u, dst_v, width); 725 ARGBToYRow(src_argb, dst_y, width); 726 ARGBToYRow(src_argb + src_stride_argb, dst_y + dst_stride_y, width); 727 src_argb += src_stride_argb * 2; 728 dst_y += dst_stride_y * 2; 729 dst_u += dst_stride_u; 730 dst_v += dst_stride_v; 731 } 732 if (height & 1) { 733 ARGBToUVRow(src_argb, 0, dst_u, dst_v, width); 734 ARGBToYRow(src_argb, dst_y, width); 735 } 736 return 0; 737} 738 739// Convert BGRA to I420. 740LIBYUV_API 741int BGRAToI420(const uint8* src_bgra, int src_stride_bgra, 742 uint8* dst_y, int dst_stride_y, 743 uint8* dst_u, int dst_stride_u, 744 uint8* dst_v, int dst_stride_v, 745 int width, int height) { 746 int y; 747 void (*BGRAToUVRow)(const uint8* src_bgra0, int src_stride_bgra, 748 uint8* dst_u, uint8* dst_v, int width) = BGRAToUVRow_C; 749 void (*BGRAToYRow)(const uint8* src_bgra, uint8* dst_y, int pix) = 750 BGRAToYRow_C; 751 if (!src_bgra || 752 !dst_y || !dst_u || !dst_v || 753 width <= 0 || height == 0) { 754 return -1; 755 } 756 // Negative height means invert the image. 757 if (height < 0) { 758 height = -height; 759 src_bgra = src_bgra + (height - 1) * src_stride_bgra; 760 src_stride_bgra = -src_stride_bgra; 761 } 762#if defined(HAS_BGRATOYROW_SSSE3) 763 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) { 764 BGRAToUVRow = BGRAToUVRow_Any_SSSE3; 765 BGRAToYRow = BGRAToYRow_Any_SSSE3; 766 if (IS_ALIGNED(width, 16)) { 767 BGRAToUVRow = BGRAToUVRow_Unaligned_SSSE3; 768 BGRAToYRow = BGRAToYRow_Unaligned_SSSE3; 769 if (IS_ALIGNED(src_bgra, 16) && IS_ALIGNED(src_stride_bgra, 16)) { 770 BGRAToUVRow = BGRAToUVRow_SSSE3; 771 if (IS_ALIGNED(dst_y, 16) && IS_ALIGNED(dst_stride_y, 16)) { 772 BGRAToYRow = BGRAToYRow_SSSE3; 773 } 774 } 775 } 776 } 777#elif defined(HAS_BGRATOYROW_NEON) 778 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 779 BGRAToYRow = BGRAToYRow_Any_NEON; 780 if (IS_ALIGNED(width, 8)) { 781 BGRAToYRow = BGRAToYRow_NEON; 782 } 783 if (width >= 16) { 784 BGRAToUVRow = BGRAToUVRow_Any_NEON; 785 if (IS_ALIGNED(width, 16)) { 786 BGRAToUVRow = BGRAToUVRow_NEON; 787 } 788 } 789 } 790#endif 791 792 for (y = 0; y < height - 1; y += 2) { 793 BGRAToUVRow(src_bgra, src_stride_bgra, dst_u, dst_v, width); 794 BGRAToYRow(src_bgra, dst_y, width); 795 BGRAToYRow(src_bgra + src_stride_bgra, dst_y + dst_stride_y, width); 796 src_bgra += src_stride_bgra * 2; 797 dst_y += dst_stride_y * 2; 798 dst_u += dst_stride_u; 799 dst_v += dst_stride_v; 800 } 801 if (height & 1) { 802 BGRAToUVRow(src_bgra, 0, dst_u, dst_v, width); 803 BGRAToYRow(src_bgra, dst_y, width); 804 } 805 return 0; 806} 807 808// Convert ABGR to I420. 809LIBYUV_API 810int ABGRToI420(const uint8* src_abgr, int src_stride_abgr, 811 uint8* dst_y, int dst_stride_y, 812 uint8* dst_u, int dst_stride_u, 813 uint8* dst_v, int dst_stride_v, 814 int width, int height) { 815 int y; 816 void (*ABGRToUVRow)(const uint8* src_abgr0, int src_stride_abgr, 817 uint8* dst_u, uint8* dst_v, int width) = ABGRToUVRow_C; 818 void (*ABGRToYRow)(const uint8* src_abgr, uint8* dst_y, int pix) = 819 ABGRToYRow_C; 820 if (!src_abgr || 821 !dst_y || !dst_u || !dst_v || 822 width <= 0 || height == 0) { 823 return -1; 824 } 825 // Negative height means invert the image. 826 if (height < 0) { 827 height = -height; 828 src_abgr = src_abgr + (height - 1) * src_stride_abgr; 829 src_stride_abgr = -src_stride_abgr; 830 } 831#if defined(HAS_ABGRTOYROW_SSSE3) 832 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) { 833 ABGRToUVRow = ABGRToUVRow_Any_SSSE3; 834 ABGRToYRow = ABGRToYRow_Any_SSSE3; 835 if (IS_ALIGNED(width, 16)) { 836 ABGRToUVRow = ABGRToUVRow_Unaligned_SSSE3; 837 ABGRToYRow = ABGRToYRow_Unaligned_SSSE3; 838 if (IS_ALIGNED(src_abgr, 16) && IS_ALIGNED(src_stride_abgr, 16)) { 839 ABGRToUVRow = ABGRToUVRow_SSSE3; 840 if (IS_ALIGNED(dst_y, 16) && IS_ALIGNED(dst_stride_y, 16)) { 841 ABGRToYRow = ABGRToYRow_SSSE3; 842 } 843 } 844 } 845 } 846#elif defined(HAS_ABGRTOYROW_NEON) 847 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 848 ABGRToYRow = ABGRToYRow_Any_NEON; 849 if (IS_ALIGNED(width, 8)) { 850 ABGRToYRow = ABGRToYRow_NEON; 851 } 852 if (width >= 16) { 853 ABGRToUVRow = ABGRToUVRow_Any_NEON; 854 if (IS_ALIGNED(width, 16)) { 855 ABGRToUVRow = ABGRToUVRow_NEON; 856 } 857 } 858 } 859#endif 860 861 for (y = 0; y < height - 1; y += 2) { 862 ABGRToUVRow(src_abgr, src_stride_abgr, dst_u, dst_v, width); 863 ABGRToYRow(src_abgr, dst_y, width); 864 ABGRToYRow(src_abgr + src_stride_abgr, dst_y + dst_stride_y, width); 865 src_abgr += src_stride_abgr * 2; 866 dst_y += dst_stride_y * 2; 867 dst_u += dst_stride_u; 868 dst_v += dst_stride_v; 869 } 870 if (height & 1) { 871 ABGRToUVRow(src_abgr, 0, dst_u, dst_v, width); 872 ABGRToYRow(src_abgr, dst_y, width); 873 } 874 return 0; 875} 876 877// Convert RGBA to I420. 878LIBYUV_API 879int RGBAToI420(const uint8* src_rgba, int src_stride_rgba, 880 uint8* dst_y, int dst_stride_y, 881 uint8* dst_u, int dst_stride_u, 882 uint8* dst_v, int dst_stride_v, 883 int width, int height) { 884 int y; 885 void (*RGBAToUVRow)(const uint8* src_rgba0, int src_stride_rgba, 886 uint8* dst_u, uint8* dst_v, int width) = RGBAToUVRow_C; 887 void (*RGBAToYRow)(const uint8* src_rgba, uint8* dst_y, int pix) = 888 RGBAToYRow_C; 889 if (!src_rgba || 890 !dst_y || !dst_u || !dst_v || 891 width <= 0 || height == 0) { 892 return -1; 893 } 894 // Negative height means invert the image. 895 if (height < 0) { 896 height = -height; 897 src_rgba = src_rgba + (height - 1) * src_stride_rgba; 898 src_stride_rgba = -src_stride_rgba; 899 } 900#if defined(HAS_RGBATOYROW_SSSE3) 901 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) { 902 RGBAToUVRow = RGBAToUVRow_Any_SSSE3; 903 RGBAToYRow = RGBAToYRow_Any_SSSE3; 904 if (IS_ALIGNED(width, 16)) { 905 RGBAToUVRow = RGBAToUVRow_Unaligned_SSSE3; 906 RGBAToYRow = RGBAToYRow_Unaligned_SSSE3; 907 if (IS_ALIGNED(src_rgba, 16) && IS_ALIGNED(src_stride_rgba, 16)) { 908 RGBAToUVRow = RGBAToUVRow_SSSE3; 909 if (IS_ALIGNED(dst_y, 16) && IS_ALIGNED(dst_stride_y, 16)) { 910 RGBAToYRow = RGBAToYRow_SSSE3; 911 } 912 } 913 } 914 } 915#elif defined(HAS_RGBATOYROW_NEON) 916 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 917 RGBAToYRow = RGBAToYRow_Any_NEON; 918 if (IS_ALIGNED(width, 8)) { 919 RGBAToYRow = RGBAToYRow_NEON; 920 } 921 if (width >= 16) { 922 RGBAToUVRow = RGBAToUVRow_Any_NEON; 923 if (IS_ALIGNED(width, 16)) { 924 RGBAToUVRow = RGBAToUVRow_NEON; 925 } 926 } 927 } 928#endif 929 930 for (y = 0; y < height - 1; y += 2) { 931 RGBAToUVRow(src_rgba, src_stride_rgba, dst_u, dst_v, width); 932 RGBAToYRow(src_rgba, dst_y, width); 933 RGBAToYRow(src_rgba + src_stride_rgba, dst_y + dst_stride_y, width); 934 src_rgba += src_stride_rgba * 2; 935 dst_y += dst_stride_y * 2; 936 dst_u += dst_stride_u; 937 dst_v += dst_stride_v; 938 } 939 if (height & 1) { 940 RGBAToUVRow(src_rgba, 0, dst_u, dst_v, width); 941 RGBAToYRow(src_rgba, dst_y, width); 942 } 943 return 0; 944} 945 946// Convert RGB24 to I420. 947LIBYUV_API 948int RGB24ToI420(const uint8* src_rgb24, int src_stride_rgb24, 949 uint8* dst_y, int dst_stride_y, 950 uint8* dst_u, int dst_stride_u, 951 uint8* dst_v, int dst_stride_v, 952 int width, int height) { 953 int y; 954#if defined(HAS_RGB24TOYROW_NEON) 955 void (*RGB24ToUVRow)(const uint8* src_rgb24, int src_stride_rgb24, 956 uint8* dst_u, uint8* dst_v, int width) = RGB24ToUVRow_C; 957 void (*RGB24ToYRow)(const uint8* src_rgb24, uint8* dst_y, int pix) = 958 RGB24ToYRow_C; 959#else 960 void (*RGB24ToARGBRow)(const uint8* src_rgb, uint8* dst_argb, int pix) = 961 RGB24ToARGBRow_C; 962 void (*ARGBToUVRow)(const uint8* src_argb0, int src_stride_argb, 963 uint8* dst_u, uint8* dst_v, int width) = ARGBToUVRow_C; 964 void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int pix) = 965 ARGBToYRow_C; 966 // Allocate 2 rows of ARGB. 967 const int kRowSize = (width * 4 + 15) & ~15; 968 align_buffer_64(row, kRowSize * 2); 969#endif 970 if (!src_rgb24 || !dst_y || !dst_u || !dst_v || 971 width <= 0 || height == 0) { 972 return -1; 973 } 974 // Negative height means invert the image. 975 if (height < 0) { 976 height = -height; 977 src_rgb24 = src_rgb24 + (height - 1) * src_stride_rgb24; 978 src_stride_rgb24 = -src_stride_rgb24; 979 } 980 981#if defined(HAS_RGB24TOYROW_NEON) 982 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 983 RGB24ToYRow = RGB24ToYRow_Any_NEON; 984 if (IS_ALIGNED(width, 8)) { 985 RGB24ToYRow = RGB24ToYRow_NEON; 986 } 987 if (width >= 16) { 988 RGB24ToUVRow = RGB24ToUVRow_Any_NEON; 989 if (IS_ALIGNED(width, 16)) { 990 RGB24ToUVRow = RGB24ToUVRow_NEON; 991 } 992 } 993 } 994#else // HAS_RGB24TOYROW_NEON 995 996#if defined(HAS_RGB24TOARGBROW_SSSE3) 997 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) { 998 RGB24ToARGBRow = RGB24ToARGBRow_Any_SSSE3; 999 if (IS_ALIGNED(width, 16)) { 1000 RGB24ToARGBRow = RGB24ToARGBRow_SSSE3; 1001 } 1002 } 1003#endif 1004#if defined(HAS_ARGBTOUVROW_SSSE3) 1005 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) { 1006 ARGBToUVRow = ARGBToUVRow_Any_SSSE3; 1007 if (IS_ALIGNED(width, 16)) { 1008 ARGBToUVRow = ARGBToUVRow_SSSE3; 1009 } 1010 } 1011#endif 1012#if defined(HAS_ARGBTOUVROW_SSSE3) 1013 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) { 1014 ARGBToYRow = ARGBToYRow_Any_SSSE3; 1015 if (IS_ALIGNED(width, 16)) { 1016 ARGBToYRow = ARGBToYRow_Unaligned_SSSE3; 1017 if (IS_ALIGNED(dst_y, 16) && IS_ALIGNED(dst_stride_y, 16)) { 1018 ARGBToYRow = ARGBToYRow_SSSE3; 1019 } 1020 } 1021 } 1022#endif // HAS_ARGBTOUVROW_SSSE3 1023#endif // HAS_RGB24TOYROW_NEON 1024 1025 for (y = 0; y < height - 1; y += 2) { 1026#if defined(HAS_RGB24TOYROW_NEON) 1027 RGB24ToUVRow(src_rgb24, src_stride_rgb24, dst_u, dst_v, width); 1028 RGB24ToYRow(src_rgb24, dst_y, width); 1029 RGB24ToYRow(src_rgb24 + src_stride_rgb24, dst_y + dst_stride_y, width); 1030#else 1031 RGB24ToARGBRow(src_rgb24, row, width); 1032 RGB24ToARGBRow(src_rgb24 + src_stride_rgb24, row + kRowSize, width); 1033 ARGBToUVRow(row, kRowSize, dst_u, dst_v, width); 1034 ARGBToYRow(row, dst_y, width); 1035 ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width); 1036#endif 1037 src_rgb24 += src_stride_rgb24 * 2; 1038 dst_y += dst_stride_y * 2; 1039 dst_u += dst_stride_u; 1040 dst_v += dst_stride_v; 1041 } 1042 if (height & 1) { 1043#if defined(HAS_RGB24TOYROW_NEON) 1044 RGB24ToUVRow(src_rgb24, 0, dst_u, dst_v, width); 1045 RGB24ToYRow(src_rgb24, dst_y, width); 1046#else 1047 RGB24ToARGBRow(src_rgb24, row, width); 1048 ARGBToUVRow(row, 0, dst_u, dst_v, width); 1049 ARGBToYRow(row, dst_y, width); 1050#endif 1051 } 1052#if !defined(HAS_RGB24TOYROW_NEON) 1053 free_aligned_buffer_64(row); 1054#endif 1055 return 0; 1056} 1057 1058// Convert RAW to I420. 1059LIBYUV_API 1060int RAWToI420(const uint8* src_raw, int src_stride_raw, 1061 uint8* dst_y, int dst_stride_y, 1062 uint8* dst_u, int dst_stride_u, 1063 uint8* dst_v, int dst_stride_v, 1064 int width, int height) { 1065 int y; 1066#if defined(HAS_RAWTOYROW_NEON) 1067 void (*RAWToUVRow)(const uint8* src_raw, int src_stride_raw, 1068 uint8* dst_u, uint8* dst_v, int width) = RAWToUVRow_C; 1069 void (*RAWToYRow)(const uint8* src_raw, uint8* dst_y, int pix) = 1070 RAWToYRow_C; 1071#else 1072 void (*RAWToARGBRow)(const uint8* src_rgb, uint8* dst_argb, int pix) = 1073 RAWToARGBRow_C; 1074 void (*ARGBToUVRow)(const uint8* src_argb0, int src_stride_argb, 1075 uint8* dst_u, uint8* dst_v, int width) = ARGBToUVRow_C; 1076 void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int pix) = 1077 ARGBToYRow_C; 1078 // Allocate 2 rows of ARGB. 1079 const int kRowSize = (width * 4 + 15) & ~15; 1080 align_buffer_64(row, kRowSize * 2); 1081#endif 1082 if (!src_raw || !dst_y || !dst_u || !dst_v || 1083 width <= 0 || height == 0) { 1084 return -1; 1085 } 1086 // Negative height means invert the image. 1087 if (height < 0) { 1088 height = -height; 1089 src_raw = src_raw + (height - 1) * src_stride_raw; 1090 src_stride_raw = -src_stride_raw; 1091 } 1092 1093#if defined(HAS_RAWTOYROW_NEON) 1094 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 1095 RAWToYRow = RAWToYRow_Any_NEON; 1096 if (IS_ALIGNED(width, 8)) { 1097 RAWToYRow = RAWToYRow_NEON; 1098 } 1099 if (width >= 16) { 1100 RAWToUVRow = RAWToUVRow_Any_NEON; 1101 if (IS_ALIGNED(width, 16)) { 1102 RAWToUVRow = RAWToUVRow_NEON; 1103 } 1104 } 1105 } 1106#else // HAS_RAWTOYROW_NEON 1107 1108#if defined(HAS_RAWTOARGBROW_SSSE3) 1109 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) { 1110 RAWToARGBRow = RAWToARGBRow_Any_SSSE3; 1111 if (IS_ALIGNED(width, 16)) { 1112 RAWToARGBRow = RAWToARGBRow_SSSE3; 1113 } 1114 } 1115#endif 1116#if defined(HAS_ARGBTOUVROW_SSSE3) 1117 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) { 1118 ARGBToUVRow = ARGBToUVRow_Any_SSSE3; 1119 if (IS_ALIGNED(width, 16)) { 1120 ARGBToUVRow = ARGBToUVRow_SSSE3; 1121 } 1122 } 1123#endif 1124#if defined(HAS_ARGBTOUVROW_SSSE3) 1125 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) { 1126 ARGBToYRow = ARGBToYRow_Any_SSSE3; 1127 if (IS_ALIGNED(width, 16)) { 1128 ARGBToYRow = ARGBToYRow_Unaligned_SSSE3; 1129 if (IS_ALIGNED(dst_y, 16) && IS_ALIGNED(dst_stride_y, 16)) { 1130 ARGBToYRow = ARGBToYRow_SSSE3; 1131 } 1132 } 1133 } 1134#endif // HAS_ARGBTOUVROW_SSSE3 1135#endif // HAS_RAWTOYROW_NEON 1136 1137 for (y = 0; y < height - 1; y += 2) { 1138#if defined(HAS_RAWTOYROW_NEON) 1139 RAWToUVRow(src_raw, src_stride_raw, dst_u, dst_v, width); 1140 RAWToYRow(src_raw, dst_y, width); 1141 RAWToYRow(src_raw + src_stride_raw, dst_y + dst_stride_y, width); 1142#else 1143 RAWToARGBRow(src_raw, row, width); 1144 RAWToARGBRow(src_raw + src_stride_raw, row + kRowSize, width); 1145 ARGBToUVRow(row, kRowSize, dst_u, dst_v, width); 1146 ARGBToYRow(row, dst_y, width); 1147 ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width); 1148#endif 1149 src_raw += src_stride_raw * 2; 1150 dst_y += dst_stride_y * 2; 1151 dst_u += dst_stride_u; 1152 dst_v += dst_stride_v; 1153 } 1154 if (height & 1) { 1155#if defined(HAS_RAWTOYROW_NEON) 1156 RAWToUVRow(src_raw, 0, dst_u, dst_v, width); 1157 RAWToYRow(src_raw, dst_y, width); 1158#else 1159 RAWToARGBRow(src_raw, row, width); 1160 ARGBToUVRow(row, 0, dst_u, dst_v, width); 1161 ARGBToYRow(row, dst_y, width); 1162#endif 1163 } 1164#if !defined(HAS_RAWTOYROW_NEON) 1165 free_aligned_buffer_64(row); 1166#endif 1167 return 0; 1168} 1169 1170// Convert RGB565 to I420. 1171LIBYUV_API 1172int RGB565ToI420(const uint8* src_rgb565, int src_stride_rgb565, 1173 uint8* dst_y, int dst_stride_y, 1174 uint8* dst_u, int dst_stride_u, 1175 uint8* dst_v, int dst_stride_v, 1176 int width, int height) { 1177 int y; 1178#if defined(HAS_RGB565TOYROW_NEON) 1179 void (*RGB565ToUVRow)(const uint8* src_rgb565, int src_stride_rgb565, 1180 uint8* dst_u, uint8* dst_v, int width) = RGB565ToUVRow_C; 1181 void (*RGB565ToYRow)(const uint8* src_rgb565, uint8* dst_y, int pix) = 1182 RGB565ToYRow_C; 1183#else 1184 void (*RGB565ToARGBRow)(const uint8* src_rgb, uint8* dst_argb, int pix) = 1185 RGB565ToARGBRow_C; 1186 void (*ARGBToUVRow)(const uint8* src_argb0, int src_stride_argb, 1187 uint8* dst_u, uint8* dst_v, int width) = ARGBToUVRow_C; 1188 void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int pix) = 1189 ARGBToYRow_C; 1190 // Allocate 2 rows of ARGB. 1191 const int kRowSize = (width * 4 + 15) & ~15; 1192 align_buffer_64(row, kRowSize * 2); 1193#endif 1194 if (!src_rgb565 || !dst_y || !dst_u || !dst_v || 1195 width <= 0 || height == 0) { 1196 return -1; 1197 } 1198 // Negative height means invert the image. 1199 if (height < 0) { 1200 height = -height; 1201 src_rgb565 = src_rgb565 + (height - 1) * src_stride_rgb565; 1202 src_stride_rgb565 = -src_stride_rgb565; 1203 } 1204 1205#if defined(HAS_RGB565TOYROW_NEON) 1206 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 1207 RGB565ToYRow = RGB565ToYRow_Any_NEON; 1208 if (IS_ALIGNED(width, 8)) { 1209 RGB565ToYRow = RGB565ToYRow_NEON; 1210 } 1211 if (width >= 16) { 1212 RGB565ToUVRow = RGB565ToUVRow_Any_NEON; 1213 if (IS_ALIGNED(width, 16)) { 1214 RGB565ToUVRow = RGB565ToUVRow_NEON; 1215 } 1216 } 1217 } 1218#else // HAS_RGB565TOYROW_NEON 1219 1220#if defined(HAS_RGB565TOARGBROW_SSE2) 1221 if (TestCpuFlag(kCpuHasSSE2) && width >= 8) { 1222 RGB565ToARGBRow = RGB565ToARGBRow_Any_SSE2; 1223 if (IS_ALIGNED(width, 8)) { 1224 RGB565ToARGBRow = RGB565ToARGBRow_SSE2; 1225 } 1226 } 1227#endif 1228#if defined(HAS_ARGBTOUVROW_SSSE3) 1229 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) { 1230 ARGBToUVRow = ARGBToUVRow_Any_SSSE3; 1231 if (IS_ALIGNED(width, 16)) { 1232 ARGBToUVRow = ARGBToUVRow_SSSE3; 1233 } 1234 } 1235#endif 1236#if defined(HAS_ARGBTOUVROW_SSSE3) 1237 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) { 1238 ARGBToYRow = ARGBToYRow_Any_SSSE3; 1239 if (IS_ALIGNED(width, 16)) { 1240 ARGBToYRow = ARGBToYRow_Unaligned_SSSE3; 1241 if (IS_ALIGNED(dst_y, 16) && IS_ALIGNED(dst_stride_y, 16)) { 1242 ARGBToYRow = ARGBToYRow_SSSE3; 1243 } 1244 } 1245 } 1246#endif // HAS_ARGBTOUVROW_SSSE3 1247#endif // HAS_RGB565TOYROW_NEON 1248 1249 for (y = 0; y < height - 1; y += 2) { 1250#if defined(HAS_RGB565TOYROW_NEON) 1251 RGB565ToUVRow(src_rgb565, src_stride_rgb565, dst_u, dst_v, width); 1252 RGB565ToYRow(src_rgb565, dst_y, width); 1253 RGB565ToYRow(src_rgb565 + src_stride_rgb565, dst_y + dst_stride_y, width); 1254#else 1255 RGB565ToARGBRow(src_rgb565, row, width); 1256 RGB565ToARGBRow(src_rgb565 + src_stride_rgb565, row + kRowSize, width); 1257 ARGBToUVRow(row, kRowSize, dst_u, dst_v, width); 1258 ARGBToYRow(row, dst_y, width); 1259 ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width); 1260#endif 1261 src_rgb565 += src_stride_rgb565 * 2; 1262 dst_y += dst_stride_y * 2; 1263 dst_u += dst_stride_u; 1264 dst_v += dst_stride_v; 1265 } 1266 if (height & 1) { 1267#if defined(HAS_RGB565TOYROW_NEON) 1268 RGB565ToUVRow(src_rgb565, 0, dst_u, dst_v, width); 1269 RGB565ToYRow(src_rgb565, dst_y, width); 1270#else 1271 RGB565ToARGBRow(src_rgb565, row, width); 1272 ARGBToUVRow(row, 0, dst_u, dst_v, width); 1273 ARGBToYRow(row, dst_y, width); 1274#endif 1275 } 1276#if !defined(HAS_RGB565TOYROW_NEON) 1277 free_aligned_buffer_64(row); 1278#endif 1279 return 0; 1280} 1281 1282// Convert ARGB1555 to I420. 1283LIBYUV_API 1284int ARGB1555ToI420(const uint8* src_argb1555, int src_stride_argb1555, 1285 uint8* dst_y, int dst_stride_y, 1286 uint8* dst_u, int dst_stride_u, 1287 uint8* dst_v, int dst_stride_v, 1288 int width, int height) { 1289 int y; 1290#if defined(HAS_ARGB1555TOYROW_NEON) 1291 void (*ARGB1555ToUVRow)(const uint8* src_argb1555, int src_stride_argb1555, 1292 uint8* dst_u, uint8* dst_v, int width) = ARGB1555ToUVRow_C; 1293 void (*ARGB1555ToYRow)(const uint8* src_argb1555, uint8* dst_y, int pix) = 1294 ARGB1555ToYRow_C; 1295#else 1296 void (*ARGB1555ToARGBRow)(const uint8* src_rgb, uint8* dst_argb, int pix) = 1297 ARGB1555ToARGBRow_C; 1298 void (*ARGBToUVRow)(const uint8* src_argb0, int src_stride_argb, 1299 uint8* dst_u, uint8* dst_v, int width) = ARGBToUVRow_C; 1300 void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int pix) = 1301 ARGBToYRow_C; 1302 // Allocate 2 rows of ARGB. 1303 const int kRowSize = (width * 4 + 15) & ~15; 1304 align_buffer_64(row, kRowSize * 2); 1305#endif 1306 if (!src_argb1555 || !dst_y || !dst_u || !dst_v || 1307 width <= 0 || height == 0) { 1308 return -1; 1309 } 1310 // Negative height means invert the image. 1311 if (height < 0) { 1312 height = -height; 1313 src_argb1555 = src_argb1555 + (height - 1) * src_stride_argb1555; 1314 src_stride_argb1555 = -src_stride_argb1555; 1315 } 1316 1317#if defined(HAS_ARGB1555TOYROW_NEON) 1318 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 1319 ARGB1555ToYRow = ARGB1555ToYRow_Any_NEON; 1320 if (IS_ALIGNED(width, 8)) { 1321 ARGB1555ToYRow = ARGB1555ToYRow_NEON; 1322 } 1323 if (width >= 16) { 1324 ARGB1555ToUVRow = ARGB1555ToUVRow_Any_NEON; 1325 if (IS_ALIGNED(width, 16)) { 1326 ARGB1555ToUVRow = ARGB1555ToUVRow_NEON; 1327 } 1328 } 1329 } 1330#else // HAS_ARGB1555TOYROW_NEON 1331 1332#if defined(HAS_ARGB1555TOARGBROW_SSE2) 1333 if (TestCpuFlag(kCpuHasSSE2) && width >= 8) { 1334 ARGB1555ToARGBRow = ARGB1555ToARGBRow_Any_SSE2; 1335 if (IS_ALIGNED(width, 8)) { 1336 ARGB1555ToARGBRow = ARGB1555ToARGBRow_SSE2; 1337 } 1338 } 1339#endif 1340#if defined(HAS_ARGBTOUVROW_SSSE3) 1341 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) { 1342 ARGBToUVRow = ARGBToUVRow_Any_SSSE3; 1343 if (IS_ALIGNED(width, 16)) { 1344 ARGBToUVRow = ARGBToUVRow_SSSE3; 1345 } 1346 } 1347#endif 1348#if defined(HAS_ARGBTOUVROW_SSSE3) 1349 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) { 1350 ARGBToYRow = ARGBToYRow_Any_SSSE3; 1351 if (IS_ALIGNED(width, 16)) { 1352 ARGBToYRow = ARGBToYRow_Unaligned_SSSE3; 1353 if (IS_ALIGNED(dst_y, 16) && IS_ALIGNED(dst_stride_y, 16)) { 1354 ARGBToYRow = ARGBToYRow_SSSE3; 1355 } 1356 } 1357 } 1358#endif // HAS_ARGBTOUVROW_SSSE3 1359#endif // HAS_ARGB1555TOYROW_NEON 1360 1361 for (y = 0; y < height - 1; y += 2) { 1362#if defined(HAS_ARGB1555TOYROW_NEON) 1363 ARGB1555ToUVRow(src_argb1555, src_stride_argb1555, dst_u, dst_v, width); 1364 ARGB1555ToYRow(src_argb1555, dst_y, width); 1365 ARGB1555ToYRow(src_argb1555 + src_stride_argb1555, dst_y + dst_stride_y, 1366 width); 1367#else 1368 ARGB1555ToARGBRow(src_argb1555, row, width); 1369 ARGB1555ToARGBRow(src_argb1555 + src_stride_argb1555, row + kRowSize, 1370 width); 1371 ARGBToUVRow(row, kRowSize, dst_u, dst_v, width); 1372 ARGBToYRow(row, dst_y, width); 1373 ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width); 1374#endif 1375 src_argb1555 += src_stride_argb1555 * 2; 1376 dst_y += dst_stride_y * 2; 1377 dst_u += dst_stride_u; 1378 dst_v += dst_stride_v; 1379 } 1380 if (height & 1) { 1381#if defined(HAS_ARGB1555TOYROW_NEON) 1382 ARGB1555ToUVRow(src_argb1555, 0, dst_u, dst_v, width); 1383 ARGB1555ToYRow(src_argb1555, dst_y, width); 1384#else 1385 ARGB1555ToARGBRow(src_argb1555, row, width); 1386 ARGBToUVRow(row, 0, dst_u, dst_v, width); 1387 ARGBToYRow(row, dst_y, width); 1388#endif 1389 } 1390#if !defined(HAS_ARGB1555TOYROW_NEON) 1391 free_aligned_buffer_64(row); 1392#endif 1393 return 0; 1394} 1395 1396// Convert ARGB4444 to I420. 1397LIBYUV_API 1398int ARGB4444ToI420(const uint8* src_argb4444, int src_stride_argb4444, 1399 uint8* dst_y, int dst_stride_y, 1400 uint8* dst_u, int dst_stride_u, 1401 uint8* dst_v, int dst_stride_v, 1402 int width, int height) { 1403 int y; 1404#if defined(HAS_ARGB4444TOYROW_NEON) 1405 void (*ARGB4444ToUVRow)(const uint8* src_argb4444, int src_stride_argb4444, 1406 uint8* dst_u, uint8* dst_v, int width) = ARGB4444ToUVRow_C; 1407 void (*ARGB4444ToYRow)(const uint8* src_argb4444, uint8* dst_y, int pix) = 1408 ARGB4444ToYRow_C; 1409#else 1410 void (*ARGB4444ToARGBRow)(const uint8* src_rgb, uint8* dst_argb, int pix) = 1411 ARGB4444ToARGBRow_C; 1412 void (*ARGBToUVRow)(const uint8* src_argb0, int src_stride_argb, 1413 uint8* dst_u, uint8* dst_v, int width) = ARGBToUVRow_C; 1414 void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int pix) = 1415 ARGBToYRow_C; 1416 // Allocate 2 rows of ARGB. 1417 const int kRowSize = (width * 4 + 15) & ~15; 1418 align_buffer_64(row, kRowSize * 2); 1419#endif 1420 if (!src_argb4444 || !dst_y || !dst_u || !dst_v || 1421 width <= 0 || height == 0) { 1422 return -1; 1423 } 1424 // Negative height means invert the image. 1425 if (height < 0) { 1426 height = -height; 1427 src_argb4444 = src_argb4444 + (height - 1) * src_stride_argb4444; 1428 src_stride_argb4444 = -src_stride_argb4444; 1429 } 1430 1431#if defined(HAS_ARGB4444TOYROW_NEON) 1432 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 1433 ARGB4444ToYRow = ARGB4444ToYRow_Any_NEON; 1434 if (IS_ALIGNED(width, 8)) { 1435 ARGB4444ToYRow = ARGB4444ToYRow_NEON; 1436 } 1437 if (width >= 16) { 1438 ARGB4444ToUVRow = ARGB4444ToUVRow_Any_NEON; 1439 if (IS_ALIGNED(width, 16)) { 1440 ARGB4444ToUVRow = ARGB4444ToUVRow_NEON; 1441 } 1442 } 1443 } 1444#else // HAS_ARGB4444TOYROW_NEON 1445 1446#if defined(HAS_ARGB4444TOARGBROW_SSE2) 1447 if (TestCpuFlag(kCpuHasSSE2) && width >= 8) { 1448 ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_SSE2; 1449 if (IS_ALIGNED(width, 8)) { 1450 ARGB4444ToARGBRow = ARGB4444ToARGBRow_SSE2; 1451 } 1452 } 1453#endif 1454#if defined(HAS_ARGBTOUVROW_SSSE3) 1455 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) { 1456 ARGBToUVRow = ARGBToUVRow_Any_SSSE3; 1457 if (IS_ALIGNED(width, 16)) { 1458 ARGBToUVRow = ARGBToUVRow_SSSE3; 1459 } 1460 } 1461#endif 1462#if defined(HAS_ARGBTOUVROW_SSSE3) 1463 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) { 1464 ARGBToYRow = ARGBToYRow_Any_SSSE3; 1465 if (IS_ALIGNED(width, 16)) { 1466 ARGBToYRow = ARGBToYRow_Unaligned_SSSE3; 1467 if (IS_ALIGNED(dst_y, 16) && IS_ALIGNED(dst_stride_y, 16)) { 1468 ARGBToYRow = ARGBToYRow_SSSE3; 1469 } 1470 } 1471 } 1472#endif // HAS_ARGBTOUVROW_SSSE3 1473#endif // HAS_ARGB4444TOYROW_NEON 1474 1475 for (y = 0; y < height - 1; y += 2) { 1476#if defined(HAS_ARGB4444TOYROW_NEON) 1477 ARGB4444ToUVRow(src_argb4444, src_stride_argb4444, dst_u, dst_v, width); 1478 ARGB4444ToYRow(src_argb4444, dst_y, width); 1479 ARGB4444ToYRow(src_argb4444 + src_stride_argb4444, dst_y + dst_stride_y, 1480 width); 1481#else 1482 ARGB4444ToARGBRow(src_argb4444, row, width); 1483 ARGB4444ToARGBRow(src_argb4444 + src_stride_argb4444, row + kRowSize, 1484 width); 1485 ARGBToUVRow(row, kRowSize, dst_u, dst_v, width); 1486 ARGBToYRow(row, dst_y, width); 1487 ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width); 1488#endif 1489 src_argb4444 += src_stride_argb4444 * 2; 1490 dst_y += dst_stride_y * 2; 1491 dst_u += dst_stride_u; 1492 dst_v += dst_stride_v; 1493 } 1494 if (height & 1) { 1495#if defined(HAS_ARGB4444TOYROW_NEON) 1496 ARGB4444ToUVRow(src_argb4444, 0, dst_u, dst_v, width); 1497 ARGB4444ToYRow(src_argb4444, dst_y, width); 1498#else 1499 ARGB4444ToARGBRow(src_argb4444, row, width); 1500 ARGBToUVRow(row, 0, dst_u, dst_v, width); 1501 ARGBToYRow(row, dst_y, width); 1502#endif 1503 } 1504#if !defined(HAS_ARGB4444TOYROW_NEON) 1505 free_aligned_buffer_64(row); 1506#endif 1507 return 0; 1508} 1509 1510#ifdef __cplusplus 1511} // extern "C" 1512} // namespace libyuv 1513#endif 1514