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_argb.h" 12 13 #include "libyuv/cpu_id.h" 14 #include "libyuv/format_conversion.h" 15 #ifdef HAVE_JPEG 16 #include "libyuv/mjpeg_decoder.h" 17 #endif 18 #include "libyuv/rotate_argb.h" 19 #include "libyuv/row.h" 20 #include "libyuv/video_common.h" 21 22 #ifdef __cplusplus 23 namespace libyuv { 24 extern "C" { 25 #endif 26 27 // Copy ARGB with optional flipping 28 LIBYUV_API 29 int ARGBCopy(const uint8* src_argb, int src_stride_argb, 30 uint8* dst_argb, int dst_stride_argb, 31 int width, int height) { 32 if (!src_argb || !dst_argb || 33 width <= 0 || height == 0) { 34 return -1; 35 } 36 // Negative height means invert the image. 37 if (height < 0) { 38 height = -height; 39 src_argb = src_argb + (height - 1) * src_stride_argb; 40 src_stride_argb = -src_stride_argb; 41 } 42 43 CopyPlane(src_argb, src_stride_argb, dst_argb, dst_stride_argb, 44 width * 4, height); 45 return 0; 46 } 47 48 // Convert I444 to ARGB. 49 LIBYUV_API 50 int I444ToARGB(const uint8* src_y, int src_stride_y, 51 const uint8* src_u, int src_stride_u, 52 const uint8* src_v, int src_stride_v, 53 uint8* dst_argb, int dst_stride_argb, 54 int width, int height) { 55 int y; 56 void (*I444ToARGBRow)(const uint8* y_buf, 57 const uint8* u_buf, 58 const uint8* v_buf, 59 uint8* rgb_buf, 60 int width) = I444ToARGBRow_C; 61 if (!src_y || !src_u || !src_v || 62 !dst_argb || 63 width <= 0 || height == 0) { 64 return -1; 65 } 66 // Negative height means invert the image. 67 if (height < 0) { 68 height = -height; 69 dst_argb = dst_argb + (height - 1) * dst_stride_argb; 70 dst_stride_argb = -dst_stride_argb; 71 } 72 // Coalesce rows. 73 if (src_stride_y == width && 74 src_stride_u == width && 75 src_stride_v == width && 76 dst_stride_argb == width * 4) { 77 width *= height; 78 height = 1; 79 src_stride_y = src_stride_u = src_stride_v = dst_stride_argb = 0; 80 } 81 #if defined(HAS_I444TOARGBROW_SSSE3) 82 if (TestCpuFlag(kCpuHasSSSE3) && width >= 8) { 83 I444ToARGBRow = I444ToARGBRow_Any_SSSE3; 84 if (IS_ALIGNED(width, 8)) { 85 I444ToARGBRow = I444ToARGBRow_Unaligned_SSSE3; 86 if (IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) { 87 I444ToARGBRow = I444ToARGBRow_SSSE3; 88 } 89 } 90 } 91 #elif defined(HAS_I444TOARGBROW_NEON) 92 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 93 I444ToARGBRow = I444ToARGBRow_Any_NEON; 94 if (IS_ALIGNED(width, 8)) { 95 I444ToARGBRow = I444ToARGBRow_NEON; 96 } 97 } 98 #endif 99 100 for (y = 0; y < height; ++y) { 101 I444ToARGBRow(src_y, src_u, src_v, dst_argb, width); 102 dst_argb += dst_stride_argb; 103 src_y += src_stride_y; 104 src_u += src_stride_u; 105 src_v += src_stride_v; 106 } 107 return 0; 108 } 109 110 // Convert I422 to ARGB. 111 LIBYUV_API 112 int I422ToARGB(const uint8* src_y, int src_stride_y, 113 const uint8* src_u, int src_stride_u, 114 const uint8* src_v, int src_stride_v, 115 uint8* dst_argb, int dst_stride_argb, 116 int width, int height) { 117 int y; 118 void (*I422ToARGBRow)(const uint8* y_buf, 119 const uint8* u_buf, 120 const uint8* v_buf, 121 uint8* rgb_buf, 122 int width) = I422ToARGBRow_C; 123 if (!src_y || !src_u || !src_v || 124 !dst_argb || 125 width <= 0 || height == 0) { 126 return -1; 127 } 128 // Negative height means invert the image. 129 if (height < 0) { 130 height = -height; 131 dst_argb = dst_argb + (height - 1) * dst_stride_argb; 132 dst_stride_argb = -dst_stride_argb; 133 } 134 // Coalesce rows. 135 if (src_stride_y == width && 136 src_stride_u * 2 == width && 137 src_stride_v * 2 == width && 138 dst_stride_argb == width * 4) { 139 width *= height; 140 height = 1; 141 src_stride_y = src_stride_u = src_stride_v = dst_stride_argb = 0; 142 } 143 #if defined(HAS_I422TOARGBROW_SSSE3) 144 if (TestCpuFlag(kCpuHasSSSE3) && width >= 8) { 145 I422ToARGBRow = I422ToARGBRow_Any_SSSE3; 146 if (IS_ALIGNED(width, 8)) { 147 I422ToARGBRow = I422ToARGBRow_Unaligned_SSSE3; 148 if (IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) { 149 I422ToARGBRow = I422ToARGBRow_SSSE3; 150 } 151 } 152 } 153 #endif 154 #if defined(HAS_I422TOARGBROW_AVX2) 155 if (TestCpuFlag(kCpuHasAVX2) && width >= 16) { 156 I422ToARGBRow = I422ToARGBRow_Any_AVX2; 157 if (IS_ALIGNED(width, 16)) { 158 I422ToARGBRow = I422ToARGBRow_AVX2; 159 } 160 } 161 #endif 162 #if defined(HAS_I422TOARGBROW_NEON) 163 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 164 I422ToARGBRow = I422ToARGBRow_Any_NEON; 165 if (IS_ALIGNED(width, 8)) { 166 I422ToARGBRow = I422ToARGBRow_NEON; 167 } 168 } 169 #endif 170 #if defined(HAS_I422TOARGBROW_MIPS_DSPR2) 171 if (TestCpuFlag(kCpuHasMIPS_DSPR2) && IS_ALIGNED(width, 4) && 172 IS_ALIGNED(src_y, 4) && IS_ALIGNED(src_stride_y, 4) && 173 IS_ALIGNED(src_u, 2) && IS_ALIGNED(src_stride_u, 2) && 174 IS_ALIGNED(src_v, 2) && IS_ALIGNED(src_stride_v, 2) && 175 IS_ALIGNED(dst_argb, 4) && IS_ALIGNED(dst_stride_argb, 4)) { 176 I422ToARGBRow = I422ToARGBRow_MIPS_DSPR2; 177 } 178 #endif 179 180 for (y = 0; y < height; ++y) { 181 I422ToARGBRow(src_y, src_u, src_v, dst_argb, width); 182 dst_argb += dst_stride_argb; 183 src_y += src_stride_y; 184 src_u += src_stride_u; 185 src_v += src_stride_v; 186 } 187 return 0; 188 } 189 190 // Convert I411 to ARGB. 191 LIBYUV_API 192 int I411ToARGB(const uint8* src_y, int src_stride_y, 193 const uint8* src_u, int src_stride_u, 194 const uint8* src_v, int src_stride_v, 195 uint8* dst_argb, int dst_stride_argb, 196 int width, int height) { 197 int y; 198 void (*I411ToARGBRow)(const uint8* y_buf, 199 const uint8* u_buf, 200 const uint8* v_buf, 201 uint8* rgb_buf, 202 int width) = I411ToARGBRow_C; 203 if (!src_y || !src_u || !src_v || 204 !dst_argb || 205 width <= 0 || height == 0) { 206 return -1; 207 } 208 // Negative height means invert the image. 209 if (height < 0) { 210 height = -height; 211 dst_argb = dst_argb + (height - 1) * dst_stride_argb; 212 dst_stride_argb = -dst_stride_argb; 213 } 214 // Coalesce rows. 215 if (src_stride_y == width && 216 src_stride_u * 4 == width && 217 src_stride_v * 4 == width && 218 dst_stride_argb == width * 4) { 219 width *= height; 220 height = 1; 221 src_stride_y = src_stride_u = src_stride_v = dst_stride_argb = 0; 222 } 223 #if defined(HAS_I411TOARGBROW_SSSE3) 224 if (TestCpuFlag(kCpuHasSSSE3) && width >= 8) { 225 I411ToARGBRow = I411ToARGBRow_Any_SSSE3; 226 if (IS_ALIGNED(width, 8)) { 227 I411ToARGBRow = I411ToARGBRow_Unaligned_SSSE3; 228 if (IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) { 229 I411ToARGBRow = I411ToARGBRow_SSSE3; 230 } 231 } 232 } 233 #elif defined(HAS_I411TOARGBROW_NEON) 234 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 235 I411ToARGBRow = I411ToARGBRow_Any_NEON; 236 if (IS_ALIGNED(width, 8)) { 237 I411ToARGBRow = I411ToARGBRow_NEON; 238 } 239 } 240 #endif 241 242 for (y = 0; y < height; ++y) { 243 I411ToARGBRow(src_y, src_u, src_v, dst_argb, width); 244 dst_argb += dst_stride_argb; 245 src_y += src_stride_y; 246 src_u += src_stride_u; 247 src_v += src_stride_v; 248 } 249 return 0; 250 } 251 252 // Convert I400 to ARGB. 253 LIBYUV_API 254 int I400ToARGB_Reference(const uint8* src_y, int src_stride_y, 255 uint8* dst_argb, int dst_stride_argb, 256 int width, int height) { 257 int y; 258 void (*YToARGBRow)(const uint8* y_buf, 259 uint8* rgb_buf, 260 int width) = YToARGBRow_C; 261 if (!src_y || !dst_argb || 262 width <= 0 || height == 0) { 263 return -1; 264 } 265 // Negative height means invert the image. 266 if (height < 0) { 267 height = -height; 268 dst_argb = dst_argb + (height - 1) * dst_stride_argb; 269 dst_stride_argb = -dst_stride_argb; 270 } 271 // Coalesce rows. 272 if (src_stride_y == width && 273 dst_stride_argb == width * 4) { 274 width *= height; 275 height = 1; 276 src_stride_y = dst_stride_argb = 0; 277 } 278 #if defined(HAS_YTOARGBROW_SSE2) 279 if (TestCpuFlag(kCpuHasSSE2) && width >= 8 && 280 IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) { 281 YToARGBRow = YToARGBRow_Any_SSE2; 282 if (IS_ALIGNED(width, 8)) { 283 YToARGBRow = YToARGBRow_SSE2; 284 } 285 } 286 #elif defined(HAS_YTOARGBROW_NEON) 287 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 288 YToARGBRow = YToARGBRow_Any_NEON; 289 if (IS_ALIGNED(width, 8)) { 290 YToARGBRow = YToARGBRow_NEON; 291 } 292 } 293 #endif 294 295 for (y = 0; y < height; ++y) { 296 YToARGBRow(src_y, dst_argb, width); 297 dst_argb += dst_stride_argb; 298 src_y += src_stride_y; 299 } 300 return 0; 301 } 302 303 // Convert I400 to ARGB. 304 LIBYUV_API 305 int I400ToARGB(const uint8* src_y, int src_stride_y, 306 uint8* dst_argb, int dst_stride_argb, 307 int width, int height) { 308 int y; 309 void (*I400ToARGBRow)(const uint8* src_y, uint8* dst_argb, int pix) = 310 I400ToARGBRow_C; 311 if (!src_y || !dst_argb || 312 width <= 0 || height == 0) { 313 return -1; 314 } 315 // Negative height means invert the image. 316 if (height < 0) { 317 height = -height; 318 src_y = src_y + (height - 1) * src_stride_y; 319 src_stride_y = -src_stride_y; 320 } 321 // Coalesce rows. 322 if (src_stride_y == width && 323 dst_stride_argb == width * 4) { 324 width *= height; 325 height = 1; 326 src_stride_y = dst_stride_argb = 0; 327 } 328 #if defined(HAS_I400TOARGBROW_SSE2) 329 if (TestCpuFlag(kCpuHasSSE2) && width >= 8) { 330 I400ToARGBRow = I400ToARGBRow_Any_SSE2; 331 if (IS_ALIGNED(width, 8)) { 332 I400ToARGBRow = I400ToARGBRow_Unaligned_SSE2; 333 if (IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) { 334 I400ToARGBRow = I400ToARGBRow_SSE2; 335 } 336 } 337 } 338 #elif defined(HAS_I400TOARGBROW_NEON) 339 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 340 I400ToARGBRow = I400ToARGBRow_Any_NEON; 341 if (IS_ALIGNED(width, 8)) { 342 I400ToARGBRow = I400ToARGBRow_NEON; 343 } 344 } 345 #endif 346 for (y = 0; y < height; ++y) { 347 I400ToARGBRow(src_y, dst_argb, width); 348 src_y += src_stride_y; 349 dst_argb += dst_stride_argb; 350 } 351 return 0; 352 } 353 354 // Shuffle table for converting BGRA to ARGB. 355 static uvec8 kShuffleMaskBGRAToARGB = { 356 3u, 2u, 1u, 0u, 7u, 6u, 5u, 4u, 11u, 10u, 9u, 8u, 15u, 14u, 13u, 12u 357 }; 358 359 // Shuffle table for converting ABGR to ARGB. 360 static uvec8 kShuffleMaskABGRToARGB = { 361 2u, 1u, 0u, 3u, 6u, 5u, 4u, 7u, 10u, 9u, 8u, 11u, 14u, 13u, 12u, 15u 362 }; 363 364 // Shuffle table for converting RGBA to ARGB. 365 static uvec8 kShuffleMaskRGBAToARGB = { 366 1u, 2u, 3u, 0u, 5u, 6u, 7u, 4u, 9u, 10u, 11u, 8u, 13u, 14u, 15u, 12u 367 }; 368 369 // Convert BGRA to ARGB. 370 LIBYUV_API 371 int BGRAToARGB(const uint8* src_bgra, int src_stride_bgra, 372 uint8* dst_argb, int dst_stride_argb, 373 int width, int height) { 374 return ARGBShuffle(src_bgra, src_stride_bgra, 375 dst_argb, dst_stride_argb, 376 (const uint8*)(&kShuffleMaskBGRAToARGB), 377 width, height); 378 } 379 380 // Convert ARGB to BGRA (same as BGRAToARGB). 381 LIBYUV_API 382 int ARGBToBGRA(const uint8* src_bgra, int src_stride_bgra, 383 uint8* dst_argb, int dst_stride_argb, 384 int width, int height) { 385 return ARGBShuffle(src_bgra, src_stride_bgra, 386 dst_argb, dst_stride_argb, 387 (const uint8*)(&kShuffleMaskBGRAToARGB), 388 width, height); 389 } 390 391 // Convert ABGR to ARGB. 392 LIBYUV_API 393 int ABGRToARGB(const uint8* src_abgr, int src_stride_abgr, 394 uint8* dst_argb, int dst_stride_argb, 395 int width, int height) { 396 return ARGBShuffle(src_abgr, src_stride_abgr, 397 dst_argb, dst_stride_argb, 398 (const uint8*)(&kShuffleMaskABGRToARGB), 399 width, height); 400 } 401 402 // Convert ARGB to ABGR to (same as ABGRToARGB). 403 LIBYUV_API 404 int ARGBToABGR(const uint8* src_abgr, int src_stride_abgr, 405 uint8* dst_argb, int dst_stride_argb, 406 int width, int height) { 407 return ARGBShuffle(src_abgr, src_stride_abgr, 408 dst_argb, dst_stride_argb, 409 (const uint8*)(&kShuffleMaskABGRToARGB), 410 width, height); 411 } 412 413 // Convert RGBA to ARGB. 414 LIBYUV_API 415 int RGBAToARGB(const uint8* src_rgba, int src_stride_rgba, 416 uint8* dst_argb, int dst_stride_argb, 417 int width, int height) { 418 return ARGBShuffle(src_rgba, src_stride_rgba, 419 dst_argb, dst_stride_argb, 420 (const uint8*)(&kShuffleMaskRGBAToARGB), 421 width, height); 422 } 423 424 // Convert RGB24 to ARGB. 425 LIBYUV_API 426 int RGB24ToARGB(const uint8* src_rgb24, int src_stride_rgb24, 427 uint8* dst_argb, int dst_stride_argb, 428 int width, int height) { 429 int y; 430 void (*RGB24ToARGBRow)(const uint8* src_rgb, uint8* dst_argb, int pix) = 431 RGB24ToARGBRow_C; 432 if (!src_rgb24 || !dst_argb || 433 width <= 0 || height == 0) { 434 return -1; 435 } 436 // Negative height means invert the image. 437 if (height < 0) { 438 height = -height; 439 src_rgb24 = src_rgb24 + (height - 1) * src_stride_rgb24; 440 src_stride_rgb24 = -src_stride_rgb24; 441 } 442 // Coalesce rows. 443 if (src_stride_rgb24 == width * 3 && 444 dst_stride_argb == width * 4) { 445 width *= height; 446 height = 1; 447 src_stride_rgb24 = dst_stride_argb = 0; 448 } 449 #if defined(HAS_RGB24TOARGBROW_SSSE3) 450 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16 && 451 IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) { 452 RGB24ToARGBRow = RGB24ToARGBRow_Any_SSSE3; 453 if (IS_ALIGNED(width, 16)) { 454 RGB24ToARGBRow = RGB24ToARGBRow_SSSE3; 455 } 456 } 457 #elif defined(HAS_RGB24TOARGBROW_NEON) 458 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 459 RGB24ToARGBRow = RGB24ToARGBRow_Any_NEON; 460 if (IS_ALIGNED(width, 8)) { 461 RGB24ToARGBRow = RGB24ToARGBRow_NEON; 462 } 463 } 464 #endif 465 466 for (y = 0; y < height; ++y) { 467 RGB24ToARGBRow(src_rgb24, dst_argb, width); 468 src_rgb24 += src_stride_rgb24; 469 dst_argb += dst_stride_argb; 470 } 471 return 0; 472 } 473 474 // Convert RAW to ARGB. 475 LIBYUV_API 476 int RAWToARGB(const uint8* src_raw, int src_stride_raw, 477 uint8* dst_argb, int dst_stride_argb, 478 int width, int height) { 479 int y; 480 void (*RAWToARGBRow)(const uint8* src_rgb, uint8* dst_argb, int pix) = 481 RAWToARGBRow_C; 482 if (!src_raw || !dst_argb || 483 width <= 0 || height == 0) { 484 return -1; 485 } 486 // Negative height means invert the image. 487 if (height < 0) { 488 height = -height; 489 src_raw = src_raw + (height - 1) * src_stride_raw; 490 src_stride_raw = -src_stride_raw; 491 } 492 // Coalesce rows. 493 if (src_stride_raw == width * 3 && 494 dst_stride_argb == width * 4) { 495 width *= height; 496 height = 1; 497 src_stride_raw = dst_stride_argb = 0; 498 } 499 #if defined(HAS_RAWTOARGBROW_SSSE3) 500 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16 && 501 IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) { 502 RAWToARGBRow = RAWToARGBRow_Any_SSSE3; 503 if (IS_ALIGNED(width, 16)) { 504 RAWToARGBRow = RAWToARGBRow_SSSE3; 505 } 506 } 507 #elif defined(HAS_RAWTOARGBROW_NEON) 508 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 509 RAWToARGBRow = RAWToARGBRow_Any_NEON; 510 if (IS_ALIGNED(width, 8)) { 511 RAWToARGBRow = RAWToARGBRow_NEON; 512 } 513 } 514 #endif 515 516 for (y = 0; y < height; ++y) { 517 RAWToARGBRow(src_raw, dst_argb, width); 518 src_raw += src_stride_raw; 519 dst_argb += dst_stride_argb; 520 } 521 return 0; 522 } 523 524 // Convert RGB565 to ARGB. 525 LIBYUV_API 526 int RGB565ToARGB(const uint8* src_rgb565, int src_stride_rgb565, 527 uint8* dst_argb, int dst_stride_argb, 528 int width, int height) { 529 int y; 530 void (*RGB565ToARGBRow)(const uint8* src_rgb565, uint8* dst_argb, int pix) = 531 RGB565ToARGBRow_C; 532 if (!src_rgb565 || !dst_argb || 533 width <= 0 || height == 0) { 534 return -1; 535 } 536 // Negative height means invert the image. 537 if (height < 0) { 538 height = -height; 539 src_rgb565 = src_rgb565 + (height - 1) * src_stride_rgb565; 540 src_stride_rgb565 = -src_stride_rgb565; 541 } 542 // Coalesce rows. 543 if (src_stride_rgb565 == width * 2 && 544 dst_stride_argb == width * 4) { 545 width *= height; 546 height = 1; 547 src_stride_rgb565 = dst_stride_argb = 0; 548 } 549 #if defined(HAS_RGB565TOARGBROW_SSE2) 550 if (TestCpuFlag(kCpuHasSSE2) && width >= 8 && 551 IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) { 552 RGB565ToARGBRow = RGB565ToARGBRow_Any_SSE2; 553 if (IS_ALIGNED(width, 8)) { 554 RGB565ToARGBRow = RGB565ToARGBRow_SSE2; 555 } 556 } 557 #elif defined(HAS_RGB565TOARGBROW_NEON) 558 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 559 RGB565ToARGBRow = RGB565ToARGBRow_Any_NEON; 560 if (IS_ALIGNED(width, 8)) { 561 RGB565ToARGBRow = RGB565ToARGBRow_NEON; 562 } 563 } 564 #endif 565 566 for (y = 0; y < height; ++y) { 567 RGB565ToARGBRow(src_rgb565, dst_argb, width); 568 src_rgb565 += src_stride_rgb565; 569 dst_argb += dst_stride_argb; 570 } 571 return 0; 572 } 573 574 // Convert ARGB1555 to ARGB. 575 LIBYUV_API 576 int ARGB1555ToARGB(const uint8* src_argb1555, int src_stride_argb1555, 577 uint8* dst_argb, int dst_stride_argb, 578 int width, int height) { 579 int y; 580 void (*ARGB1555ToARGBRow)(const uint8* src_argb1555, uint8* dst_argb, 581 int pix) = ARGB1555ToARGBRow_C; 582 if (!src_argb1555 || !dst_argb || 583 width <= 0 || height == 0) { 584 return -1; 585 } 586 // Negative height means invert the image. 587 if (height < 0) { 588 height = -height; 589 src_argb1555 = src_argb1555 + (height - 1) * src_stride_argb1555; 590 src_stride_argb1555 = -src_stride_argb1555; 591 } 592 // Coalesce rows. 593 if (src_stride_argb1555 == width * 2 && 594 dst_stride_argb == width * 4) { 595 width *= height; 596 height = 1; 597 src_stride_argb1555 = dst_stride_argb = 0; 598 } 599 #if defined(HAS_ARGB1555TOARGBROW_SSE2) 600 if (TestCpuFlag(kCpuHasSSE2) && width >= 8 && 601 IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) { 602 ARGB1555ToARGBRow = ARGB1555ToARGBRow_Any_SSE2; 603 if (IS_ALIGNED(width, 8)) { 604 ARGB1555ToARGBRow = ARGB1555ToARGBRow_SSE2; 605 } 606 } 607 #elif defined(HAS_ARGB1555TOARGBROW_NEON) 608 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 609 ARGB1555ToARGBRow = ARGB1555ToARGBRow_Any_NEON; 610 if (IS_ALIGNED(width, 8)) { 611 ARGB1555ToARGBRow = ARGB1555ToARGBRow_NEON; 612 } 613 } 614 #endif 615 616 for (y = 0; y < height; ++y) { 617 ARGB1555ToARGBRow(src_argb1555, dst_argb, width); 618 src_argb1555 += src_stride_argb1555; 619 dst_argb += dst_stride_argb; 620 } 621 return 0; 622 } 623 624 // Convert ARGB4444 to ARGB. 625 LIBYUV_API 626 int ARGB4444ToARGB(const uint8* src_argb4444, int src_stride_argb4444, 627 uint8* dst_argb, int dst_stride_argb, 628 int width, int height) { 629 int y; 630 void (*ARGB4444ToARGBRow)(const uint8* src_argb4444, uint8* dst_argb, 631 int pix) = ARGB4444ToARGBRow_C; 632 if (!src_argb4444 || !dst_argb || 633 width <= 0 || height == 0) { 634 return -1; 635 } 636 // Negative height means invert the image. 637 if (height < 0) { 638 height = -height; 639 src_argb4444 = src_argb4444 + (height - 1) * src_stride_argb4444; 640 src_stride_argb4444 = -src_stride_argb4444; 641 } 642 // Coalesce rows. 643 if (src_stride_argb4444 == width * 2 && 644 dst_stride_argb == width * 4) { 645 width *= height; 646 height = 1; 647 src_stride_argb4444 = dst_stride_argb = 0; 648 } 649 #if defined(HAS_ARGB4444TOARGBROW_SSE2) 650 if (TestCpuFlag(kCpuHasSSE2) && width >= 8 && 651 IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) { 652 ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_SSE2; 653 if (IS_ALIGNED(width, 8)) { 654 ARGB4444ToARGBRow = ARGB4444ToARGBRow_SSE2; 655 } 656 } 657 #elif defined(HAS_ARGB4444TOARGBROW_NEON) 658 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 659 ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_NEON; 660 if (IS_ALIGNED(width, 8)) { 661 ARGB4444ToARGBRow = ARGB4444ToARGBRow_NEON; 662 } 663 } 664 #endif 665 666 for (y = 0; y < height; ++y) { 667 ARGB4444ToARGBRow(src_argb4444, dst_argb, width); 668 src_argb4444 += src_stride_argb4444; 669 dst_argb += dst_stride_argb; 670 } 671 return 0; 672 } 673 674 // Convert NV12 to ARGB. 675 LIBYUV_API 676 int NV12ToARGB(const uint8* src_y, int src_stride_y, 677 const uint8* src_uv, int src_stride_uv, 678 uint8* dst_argb, int dst_stride_argb, 679 int width, int height) { 680 int y; 681 void (*NV12ToARGBRow)(const uint8* y_buf, 682 const uint8* uv_buf, 683 uint8* rgb_buf, 684 int width) = NV12ToARGBRow_C; 685 if (!src_y || !src_uv || !dst_argb || 686 width <= 0 || height == 0) { 687 return -1; 688 } 689 // Negative height means invert the image. 690 if (height < 0) { 691 height = -height; 692 dst_argb = dst_argb + (height - 1) * dst_stride_argb; 693 dst_stride_argb = -dst_stride_argb; 694 } 695 #if defined(HAS_NV12TOARGBROW_SSSE3) 696 if (TestCpuFlag(kCpuHasSSSE3) && width >= 8) { 697 NV12ToARGBRow = NV12ToARGBRow_Any_SSSE3; 698 if (IS_ALIGNED(width, 8)) { 699 NV12ToARGBRow = NV12ToARGBRow_Unaligned_SSSE3; 700 if (IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) { 701 NV12ToARGBRow = NV12ToARGBRow_SSSE3; 702 } 703 } 704 } 705 #elif defined(HAS_NV12TOARGBROW_NEON) 706 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 707 NV12ToARGBRow = NV12ToARGBRow_Any_NEON; 708 if (IS_ALIGNED(width, 8)) { 709 NV12ToARGBRow = NV12ToARGBRow_NEON; 710 } 711 } 712 #endif 713 714 for (y = 0; y < height; ++y) { 715 NV12ToARGBRow(src_y, src_uv, dst_argb, width); 716 dst_argb += dst_stride_argb; 717 src_y += src_stride_y; 718 if (y & 1) { 719 src_uv += src_stride_uv; 720 } 721 } 722 return 0; 723 } 724 725 // Convert NV21 to ARGB. 726 LIBYUV_API 727 int NV21ToARGB(const uint8* src_y, int src_stride_y, 728 const uint8* src_uv, int src_stride_uv, 729 uint8* dst_argb, int dst_stride_argb, 730 int width, int height) { 731 int y; 732 void (*NV21ToARGBRow)(const uint8* y_buf, 733 const uint8* uv_buf, 734 uint8* rgb_buf, 735 int width) = NV21ToARGBRow_C; 736 if (!src_y || !src_uv || !dst_argb || 737 width <= 0 || height == 0) { 738 return -1; 739 } 740 // Negative height means invert the image. 741 if (height < 0) { 742 height = -height; 743 dst_argb = dst_argb + (height - 1) * dst_stride_argb; 744 dst_stride_argb = -dst_stride_argb; 745 } 746 #if defined(HAS_NV21TOARGBROW_SSSE3) 747 if (TestCpuFlag(kCpuHasSSSE3) && width >= 8) { 748 NV21ToARGBRow = NV21ToARGBRow_Any_SSSE3; 749 if (IS_ALIGNED(width, 8)) { 750 NV21ToARGBRow = NV21ToARGBRow_Unaligned_SSSE3; 751 if (IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) { 752 NV21ToARGBRow = NV21ToARGBRow_SSSE3; 753 } 754 } 755 } 756 #endif 757 #if defined(HAS_NV21TOARGBROW_NEON) 758 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 759 NV21ToARGBRow = NV21ToARGBRow_Any_NEON; 760 if (IS_ALIGNED(width, 8)) { 761 NV21ToARGBRow = NV21ToARGBRow_NEON; 762 } 763 } 764 #endif 765 766 for (y = 0; y < height; ++y) { 767 NV21ToARGBRow(src_y, src_uv, dst_argb, width); 768 dst_argb += dst_stride_argb; 769 src_y += src_stride_y; 770 if (y & 1) { 771 src_uv += src_stride_uv; 772 } 773 } 774 return 0; 775 } 776 777 // Convert M420 to ARGB. 778 LIBYUV_API 779 int M420ToARGB(const uint8* src_m420, int src_stride_m420, 780 uint8* dst_argb, int dst_stride_argb, 781 int width, int height) { 782 int y; 783 void (*NV12ToARGBRow)(const uint8* y_buf, 784 const uint8* uv_buf, 785 uint8* rgb_buf, 786 int width) = NV12ToARGBRow_C; 787 if (!src_m420 || !dst_argb || 788 width <= 0 || height == 0) { 789 return -1; 790 } 791 // Negative height means invert the image. 792 if (height < 0) { 793 height = -height; 794 dst_argb = dst_argb + (height - 1) * dst_stride_argb; 795 dst_stride_argb = -dst_stride_argb; 796 } 797 #if defined(HAS_NV12TOARGBROW_SSSE3) 798 if (TestCpuFlag(kCpuHasSSSE3) && width >= 8) { 799 NV12ToARGBRow = NV12ToARGBRow_Any_SSSE3; 800 if (IS_ALIGNED(width, 8)) { 801 NV12ToARGBRow = NV12ToARGBRow_Unaligned_SSSE3; 802 if (IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) { 803 NV12ToARGBRow = NV12ToARGBRow_SSSE3; 804 } 805 } 806 } 807 #elif defined(HAS_NV12TOARGBROW_NEON) 808 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 809 NV12ToARGBRow = NV12ToARGBRow_Any_NEON; 810 if (IS_ALIGNED(width, 8)) { 811 NV12ToARGBRow = NV12ToARGBRow_NEON; 812 } 813 } 814 #endif 815 816 for (y = 0; y < height - 1; y += 2) { 817 NV12ToARGBRow(src_m420, src_m420 + src_stride_m420 * 2, dst_argb, width); 818 NV12ToARGBRow(src_m420 + src_stride_m420, src_m420 + src_stride_m420 * 2, 819 dst_argb + dst_stride_argb, width); 820 dst_argb += dst_stride_argb * 2; 821 src_m420 += src_stride_m420 * 3; 822 } 823 if (height & 1) { 824 NV12ToARGBRow(src_m420, src_m420 + src_stride_m420 * 2, dst_argb, width); 825 } 826 return 0; 827 } 828 829 // Convert YUY2 to ARGB. 830 LIBYUV_API 831 int YUY2ToARGB(const uint8* src_yuy2, int src_stride_yuy2, 832 uint8* dst_argb, int dst_stride_argb, 833 int width, int height) { 834 int y; 835 void (*YUY2ToARGBRow)(const uint8* src_yuy2, uint8* dst_argb, int pix) = 836 YUY2ToARGBRow_C; 837 if (!src_yuy2 || !dst_argb || 838 width <= 0 || height == 0) { 839 return -1; 840 } 841 // Negative height means invert the image. 842 if (height < 0) { 843 height = -height; 844 src_yuy2 = src_yuy2 + (height - 1) * src_stride_yuy2; 845 src_stride_yuy2 = -src_stride_yuy2; 846 } 847 // Coalesce rows. 848 if (src_stride_yuy2 == width * 2 && 849 dst_stride_argb == width * 4) { 850 width *= height; 851 height = 1; 852 src_stride_yuy2 = dst_stride_argb = 0; 853 } 854 #if defined(HAS_YUY2TOARGBROW_SSSE3) 855 // Posix is 16, Windows is 8. 856 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) { 857 YUY2ToARGBRow = YUY2ToARGBRow_Any_SSSE3; 858 if (IS_ALIGNED(width, 16)) { 859 YUY2ToARGBRow = YUY2ToARGBRow_Unaligned_SSSE3; 860 if (IS_ALIGNED(src_yuy2, 16) && IS_ALIGNED(src_stride_yuy2, 16) && 861 IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) { 862 YUY2ToARGBRow = YUY2ToARGBRow_SSSE3; 863 } 864 } 865 } 866 #elif defined(HAS_YUY2TOARGBROW_NEON) 867 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 868 YUY2ToARGBRow = YUY2ToARGBRow_Any_NEON; 869 if (IS_ALIGNED(width, 8)) { 870 YUY2ToARGBRow = YUY2ToARGBRow_NEON; 871 } 872 } 873 #endif 874 for (y = 0; y < height; ++y) { 875 YUY2ToARGBRow(src_yuy2, dst_argb, width); 876 src_yuy2 += src_stride_yuy2; 877 dst_argb += dst_stride_argb; 878 } 879 return 0; 880 } 881 882 // Convert UYVY to ARGB. 883 LIBYUV_API 884 int UYVYToARGB(const uint8* src_uyvy, int src_stride_uyvy, 885 uint8* dst_argb, int dst_stride_argb, 886 int width, int height) { 887 int y; 888 void (*UYVYToARGBRow)(const uint8* src_uyvy, uint8* dst_argb, int pix) = 889 UYVYToARGBRow_C; 890 if (!src_uyvy || !dst_argb || 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_uyvy = src_uyvy + (height - 1) * src_stride_uyvy; 898 src_stride_uyvy = -src_stride_uyvy; 899 } 900 // Coalesce rows. 901 if (src_stride_uyvy == width * 2 && 902 dst_stride_argb == width * 4) { 903 width *= height; 904 height = 1; 905 src_stride_uyvy = dst_stride_argb = 0; 906 } 907 #if defined(HAS_UYVYTOARGBROW_SSSE3) 908 // Posix is 16, Windows is 8. 909 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) { 910 UYVYToARGBRow = UYVYToARGBRow_Any_SSSE3; 911 if (IS_ALIGNED(width, 16)) { 912 UYVYToARGBRow = UYVYToARGBRow_Unaligned_SSSE3; 913 if (IS_ALIGNED(src_uyvy, 16) && IS_ALIGNED(src_stride_uyvy, 16) && 914 IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) { 915 UYVYToARGBRow = UYVYToARGBRow_SSSE3; 916 } 917 } 918 } 919 #elif defined(HAS_UYVYTOARGBROW_NEON) 920 if (TestCpuFlag(kCpuHasNEON) && width >= 8) { 921 UYVYToARGBRow = UYVYToARGBRow_Any_NEON; 922 if (IS_ALIGNED(width, 8)) { 923 UYVYToARGBRow = UYVYToARGBRow_NEON; 924 } 925 } 926 #endif 927 for (y = 0; y < height; ++y) { 928 UYVYToARGBRow(src_uyvy, dst_argb, width); 929 src_uyvy += src_stride_uyvy; 930 dst_argb += dst_stride_argb; 931 } 932 return 0; 933 } 934 935 #ifdef __cplusplus 936 } // extern "C" 937 } // namespace libyuv 938 #endif 939
