Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(375)

Side by Side Diff: source/convert_from_argb.cc

Issue 1574253004: refactor ARGBToI422 using ARGBToI420 internally (Closed) Base URL: https://chromium.googlesource.com/libyuv/libyuv@master
Patch Set: Created 4 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « include/libyuv/version.h ('k') | source/row_any.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* 1 /*
2 * Copyright 2012 The LibYuv Project Authors. All rights reserved. 2 * Copyright 2012 The LibYuv Project Authors. All rights reserved.
3 * 3 *
4 * Use of this source code is governed by a BSD-style license 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 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 6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may 7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree. 8 * be found in the AUTHORS file in the root of the source tree.
9 */ 9 */
10 10
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after
102 } 102 }
103 103
104 // ARGB little endian (bgra in memory) to I422 104 // ARGB little endian (bgra in memory) to I422
105 LIBYUV_API 105 LIBYUV_API
106 int ARGBToI422(const uint8* src_argb, int src_stride_argb, 106 int ARGBToI422(const uint8* src_argb, int src_stride_argb,
107 uint8* dst_y, int dst_stride_y, 107 uint8* dst_y, int dst_stride_y,
108 uint8* dst_u, int dst_stride_u, 108 uint8* dst_u, int dst_stride_u,
109 uint8* dst_v, int dst_stride_v, 109 uint8* dst_v, int dst_stride_v,
110 int width, int height) { 110 int width, int height) {
111 int y; 111 int y;
112 void (*ARGBToUV422Row)(const uint8* src_argb, uint8* dst_u, uint8* dst_v, 112 void (*ARGBToUVRow)(const uint8* src_argb0, int src_stride_argb,
113 int width) = ARGBToUV422Row_C; 113 uint8* dst_u, uint8* dst_v, int width) = ARGBToUVRow_C;
114 void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int width) = 114 void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int width) =
115 ARGBToYRow_C; 115 ARGBToYRow_C;
116 if (!src_argb || !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) { 116 if (!src_argb ||
117 !dst_y || !dst_u || !dst_v ||
118 width <= 0 || height == 0) {
117 return -1; 119 return -1;
118 } 120 }
121 // Negative height means invert the image.
119 if (height < 0) { 122 if (height < 0) {
120 height = -height; 123 height = -height;
121 src_argb = src_argb + (height - 1) * src_stride_argb; 124 src_argb = src_argb + (height - 1) * src_stride_argb;
122 src_stride_argb = -src_stride_argb; 125 src_stride_argb = -src_stride_argb;
123 } 126 }
124 // Coalesce rows. 127 // Coalesce rows.
125 if (src_stride_argb == width * 4 && 128 if (src_stride_argb == width * 4 &&
126 dst_stride_y == width && 129 dst_stride_y == width &&
127 dst_stride_u * 2 == width && 130 dst_stride_u * 2 == width &&
128 dst_stride_v * 2 == width) { 131 dst_stride_v * 2 == width) {
129 width *= height; 132 width *= height;
130 height = 1; 133 height = 1;
131 src_stride_argb = dst_stride_y = dst_stride_u = dst_stride_v = 0; 134 src_stride_argb = dst_stride_y = dst_stride_u = dst_stride_v = 0;
132 } 135 }
133 #if defined(HAS_ARGBTOUV422ROW_SSSE3) 136 #if defined(HAS_ARGBTOYROW_SSSE3) && defined(HAS_ARGBTOUVROW_SSSE3)
134 if (TestCpuFlag(kCpuHasSSSE3)) { 137 if (TestCpuFlag(kCpuHasSSSE3)) {
135 ARGBToUV422Row = ARGBToUV422Row_Any_SSSE3; 138 ARGBToUVRow = ARGBToUVRow_Any_SSSE3;
136 if (IS_ALIGNED(width, 16)) {
137 ARGBToUV422Row = ARGBToUV422Row_SSSE3;
138 }
139 }
140 #endif
141 #if defined(HAS_ARGBTOUV422ROW_NEON)
142 if (TestCpuFlag(kCpuHasNEON)) {
143 ARGBToUV422Row = ARGBToUV422Row_Any_NEON;
144 if (IS_ALIGNED(width, 16)) {
145 ARGBToUV422Row = ARGBToUV422Row_NEON;
146 }
147 }
148 #endif
149 #if defined(HAS_ARGBTOYROW_SSSE3)
150 if (TestCpuFlag(kCpuHasSSSE3)) {
151 ARGBToYRow = ARGBToYRow_Any_SSSE3; 139 ARGBToYRow = ARGBToYRow_Any_SSSE3;
152 if (IS_ALIGNED(width, 16)) { 140 if (IS_ALIGNED(width, 16)) {
141 ARGBToUVRow = ARGBToUVRow_SSSE3;
153 ARGBToYRow = ARGBToYRow_SSSE3; 142 ARGBToYRow = ARGBToYRow_SSSE3;
154 } 143 }
155 } 144 }
156 #endif 145 #endif
157 #if defined(HAS_ARGBTOYROW_AVX2) 146 #if defined(HAS_ARGBTOYROW_AVX2) && defined(HAS_ARGBTOUVROW_AVX2)
158 if (TestCpuFlag(kCpuHasAVX2)) { 147 if (TestCpuFlag(kCpuHasAVX2)) {
148 ARGBToUVRow = ARGBToUVRow_Any_AVX2;
159 ARGBToYRow = ARGBToYRow_Any_AVX2; 149 ARGBToYRow = ARGBToYRow_Any_AVX2;
160 if (IS_ALIGNED(width, 32)) { 150 if (IS_ALIGNED(width, 32)) {
151 ARGBToUVRow = ARGBToUVRow_AVX2;
161 ARGBToYRow = ARGBToYRow_AVX2; 152 ARGBToYRow = ARGBToYRow_AVX2;
162 } 153 }
163 } 154 }
164 #endif 155 #endif
165 #if defined(HAS_ARGBTOYROW_NEON) 156 #if defined(HAS_ARGBTOYROW_NEON)
166 if (TestCpuFlag(kCpuHasNEON)) { 157 if (TestCpuFlag(kCpuHasNEON)) {
167 ARGBToYRow = ARGBToYRow_Any_NEON; 158 ARGBToYRow = ARGBToYRow_Any_NEON;
168 if (IS_ALIGNED(width, 8)) { 159 if (IS_ALIGNED(width, 8)) {
169 ARGBToYRow = ARGBToYRow_NEON; 160 ARGBToYRow = ARGBToYRow_NEON;
170 } 161 }
171 } 162 }
172 #endif 163 #endif
164 #if defined(HAS_ARGBTOUVROW_NEON)
165 if (TestCpuFlag(kCpuHasNEON)) {
166 ARGBToUVRow = ARGBToUVRow_Any_NEON;
167 if (IS_ALIGNED(width, 16)) {
168 ARGBToUVRow = ARGBToUVRow_NEON;
169 }
170 }
171 #endif
173 172
174 for (y = 0; y < height; ++y) { 173 for (y = 0; y < height; ++y) {
175 ARGBToUV422Row(src_argb, dst_u, dst_v, width); 174 ARGBToUVRow(src_argb, 0, dst_u, dst_v, width);
176 ARGBToYRow(src_argb, dst_y, width); 175 ARGBToYRow(src_argb, dst_y, width);
177 src_argb += src_stride_argb; 176 src_argb += src_stride_argb;
178 dst_y += dst_stride_y; 177 dst_y += dst_stride_y;
179 dst_u += dst_stride_u; 178 dst_u += dst_stride_u;
180 dst_v += dst_stride_v; 179 dst_v += dst_stride_v;
181 } 180 }
182 return 0; 181 return 0;
183 } 182 }
184 183
185 // ARGB little endian (bgra in memory) to I411 184 // ARGB little endian (bgra in memory) to I411
(...skipping 285 matching lines...) Expand 10 before | Expand all | Expand 10 after
471 } 470 }
472 return 0; 471 return 0;
473 } 472 }
474 473
475 // Convert ARGB to YUY2. 474 // Convert ARGB to YUY2.
476 LIBYUV_API 475 LIBYUV_API
477 int ARGBToYUY2(const uint8* src_argb, int src_stride_argb, 476 int ARGBToYUY2(const uint8* src_argb, int src_stride_argb,
478 uint8* dst_yuy2, int dst_stride_yuy2, 477 uint8* dst_yuy2, int dst_stride_yuy2,
479 int width, int height) { 478 int width, int height) {
480 int y; 479 int y;
481 void (*ARGBToUV422Row)(const uint8* src_argb, uint8* dst_u, uint8* dst_v, 480 void (*ARGBToUVRow)(const uint8* src_argb, int src_stride_argb,
482 int width) = ARGBToUV422Row_C; 481 uint8* dst_u, uint8* dst_v, int width) = ARGBToUVRow_C;
483 void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int width) = 482 void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int width) =
484 ARGBToYRow_C; 483 ARGBToYRow_C;
485 void (*I422ToYUY2Row)(const uint8* src_y, const uint8* src_u, 484 void (*I422ToYUY2Row)(const uint8* src_y, const uint8* src_u,
486 const uint8* src_v, uint8* dst_yuy2, int width) = I422ToYUY2Row_C; 485 const uint8* src_v, uint8* dst_yuy2, int width) = I422ToYUY2Row_C;
487 486
488 if (!src_argb || !dst_yuy2 || 487 if (!src_argb || !dst_yuy2 ||
489 width <= 0 || height == 0) { 488 width <= 0 || height == 0) {
490 return -1; 489 return -1;
491 } 490 }
492 // Negative height means invert the image. 491 // Negative height means invert the image.
493 if (height < 0) { 492 if (height < 0) {
494 height = -height; 493 height = -height;
495 dst_yuy2 = dst_yuy2 + (height - 1) * dst_stride_yuy2; 494 dst_yuy2 = dst_yuy2 + (height - 1) * dst_stride_yuy2;
496 dst_stride_yuy2 = -dst_stride_yuy2; 495 dst_stride_yuy2 = -dst_stride_yuy2;
497 } 496 }
498 // Coalesce rows. 497 // Coalesce rows.
499 if (src_stride_argb == width * 4 && 498 if (src_stride_argb == width * 4 &&
500 dst_stride_yuy2 == width * 2) { 499 dst_stride_yuy2 == width * 2) {
501 width *= height; 500 width *= height;
502 height = 1; 501 height = 1;
503 src_stride_argb = dst_stride_yuy2 = 0; 502 src_stride_argb = dst_stride_yuy2 = 0;
504 } 503 }
505 #if defined(HAS_ARGBTOUV422ROW_SSSE3) 504 #if defined(HAS_ARGBTOYROW_SSSE3) && defined(HAS_ARGBTOUVROW_SSSE3)
506 if (TestCpuFlag(kCpuHasSSSE3)) { 505 if (TestCpuFlag(kCpuHasSSSE3)) {
507 ARGBToUV422Row = ARGBToUV422Row_Any_SSSE3; 506 ARGBToUVRow = ARGBToUVRow_Any_SSSE3;
508 if (IS_ALIGNED(width, 16)) {
509 ARGBToUV422Row = ARGBToUV422Row_SSSE3;
510 }
511 }
512 #endif
513 #if defined(HAS_ARGBTOUV422ROW_NEON)
514 if (TestCpuFlag(kCpuHasNEON)) {
515 ARGBToUV422Row = ARGBToUV422Row_Any_NEON;
516 if (IS_ALIGNED(width, 16)) {
517 ARGBToUV422Row = ARGBToUV422Row_NEON;
518 }
519 }
520 #endif
521 #if defined(HAS_ARGBTOYROW_SSSE3)
522 if (TestCpuFlag(kCpuHasSSSE3)) {
523 ARGBToYRow = ARGBToYRow_Any_SSSE3; 507 ARGBToYRow = ARGBToYRow_Any_SSSE3;
524 if (IS_ALIGNED(width, 16)) { 508 if (IS_ALIGNED(width, 16)) {
509 ARGBToUVRow = ARGBToUVRow_SSSE3;
525 ARGBToYRow = ARGBToYRow_SSSE3; 510 ARGBToYRow = ARGBToYRow_SSSE3;
526 } 511 }
527 } 512 }
528 #endif 513 #endif
529 #if defined(HAS_ARGBTOYROW_AVX2) 514 #if defined(HAS_ARGBTOYROW_AVX2) && defined(HAS_ARGBTOUVROW_AVX2)
530 if (TestCpuFlag(kCpuHasAVX2)) { 515 if (TestCpuFlag(kCpuHasAVX2)) {
516 ARGBToUVRow = ARGBToUVRow_Any_AVX2;
531 ARGBToYRow = ARGBToYRow_Any_AVX2; 517 ARGBToYRow = ARGBToYRow_Any_AVX2;
532 if (IS_ALIGNED(width, 32)) { 518 if (IS_ALIGNED(width, 32)) {
519 ARGBToUVRow = ARGBToUVRow_AVX2;
533 ARGBToYRow = ARGBToYRow_AVX2; 520 ARGBToYRow = ARGBToYRow_AVX2;
534 } 521 }
535 } 522 }
536 #endif 523 #endif
537 #if defined(HAS_ARGBTOYROW_NEON) 524 #if defined(HAS_ARGBTOYROW_NEON)
538 if (TestCpuFlag(kCpuHasNEON)) { 525 if (TestCpuFlag(kCpuHasNEON)) {
539 ARGBToYRow = ARGBToYRow_Any_NEON; 526 ARGBToYRow = ARGBToYRow_Any_NEON;
540 if (IS_ALIGNED(width, 8)) { 527 if (IS_ALIGNED(width, 8)) {
541 ARGBToYRow = ARGBToYRow_NEON; 528 ARGBToYRow = ARGBToYRow_NEON;
542 } 529 }
543 } 530 }
544 #endif 531 #endif
545 532 #if defined(HAS_ARGBTOUVROW_NEON)
533 if (TestCpuFlag(kCpuHasNEON)) {
534 ARGBToUVRow = ARGBToUVRow_Any_NEON;
535 if (IS_ALIGNED(width, 16)) {
536 ARGBToUVRow = ARGBToUVRow_NEON;
537 }
538 }
539 #endif
546 #if defined(HAS_I422TOYUY2ROW_SSE2) 540 #if defined(HAS_I422TOYUY2ROW_SSE2)
547 if (TestCpuFlag(kCpuHasSSE2)) { 541 if (TestCpuFlag(kCpuHasSSE2)) {
548 I422ToYUY2Row = I422ToYUY2Row_Any_SSE2; 542 I422ToYUY2Row = I422ToYUY2Row_Any_SSE2;
549 if (IS_ALIGNED(width, 16)) { 543 if (IS_ALIGNED(width, 16)) {
550 I422ToYUY2Row = I422ToYUY2Row_SSE2; 544 I422ToYUY2Row = I422ToYUY2Row_SSE2;
551 } 545 }
552 } 546 }
553 #endif 547 #endif
554 #if defined(HAS_I422TOYUY2ROW_NEON) 548 #if defined(HAS_I422TOYUY2ROW_NEON)
555 if (TestCpuFlag(kCpuHasNEON)) { 549 if (TestCpuFlag(kCpuHasNEON)) {
556 I422ToYUY2Row = I422ToYUY2Row_Any_NEON; 550 I422ToYUY2Row = I422ToYUY2Row_Any_NEON;
557 if (IS_ALIGNED(width, 16)) { 551 if (IS_ALIGNED(width, 16)) {
558 I422ToYUY2Row = I422ToYUY2Row_NEON; 552 I422ToYUY2Row = I422ToYUY2Row_NEON;
559 } 553 }
560 } 554 }
561 #endif 555 #endif
562 556
563 { 557 {
564 // Allocate a rows of yuv. 558 // Allocate a rows of yuv.
565 align_buffer_64(row_y, ((width + 63) & ~63) * 2); 559 align_buffer_64(row_y, ((width + 63) & ~63) * 2);
566 uint8* row_u = row_y + ((width + 63) & ~63); 560 uint8* row_u = row_y + ((width + 63) & ~63);
567 uint8* row_v = row_u + ((width + 63) & ~63) / 2; 561 uint8* row_v = row_u + ((width + 63) & ~63) / 2;
568 562
569 for (y = 0; y < height; ++y) { 563 for (y = 0; y < height; ++y) {
570 ARGBToUV422Row(src_argb, row_u, row_v, width); 564 ARGBToUVRow(src_argb, 0, row_u, row_v, width);
571 ARGBToYRow(src_argb, row_y, width); 565 ARGBToYRow(src_argb, row_y, width);
572 I422ToYUY2Row(row_y, row_u, row_v, dst_yuy2, width); 566 I422ToYUY2Row(row_y, row_u, row_v, dst_yuy2, width);
573 src_argb += src_stride_argb; 567 src_argb += src_stride_argb;
574 dst_yuy2 += dst_stride_yuy2; 568 dst_yuy2 += dst_stride_yuy2;
575 } 569 }
576 570
577 free_aligned_buffer_64(row_y); 571 free_aligned_buffer_64(row_y);
578 } 572 }
579 return 0; 573 return 0;
580 } 574 }
581 575
582 // Convert ARGB to UYVY. 576 // Convert ARGB to UYVY.
583 LIBYUV_API 577 LIBYUV_API
584 int ARGBToUYVY(const uint8* src_argb, int src_stride_argb, 578 int ARGBToUYVY(const uint8* src_argb, int src_stride_argb,
585 uint8* dst_uyvy, int dst_stride_uyvy, 579 uint8* dst_uyvy, int dst_stride_uyvy,
586 int width, int height) { 580 int width, int height) {
587 int y; 581 int y;
588 void (*ARGBToUV422Row)(const uint8* src_argb, uint8* dst_u, uint8* dst_v, 582 void (*ARGBToUVRow)(const uint8* src_argb, int src_stride_argb,
589 int width) = ARGBToUV422Row_C; 583 uint8* dst_u, uint8* dst_v, int width) = ARGBToUVRow_C;
590 void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int width) = 584 void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int width) =
591 ARGBToYRow_C; 585 ARGBToYRow_C;
592 void (*I422ToUYVYRow)(const uint8* src_y, const uint8* src_u, 586 void (*I422ToUYVYRow)(const uint8* src_y, const uint8* src_u,
593 const uint8* src_v, uint8* dst_uyvy, int width) = I422ToUYVYRow_C; 587 const uint8* src_v, uint8* dst_uyvy, int width) = I422ToUYVYRow_C;
594 588
595 if (!src_argb || !dst_uyvy || 589 if (!src_argb || !dst_uyvy ||
596 width <= 0 || height == 0) { 590 width <= 0 || height == 0) {
597 return -1; 591 return -1;
598 } 592 }
599 // Negative height means invert the image. 593 // Negative height means invert the image.
600 if (height < 0) { 594 if (height < 0) {
601 height = -height; 595 height = -height;
602 dst_uyvy = dst_uyvy + (height - 1) * dst_stride_uyvy; 596 dst_uyvy = dst_uyvy + (height - 1) * dst_stride_uyvy;
603 dst_stride_uyvy = -dst_stride_uyvy; 597 dst_stride_uyvy = -dst_stride_uyvy;
604 } 598 }
605 // Coalesce rows. 599 // Coalesce rows.
606 if (src_stride_argb == width * 4 && 600 if (src_stride_argb == width * 4 &&
607 dst_stride_uyvy == width * 2) { 601 dst_stride_uyvy == width * 2) {
608 width *= height; 602 width *= height;
609 height = 1; 603 height = 1;
610 src_stride_argb = dst_stride_uyvy = 0; 604 src_stride_argb = dst_stride_uyvy = 0;
611 } 605 }
612 #if defined(HAS_ARGBTOUV422ROW_SSSE3) 606 #if defined(HAS_ARGBTOYROW_SSSE3) && defined(HAS_ARGBTOUVROW_SSSE3)
613 if (TestCpuFlag(kCpuHasSSSE3)) { 607 if (TestCpuFlag(kCpuHasSSSE3)) {
614 ARGBToUV422Row = ARGBToUV422Row_Any_SSSE3; 608 ARGBToUVRow = ARGBToUVRow_Any_SSSE3;
615 if (IS_ALIGNED(width, 16)) {
616 ARGBToUV422Row = ARGBToUV422Row_SSSE3;
617 }
618 }
619 #endif
620 #if defined(HAS_ARGBTOUV422ROW_NEON)
621 if (TestCpuFlag(kCpuHasNEON)) {
622 ARGBToUV422Row = ARGBToUV422Row_Any_NEON;
623 if (IS_ALIGNED(width, 16)) {
624 ARGBToUV422Row = ARGBToUV422Row_NEON;
625 }
626 }
627 #endif
628 #if defined(HAS_ARGBTOYROW_SSSE3)
629 if (TestCpuFlag(kCpuHasSSSE3)) {
630 ARGBToYRow = ARGBToYRow_Any_SSSE3; 609 ARGBToYRow = ARGBToYRow_Any_SSSE3;
631 if (IS_ALIGNED(width, 16)) { 610 if (IS_ALIGNED(width, 16)) {
611 ARGBToUVRow = ARGBToUVRow_SSSE3;
632 ARGBToYRow = ARGBToYRow_SSSE3; 612 ARGBToYRow = ARGBToYRow_SSSE3;
633 } 613 }
634 } 614 }
635 #endif 615 #endif
636 #if defined(HAS_ARGBTOYROW_AVX2) 616 #if defined(HAS_ARGBTOYROW_AVX2) && defined(HAS_ARGBTOUVROW_AVX2)
637 if (TestCpuFlag(kCpuHasAVX2)) { 617 if (TestCpuFlag(kCpuHasAVX2)) {
618 ARGBToUVRow = ARGBToUVRow_Any_AVX2;
638 ARGBToYRow = ARGBToYRow_Any_AVX2; 619 ARGBToYRow = ARGBToYRow_Any_AVX2;
639 if (IS_ALIGNED(width, 32)) { 620 if (IS_ALIGNED(width, 32)) {
621 ARGBToUVRow = ARGBToUVRow_AVX2;
640 ARGBToYRow = ARGBToYRow_AVX2; 622 ARGBToYRow = ARGBToYRow_AVX2;
641 } 623 }
642 } 624 }
643 #endif 625 #endif
644 #if defined(HAS_ARGBTOYROW_NEON) 626 #if defined(HAS_ARGBTOYROW_NEON)
645 if (TestCpuFlag(kCpuHasNEON)) { 627 if (TestCpuFlag(kCpuHasNEON)) {
646 ARGBToYRow = ARGBToYRow_Any_NEON; 628 ARGBToYRow = ARGBToYRow_Any_NEON;
647 if (IS_ALIGNED(width, 8)) { 629 if (IS_ALIGNED(width, 8)) {
648 ARGBToYRow = ARGBToYRow_NEON; 630 ARGBToYRow = ARGBToYRow_NEON;
649 } 631 }
650 } 632 }
651 #endif 633 #endif
652 634 #if defined(HAS_ARGBTOUVROW_NEON)
635 if (TestCpuFlag(kCpuHasNEON)) {
636 ARGBToUVRow = ARGBToUVRow_Any_NEON;
637 if (IS_ALIGNED(width, 16)) {
638 ARGBToUVRow = ARGBToUVRow_NEON;
639 }
640 }
641 #endif
653 #if defined(HAS_I422TOUYVYROW_SSE2) 642 #if defined(HAS_I422TOUYVYROW_SSE2)
654 if (TestCpuFlag(kCpuHasSSE2)) { 643 if (TestCpuFlag(kCpuHasSSE2)) {
655 I422ToUYVYRow = I422ToUYVYRow_Any_SSE2; 644 I422ToUYVYRow = I422ToUYVYRow_Any_SSE2;
656 if (IS_ALIGNED(width, 16)) { 645 if (IS_ALIGNED(width, 16)) {
657 I422ToUYVYRow = I422ToUYVYRow_SSE2; 646 I422ToUYVYRow = I422ToUYVYRow_SSE2;
658 } 647 }
659 } 648 }
660 #endif 649 #endif
661 #if defined(HAS_I422TOUYVYROW_NEON) 650 #if defined(HAS_I422TOUYVYROW_NEON)
662 if (TestCpuFlag(kCpuHasNEON)) { 651 if (TestCpuFlag(kCpuHasNEON)) {
663 I422ToUYVYRow = I422ToUYVYRow_Any_NEON; 652 I422ToUYVYRow = I422ToUYVYRow_Any_NEON;
664 if (IS_ALIGNED(width, 16)) { 653 if (IS_ALIGNED(width, 16)) {
665 I422ToUYVYRow = I422ToUYVYRow_NEON; 654 I422ToUYVYRow = I422ToUYVYRow_NEON;
666 } 655 }
667 } 656 }
668 #endif 657 #endif
669 658
670 { 659 {
671 // Allocate a rows of yuv. 660 // Allocate a rows of yuv.
672 align_buffer_64(row_y, ((width + 63) & ~63) * 2); 661 align_buffer_64(row_y, ((width + 63) & ~63) * 2);
673 uint8* row_u = row_y + ((width + 63) & ~63); 662 uint8* row_u = row_y + ((width + 63) & ~63);
674 uint8* row_v = row_u + ((width + 63) & ~63) / 2; 663 uint8* row_v = row_u + ((width + 63) & ~63) / 2;
675 664
676 for (y = 0; y < height; ++y) { 665 for (y = 0; y < height; ++y) {
677 ARGBToUV422Row(src_argb, row_u, row_v, width); 666 ARGBToUVRow(src_argb, 0, row_u, row_v, width);
678 ARGBToYRow(src_argb, row_y, width); 667 ARGBToYRow(src_argb, row_y, width);
679 I422ToUYVYRow(row_y, row_u, row_v, dst_uyvy, width); 668 I422ToUYVYRow(row_y, row_u, row_v, dst_uyvy, width);
680 src_argb += src_stride_argb; 669 src_argb += src_stride_argb;
681 dst_uyvy += dst_stride_uyvy; 670 dst_uyvy += dst_stride_uyvy;
682 } 671 }
683 672
684 free_aligned_buffer_64(row_y); 673 free_aligned_buffer_64(row_y);
685 } 674 }
686 return 0; 675 return 0;
687 } 676 }
(...skipping 462 matching lines...) Expand 10 before | Expand all | Expand 10 after
1150 dst_u += dst_stride_u; 1139 dst_u += dst_stride_u;
1151 dst_v += dst_stride_v; 1140 dst_v += dst_stride_v;
1152 } 1141 }
1153 if (height & 1) { 1142 if (height & 1) {
1154 ARGBToUVJRow(src_argb, 0, dst_u, dst_v, width); 1143 ARGBToUVJRow(src_argb, 0, dst_u, dst_v, width);
1155 ARGBToYJRow(src_argb, dst_yj, width); 1144 ARGBToYJRow(src_argb, dst_yj, width);
1156 } 1145 }
1157 return 0; 1146 return 0;
1158 } 1147 }
1159 1148
1160 // ARGB little endian (bgra in memory) to J422 1149 // Convert ARGB to J422. (JPeg full range I422).
1161 LIBYUV_API 1150 LIBYUV_API
1162 int ARGBToJ422(const uint8* src_argb, int src_stride_argb, 1151 int ARGBToJ422(const uint8* src_argb, int src_stride_argb,
1163 uint8* dst_y, int dst_stride_y, 1152 uint8* dst_yj, int dst_stride_yj,
1164 uint8* dst_u, int dst_stride_u, 1153 uint8* dst_u, int dst_stride_u,
1165 uint8* dst_v, int dst_stride_v, 1154 uint8* dst_v, int dst_stride_v,
1166 int width, int height) { 1155 int width, int height) {
1167 int y; 1156 int y;
1168 void (*ARGBToUVJ422Row)(const uint8* src_argb, uint8* dst_u, uint8* dst_v, 1157 void (*ARGBToUVJRow)(const uint8* src_argb0, int src_stride_argb,
1169 int width) = ARGBToUVJ422Row_C; 1158 uint8* dst_u, uint8* dst_v, int width) = ARGBToUVJRow_C;
1170 void (*ARGBToYJRow)(const uint8* src_argb, uint8* dst_y, int width) = 1159 void (*ARGBToYJRow)(const uint8* src_argb, uint8* dst_yj, int width) =
1171 ARGBToYJRow_C; 1160 ARGBToYJRow_C;
1172 if (!src_argb || !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) { 1161 if (!src_argb ||
1162 !dst_yj || !dst_u || !dst_v ||
1163 width <= 0 || height == 0) {
1173 return -1; 1164 return -1;
1174 } 1165 }
1166 // Negative height means invert the image.
1175 if (height < 0) { 1167 if (height < 0) {
1176 height = -height; 1168 height = -height;
1177 src_argb = src_argb + (height - 1) * src_stride_argb; 1169 src_argb = src_argb + (height - 1) * src_stride_argb;
1178 src_stride_argb = -src_stride_argb; 1170 src_stride_argb = -src_stride_argb;
1179 } 1171 }
1180 // Coalesce rows. 1172 // Coalesce rows.
1181 if (src_stride_argb == width * 4 && 1173 if (src_stride_argb == width * 4 &&
1182 dst_stride_y == width && 1174 dst_stride_yj == width &&
1183 dst_stride_u * 2 == width && 1175 dst_stride_u * 2 == width &&
1184 dst_stride_v * 2 == width) { 1176 dst_stride_v * 2 == width) {
1185 width *= height; 1177 width *= height;
1186 height = 1; 1178 height = 1;
1187 src_stride_argb = dst_stride_y = dst_stride_u = dst_stride_v = 0; 1179 src_stride_argb = dst_stride_yj = dst_stride_u = dst_stride_v = 0;
1188 } 1180 }
1189 #if defined(HAS_ARGBTOUVJ422ROW_SSSE3) 1181 #if defined(HAS_ARGBTOYJROW_SSSE3) && defined(HAS_ARGBTOUVJROW_SSSE3)
1190 if (TestCpuFlag(kCpuHasSSSE3)) { 1182 if (TestCpuFlag(kCpuHasSSSE3)) {
1191 ARGBToUVJ422Row = ARGBToUVJ422Row_Any_SSSE3; 1183 ARGBToUVJRow = ARGBToUVJRow_Any_SSSE3;
1192 if (IS_ALIGNED(width, 16)) {
1193 ARGBToUVJ422Row = ARGBToUVJ422Row_SSSE3;
1194 }
1195 }
1196 #endif
1197 #if defined(HAS_ARGBTOUVJ422ROW_NEON)
1198 if (TestCpuFlag(kCpuHasNEON)) {
1199 ARGBToUVJ422Row = ARGBToUVJ422Row_Any_NEON;
1200 if (IS_ALIGNED(width, 16)) {
1201 ARGBToUVJ422Row = ARGBToUVJ422Row_NEON;
1202 }
1203 }
1204 #endif
1205
1206 #if defined(HAS_ARGBTOYJROW_SSSE3)
1207 if (TestCpuFlag(kCpuHasSSSE3)) {
1208 ARGBToYJRow = ARGBToYJRow_Any_SSSE3; 1184 ARGBToYJRow = ARGBToYJRow_Any_SSSE3;
1209 if (IS_ALIGNED(width, 16)) { 1185 if (IS_ALIGNED(width, 16)) {
1186 ARGBToUVJRow = ARGBToUVJRow_SSSE3;
1210 ARGBToYJRow = ARGBToYJRow_SSSE3; 1187 ARGBToYJRow = ARGBToYJRow_SSSE3;
1211 } 1188 }
1212 } 1189 }
1213 #endif 1190 #endif
1214 #if defined(HAS_ARGBTOYJROW_AVX2) 1191 #if defined(HAS_ARGBTOYJROW_AVX2)
1215 if (TestCpuFlag(kCpuHasAVX2)) { 1192 if (TestCpuFlag(kCpuHasAVX2)) {
1216 ARGBToYJRow = ARGBToYJRow_Any_AVX2; 1193 ARGBToYJRow = ARGBToYJRow_Any_AVX2;
1217 if (IS_ALIGNED(width, 32)) { 1194 if (IS_ALIGNED(width, 32)) {
1218 ARGBToYJRow = ARGBToYJRow_AVX2; 1195 ARGBToYJRow = ARGBToYJRow_AVX2;
1219 } 1196 }
1220 } 1197 }
1221 #endif 1198 #endif
1222 #if defined(HAS_ARGBTOYJROW_NEON) 1199 #if defined(HAS_ARGBTOYJROW_NEON)
1223 if (TestCpuFlag(kCpuHasNEON)) { 1200 if (TestCpuFlag(kCpuHasNEON)) {
1224 ARGBToYJRow = ARGBToYJRow_Any_NEON; 1201 ARGBToYJRow = ARGBToYJRow_Any_NEON;
1225 if (IS_ALIGNED(width, 8)) { 1202 if (IS_ALIGNED(width, 8)) {
1226 ARGBToYJRow = ARGBToYJRow_NEON; 1203 ARGBToYJRow = ARGBToYJRow_NEON;
1227 } 1204 }
1228 } 1205 }
1229 #endif 1206 #endif
1207 #if defined(HAS_ARGBTOUVJROW_NEON)
1208 if (TestCpuFlag(kCpuHasNEON)) {
1209 ARGBToUVJRow = ARGBToUVJRow_Any_NEON;
1210 if (IS_ALIGNED(width, 16)) {
1211 ARGBToUVJRow = ARGBToUVJRow_NEON;
1212 }
1213 }
1214 #endif
1230 1215
1231 for (y = 0; y < height; ++y) { 1216 for (y = 0; y < height; ++y) {
1232 ARGBToUVJ422Row(src_argb, dst_u, dst_v, width); 1217 ARGBToUVJRow(src_argb, 0, dst_u, dst_v, width);
1233 ARGBToYJRow(src_argb, dst_y, width); 1218 ARGBToYJRow(src_argb, dst_yj, width);
1234 src_argb += src_stride_argb; 1219 src_argb += src_stride_argb;
1235 dst_y += dst_stride_y; 1220 dst_yj += dst_stride_yj;
1236 dst_u += dst_stride_u; 1221 dst_u += dst_stride_u;
1237 dst_v += dst_stride_v; 1222 dst_v += dst_stride_v;
1238 } 1223 }
1239 return 0; 1224 return 0;
1240 } 1225 }
1241 1226
1242 // Convert ARGB to J400. 1227 // Convert ARGB to J400.
1243 LIBYUV_API 1228 LIBYUV_API
1244 int ARGBToJ400(const uint8* src_argb, int src_stride_argb, 1229 int ARGBToJ400(const uint8* src_argb, int src_stride_argb,
1245 uint8* dst_yj, int dst_stride_yj, 1230 uint8* dst_yj, int dst_stride_yj,
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after
1292 src_argb += src_stride_argb; 1277 src_argb += src_stride_argb;
1293 dst_yj += dst_stride_yj; 1278 dst_yj += dst_stride_yj;
1294 } 1279 }
1295 return 0; 1280 return 0;
1296 } 1281 }
1297 1282
1298 #ifdef __cplusplus 1283 #ifdef __cplusplus
1299 } // extern "C" 1284 } // extern "C"
1300 } // namespace libyuv 1285 } // namespace libyuv
1301 #endif 1286 #endif
OLDNEW
« no previous file with comments | « include/libyuv/version.h ('k') | source/row_any.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698