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/planar_functions.h"
12
13 #include <string.h> // for memset()
14
15 #include "libyuv/cpu_id.h"
16 #ifdef HAVE_JPEG
17 #include "libyuv/mjpeg_decoder.h"
18 #endif
19 #include "libyuv/row.h"
20
21 #ifdef __cplusplus
22 namespace libyuv {
23 extern "C" {
24 #endif
25
26 // Copy a plane of data
27 LIBYUV_API
CopyPlane(const uint8 * src_y,int src_stride_y,uint8 * dst_y,int dst_stride_y,int width,int height)28 void CopyPlane(const uint8* src_y, int src_stride_y,
29 uint8* dst_y, int dst_stride_y,
30 int width, int height) {
31 int y;
32 void (*CopyRow)(const uint8* src, uint8* dst, int width) = CopyRow_C;
33 // Coalesce rows.
34 if (src_stride_y == width &&
35 dst_stride_y == width) {
36 width *= height;
37 height = 1;
38 src_stride_y = dst_stride_y = 0;
39 }
40 // Nothing to do.
41 if (src_y == dst_y && src_stride_y == dst_stride_y) {
42 return;
43 }
44 #if defined(HAS_COPYROW_SSE2)
45 if (TestCpuFlag(kCpuHasSSE2)) {
46 CopyRow = IS_ALIGNED(width, 32) ? CopyRow_SSE2 : CopyRow_Any_SSE2;
47 }
48 #endif
49 #if defined(HAS_COPYROW_AVX)
50 if (TestCpuFlag(kCpuHasAVX)) {
51 CopyRow = IS_ALIGNED(width, 64) ? CopyRow_AVX : CopyRow_Any_AVX;
52 }
53 #endif
54 #if defined(HAS_COPYROW_ERMS)
55 if (TestCpuFlag(kCpuHasERMS)) {
56 CopyRow = CopyRow_ERMS;
57 }
58 #endif
59 #if defined(HAS_COPYROW_NEON)
60 if (TestCpuFlag(kCpuHasNEON)) {
61 CopyRow = IS_ALIGNED(width, 32) ? CopyRow_NEON : CopyRow_Any_NEON;
62 }
63 #endif
64 #if defined(HAS_COPYROW_MIPS)
65 if (TestCpuFlag(kCpuHasMIPS)) {
66 CopyRow = CopyRow_MIPS;
67 }
68 #endif
69
70 // Copy plane
71 for (y = 0; y < height; ++y) {
72 CopyRow(src_y, dst_y, width);
73 src_y += src_stride_y;
74 dst_y += dst_stride_y;
75 }
76 }
77
78 LIBYUV_API
CopyPlane_16(const uint16 * src_y,int src_stride_y,uint16 * dst_y,int dst_stride_y,int width,int height)79 void CopyPlane_16(const uint16* src_y, int src_stride_y,
80 uint16* dst_y, int dst_stride_y,
81 int width, int height) {
82 int y;
83 void (*CopyRow)(const uint16* src, uint16* dst, int width) = CopyRow_16_C;
84 // Coalesce rows.
85 if (src_stride_y == width &&
86 dst_stride_y == width) {
87 width *= height;
88 height = 1;
89 src_stride_y = dst_stride_y = 0;
90 }
91 #if defined(HAS_COPYROW_16_SSE2)
92 if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(width, 32)) {
93 CopyRow = CopyRow_16_SSE2;
94 }
95 #endif
96 #if defined(HAS_COPYROW_16_ERMS)
97 if (TestCpuFlag(kCpuHasERMS)) {
98 CopyRow = CopyRow_16_ERMS;
99 }
100 #endif
101 #if defined(HAS_COPYROW_16_NEON)
102 if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 32)) {
103 CopyRow = CopyRow_16_NEON;
104 }
105 #endif
106 #if defined(HAS_COPYROW_16_MIPS)
107 if (TestCpuFlag(kCpuHasMIPS)) {
108 CopyRow = CopyRow_16_MIPS;
109 }
110 #endif
111
112 // Copy plane
113 for (y = 0; y < height; ++y) {
114 CopyRow(src_y, dst_y, width);
115 src_y += src_stride_y;
116 dst_y += dst_stride_y;
117 }
118 }
119
120 // Copy I422.
121 LIBYUV_API
I422Copy(const uint8 * src_y,int src_stride_y,const uint8 * src_u,int src_stride_u,const uint8 * src_v,int src_stride_v,uint8 * dst_y,int dst_stride_y,uint8 * dst_u,int dst_stride_u,uint8 * dst_v,int dst_stride_v,int width,int height)122 int I422Copy(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 int halfwidth = (width + 1) >> 1;
130 if (!src_y || !src_u || !src_v ||
131 !dst_y || !dst_u || !dst_v ||
132 width <= 0 || height == 0) {
133 return -1;
134 }
135 // Negative height means invert the image.
136 if (height < 0) {
137 height = -height;
138 src_y = src_y + (height - 1) * src_stride_y;
139 src_u = src_u + (height - 1) * src_stride_u;
140 src_v = src_v + (height - 1) * src_stride_v;
141 src_stride_y = -src_stride_y;
142 src_stride_u = -src_stride_u;
143 src_stride_v = -src_stride_v;
144 }
145 CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
146 CopyPlane(src_u, src_stride_u, dst_u, dst_stride_u, halfwidth, height);
147 CopyPlane(src_v, src_stride_v, dst_v, dst_stride_v, halfwidth, height);
148 return 0;
149 }
150
151 // Copy I444.
152 LIBYUV_API
I444Copy(const uint8 * src_y,int src_stride_y,const uint8 * src_u,int src_stride_u,const uint8 * src_v,int src_stride_v,uint8 * dst_y,int dst_stride_y,uint8 * dst_u,int dst_stride_u,uint8 * dst_v,int dst_stride_v,int width,int height)153 int I444Copy(const uint8* src_y, int src_stride_y,
154 const uint8* src_u, int src_stride_u,
155 const uint8* src_v, int src_stride_v,
156 uint8* dst_y, int dst_stride_y,
157 uint8* dst_u, int dst_stride_u,
158 uint8* dst_v, int dst_stride_v,
159 int width, int height) {
160 if (!src_y || !src_u || !src_v ||
161 !dst_y || !dst_u || !dst_v ||
162 width <= 0 || height == 0) {
163 return -1;
164 }
165 // Negative height means invert the image.
166 if (height < 0) {
167 height = -height;
168 src_y = src_y + (height - 1) * src_stride_y;
169 src_u = src_u + (height - 1) * src_stride_u;
170 src_v = src_v + (height - 1) * src_stride_v;
171 src_stride_y = -src_stride_y;
172 src_stride_u = -src_stride_u;
173 src_stride_v = -src_stride_v;
174 }
175
176 CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
177 CopyPlane(src_u, src_stride_u, dst_u, dst_stride_u, width, height);
178 CopyPlane(src_v, src_stride_v, dst_v, dst_stride_v, width, height);
179 return 0;
180 }
181
182 // Copy I400.
183 LIBYUV_API
I400ToI400(const uint8 * src_y,int src_stride_y,uint8 * dst_y,int dst_stride_y,int width,int height)184 int I400ToI400(const uint8* src_y, int src_stride_y,
185 uint8* dst_y, int dst_stride_y,
186 int width, int height) {
187 if (!src_y || !dst_y || width <= 0 || height == 0) {
188 return -1;
189 }
190 // Negative height means invert the image.
191 if (height < 0) {
192 height = -height;
193 src_y = src_y + (height - 1) * src_stride_y;
194 src_stride_y = -src_stride_y;
195 }
196 CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
197 return 0;
198 }
199
200 // Convert I420 to I400.
201 LIBYUV_API
I420ToI400(const uint8 * src_y,int src_stride_y,const uint8 * src_u,int src_stride_u,const uint8 * src_v,int src_stride_v,uint8 * dst_y,int dst_stride_y,int width,int height)202 int I420ToI400(const uint8* src_y, int src_stride_y,
203 const uint8* src_u, int src_stride_u,
204 const uint8* src_v, int src_stride_v,
205 uint8* dst_y, int dst_stride_y,
206 int width, int height) {
207 if (!src_y || !dst_y || width <= 0 || height == 0) {
208 return -1;
209 }
210 // Negative height means invert the image.
211 if (height < 0) {
212 height = -height;
213 src_y = src_y + (height - 1) * src_stride_y;
214 src_stride_y = -src_stride_y;
215 }
216 CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
217 return 0;
218 }
219
220 // Mirror a plane of data.
MirrorPlane(const uint8 * src_y,int src_stride_y,uint8 * dst_y,int dst_stride_y,int width,int height)221 void MirrorPlane(const uint8* src_y, int src_stride_y,
222 uint8* dst_y, int dst_stride_y,
223 int width, int height) {
224 int y;
225 void (*MirrorRow)(const uint8* src, uint8* dst, int width) = MirrorRow_C;
226 // Negative height means invert the image.
227 if (height < 0) {
228 height = -height;
229 src_y = src_y + (height - 1) * src_stride_y;
230 src_stride_y = -src_stride_y;
231 }
232 #if defined(HAS_MIRRORROW_NEON)
233 if (TestCpuFlag(kCpuHasNEON)) {
234 MirrorRow = MirrorRow_Any_NEON;
235 if (IS_ALIGNED(width, 16)) {
236 MirrorRow = MirrorRow_NEON;
237 }
238 }
239 #endif
240 #if defined(HAS_MIRRORROW_SSE2)
241 if (TestCpuFlag(kCpuHasSSE2)) {
242 MirrorRow = MirrorRow_Any_SSE2;
243 if (IS_ALIGNED(width, 16)) {
244 MirrorRow = MirrorRow_SSE2;
245 }
246 }
247 #endif
248 #if defined(HAS_MIRRORROW_SSSE3)
249 if (TestCpuFlag(kCpuHasSSSE3)) {
250 MirrorRow = MirrorRow_Any_SSSE3;
251 if (IS_ALIGNED(width, 16)) {
252 MirrorRow = MirrorRow_SSSE3;
253 }
254 }
255 #endif
256 #if defined(HAS_MIRRORROW_AVX2)
257 if (TestCpuFlag(kCpuHasAVX2)) {
258 MirrorRow = MirrorRow_Any_AVX2;
259 if (IS_ALIGNED(width, 32)) {
260 MirrorRow = MirrorRow_AVX2;
261 }
262 }
263 #endif
264 // TODO(fbarchard): Mirror on mips handle unaligned memory.
265 #if defined(HAS_MIRRORROW_MIPS_DSPR2)
266 if (TestCpuFlag(kCpuHasMIPS_DSPR2) &&
267 IS_ALIGNED(src_y, 4) && IS_ALIGNED(src_stride_y, 4) &&
268 IS_ALIGNED(dst_y, 4) && IS_ALIGNED(dst_stride_y, 4)) {
269 MirrorRow = MirrorRow_MIPS_DSPR2;
270 }
271 #endif
272
273 // Mirror plane
274 for (y = 0; y < height; ++y) {
275 MirrorRow(src_y, dst_y, width);
276 src_y += src_stride_y;
277 dst_y += dst_stride_y;
278 }
279 }
280
281 // Convert YUY2 to I422.
282 LIBYUV_API
YUY2ToI422(const uint8 * src_yuy2,int src_stride_yuy2,uint8 * dst_y,int dst_stride_y,uint8 * dst_u,int dst_stride_u,uint8 * dst_v,int dst_stride_v,int width,int height)283 int YUY2ToI422(const uint8* src_yuy2, int src_stride_yuy2,
284 uint8* dst_y, int dst_stride_y,
285 uint8* dst_u, int dst_stride_u,
286 uint8* dst_v, int dst_stride_v,
287 int width, int height) {
288 int y;
289 void (*YUY2ToUV422Row)(const uint8* src_yuy2,
290 uint8* dst_u, uint8* dst_v, int pix) =
291 YUY2ToUV422Row_C;
292 void (*YUY2ToYRow)(const uint8* src_yuy2, uint8* dst_y, int pix) =
293 YUY2ToYRow_C;
294 // Negative height means invert the image.
295 if (height < 0) {
296 height = -height;
297 src_yuy2 = src_yuy2 + (height - 1) * src_stride_yuy2;
298 src_stride_yuy2 = -src_stride_yuy2;
299 }
300 // Coalesce rows.
301 if (src_stride_yuy2 == width * 2 &&
302 dst_stride_y == width &&
303 dst_stride_u * 2 == width &&
304 dst_stride_v * 2 == width) {
305 width *= height;
306 height = 1;
307 src_stride_yuy2 = dst_stride_y = dst_stride_u = dst_stride_v = 0;
308 }
309 #if defined(HAS_YUY2TOYROW_SSE2)
310 if (TestCpuFlag(kCpuHasSSE2)) {
311 YUY2ToUV422Row = YUY2ToUV422Row_Any_SSE2;
312 YUY2ToYRow = YUY2ToYRow_Any_SSE2;
313 if (IS_ALIGNED(width, 16)) {
314 YUY2ToUV422Row = YUY2ToUV422Row_SSE2;
315 YUY2ToYRow = YUY2ToYRow_SSE2;
316 }
317 }
318 #endif
319 #if defined(HAS_YUY2TOYROW_AVX2)
320 if (TestCpuFlag(kCpuHasAVX2)) {
321 YUY2ToUV422Row = YUY2ToUV422Row_Any_AVX2;
322 YUY2ToYRow = YUY2ToYRow_Any_AVX2;
323 if (IS_ALIGNED(width, 32)) {
324 YUY2ToUV422Row = YUY2ToUV422Row_AVX2;
325 YUY2ToYRow = YUY2ToYRow_AVX2;
326 }
327 }
328 #endif
329 #if defined(HAS_YUY2TOYROW_NEON)
330 if (TestCpuFlag(kCpuHasNEON)) {
331 YUY2ToYRow = YUY2ToYRow_Any_NEON;
332 if (width >= 16) {
333 YUY2ToUV422Row = YUY2ToUV422Row_Any_NEON;
334 }
335 if (IS_ALIGNED(width, 16)) {
336 YUY2ToYRow = YUY2ToYRow_NEON;
337 YUY2ToUV422Row = YUY2ToUV422Row_NEON;
338 }
339 }
340 #endif
341
342 for (y = 0; y < height; ++y) {
343 YUY2ToUV422Row(src_yuy2, dst_u, dst_v, width);
344 YUY2ToYRow(src_yuy2, dst_y, width);
345 src_yuy2 += src_stride_yuy2;
346 dst_y += dst_stride_y;
347 dst_u += dst_stride_u;
348 dst_v += dst_stride_v;
349 }
350 return 0;
351 }
352
353 // Convert UYVY to I422.
354 LIBYUV_API
UYVYToI422(const uint8 * src_uyvy,int src_stride_uyvy,uint8 * dst_y,int dst_stride_y,uint8 * dst_u,int dst_stride_u,uint8 * dst_v,int dst_stride_v,int width,int height)355 int UYVYToI422(const uint8* src_uyvy, int src_stride_uyvy,
356 uint8* dst_y, int dst_stride_y,
357 uint8* dst_u, int dst_stride_u,
358 uint8* dst_v, int dst_stride_v,
359 int width, int height) {
360 int y;
361 void (*UYVYToUV422Row)(const uint8* src_uyvy,
362 uint8* dst_u, uint8* dst_v, int pix) =
363 UYVYToUV422Row_C;
364 void (*UYVYToYRow)(const uint8* src_uyvy,
365 uint8* dst_y, int pix) = UYVYToYRow_C;
366 // Negative height means invert the image.
367 if (height < 0) {
368 height = -height;
369 src_uyvy = src_uyvy + (height - 1) * src_stride_uyvy;
370 src_stride_uyvy = -src_stride_uyvy;
371 }
372 // Coalesce rows.
373 if (src_stride_uyvy == width * 2 &&
374 dst_stride_y == width &&
375 dst_stride_u * 2 == width &&
376 dst_stride_v * 2 == width) {
377 width *= height;
378 height = 1;
379 src_stride_uyvy = dst_stride_y = dst_stride_u = dst_stride_v = 0;
380 }
381 #if defined(HAS_UYVYTOYROW_SSE2)
382 if (TestCpuFlag(kCpuHasSSE2)) {
383 UYVYToUV422Row = UYVYToUV422Row_Any_SSE2;
384 UYVYToYRow = UYVYToYRow_Any_SSE2;
385 if (IS_ALIGNED(width, 16)) {
386 UYVYToUV422Row = UYVYToUV422Row_SSE2;
387 UYVYToYRow = UYVYToYRow_SSE2;
388 }
389 }
390 #endif
391 #if defined(HAS_UYVYTOYROW_AVX2)
392 if (TestCpuFlag(kCpuHasAVX2)) {
393 UYVYToUV422Row = UYVYToUV422Row_Any_AVX2;
394 UYVYToYRow = UYVYToYRow_Any_AVX2;
395 if (IS_ALIGNED(width, 32)) {
396 UYVYToUV422Row = UYVYToUV422Row_AVX2;
397 UYVYToYRow = UYVYToYRow_AVX2;
398 }
399 }
400 #endif
401 #if defined(HAS_UYVYTOYROW_NEON)
402 if (TestCpuFlag(kCpuHasNEON)) {
403 UYVYToYRow = UYVYToYRow_Any_NEON;
404 if (width >= 16) {
405 UYVYToUV422Row = UYVYToUV422Row_Any_NEON;
406 }
407 if (IS_ALIGNED(width, 16)) {
408 UYVYToYRow = UYVYToYRow_NEON;
409 UYVYToUV422Row = UYVYToUV422Row_NEON;
410 }
411 }
412 #endif
413
414 for (y = 0; y < height; ++y) {
415 UYVYToUV422Row(src_uyvy, dst_u, dst_v, width);
416 UYVYToYRow(src_uyvy, dst_y, width);
417 src_uyvy += src_stride_uyvy;
418 dst_y += dst_stride_y;
419 dst_u += dst_stride_u;
420 dst_v += dst_stride_v;
421 }
422 return 0;
423 }
424
425 // Mirror I400 with optional flipping
426 LIBYUV_API
I400Mirror(const uint8 * src_y,int src_stride_y,uint8 * dst_y,int dst_stride_y,int width,int height)427 int I400Mirror(const uint8* src_y, int src_stride_y,
428 uint8* dst_y, int dst_stride_y,
429 int width, int height) {
430 if (!src_y || !dst_y ||
431 width <= 0 || height == 0) {
432 return -1;
433 }
434 // Negative height means invert the image.
435 if (height < 0) {
436 height = -height;
437 src_y = src_y + (height - 1) * src_stride_y;
438 src_stride_y = -src_stride_y;
439 }
440
441 MirrorPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
442 return 0;
443 }
444
445 // Mirror I420 with optional flipping
446 LIBYUV_API
I420Mirror(const uint8 * src_y,int src_stride_y,const uint8 * src_u,int src_stride_u,const uint8 * src_v,int src_stride_v,uint8 * dst_y,int dst_stride_y,uint8 * dst_u,int dst_stride_u,uint8 * dst_v,int dst_stride_v,int width,int height)447 int I420Mirror(const uint8* src_y, int src_stride_y,
448 const uint8* src_u, int src_stride_u,
449 const uint8* src_v, int src_stride_v,
450 uint8* dst_y, int dst_stride_y,
451 uint8* dst_u, int dst_stride_u,
452 uint8* dst_v, int dst_stride_v,
453 int width, int height) {
454 int halfwidth = (width + 1) >> 1;
455 int halfheight = (height + 1) >> 1;
456 if (!src_y || !src_u || !src_v || !dst_y || !dst_u || !dst_v ||
457 width <= 0 || height == 0) {
458 return -1;
459 }
460 // Negative height means invert the image.
461 if (height < 0) {
462 height = -height;
463 halfheight = (height + 1) >> 1;
464 src_y = src_y + (height - 1) * src_stride_y;
465 src_u = src_u + (halfheight - 1) * src_stride_u;
466 src_v = src_v + (halfheight - 1) * src_stride_v;
467 src_stride_y = -src_stride_y;
468 src_stride_u = -src_stride_u;
469 src_stride_v = -src_stride_v;
470 }
471
472 if (dst_y) {
473 MirrorPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
474 }
475 MirrorPlane(src_u, src_stride_u, dst_u, dst_stride_u, halfwidth, halfheight);
476 MirrorPlane(src_v, src_stride_v, dst_v, dst_stride_v, halfwidth, halfheight);
477 return 0;
478 }
479
480 // ARGB mirror.
481 LIBYUV_API
ARGBMirror(const uint8 * src_argb,int src_stride_argb,uint8 * dst_argb,int dst_stride_argb,int width,int height)482 int ARGBMirror(const uint8* src_argb, int src_stride_argb,
483 uint8* dst_argb, int dst_stride_argb,
484 int width, int height) {
485 int y;
486 void (*ARGBMirrorRow)(const uint8* src, uint8* dst, int width) =
487 ARGBMirrorRow_C;
488 if (!src_argb || !dst_argb || width <= 0 || height == 0) {
489 return -1;
490 }
491 // Negative height means invert the image.
492 if (height < 0) {
493 height = -height;
494 src_argb = src_argb + (height - 1) * src_stride_argb;
495 src_stride_argb = -src_stride_argb;
496 }
497 #if defined(HAS_ARGBMIRRORROW_NEON)
498 if (TestCpuFlag(kCpuHasNEON)) {
499 ARGBMirrorRow = ARGBMirrorRow_Any_NEON;
500 if (IS_ALIGNED(width, 4)) {
501 ARGBMirrorRow = ARGBMirrorRow_NEON;
502 }
503 }
504 #endif
505 #if defined(HAS_ARGBMIRRORROW_SSE2)
506 if (TestCpuFlag(kCpuHasSSE2)) {
507 ARGBMirrorRow = ARGBMirrorRow_Any_SSE2;
508 if (IS_ALIGNED(width, 4)) {
509 ARGBMirrorRow = ARGBMirrorRow_SSE2;
510 }
511 }
512 #endif
513 #if defined(HAS_ARGBMIRRORROW_AVX2)
514 if (TestCpuFlag(kCpuHasAVX2)) {
515 ARGBMirrorRow = ARGBMirrorRow_Any_AVX2;
516 if (IS_ALIGNED(width, 8)) {
517 ARGBMirrorRow = ARGBMirrorRow_AVX2;
518 }
519 }
520 #endif
521
522 // Mirror plane
523 for (y = 0; y < height; ++y) {
524 ARGBMirrorRow(src_argb, dst_argb, width);
525 src_argb += src_stride_argb;
526 dst_argb += dst_stride_argb;
527 }
528 return 0;
529 }
530
531 // Get a blender that optimized for the CPU and pixel count.
532 // As there are 6 blenders to choose from, the caller should try to use
533 // the same blend function for all pixels if possible.
534 LIBYUV_API
GetARGBBlend()535 ARGBBlendRow GetARGBBlend() {
536 void (*ARGBBlendRow)(const uint8* src_argb, const uint8* src_argb1,
537 uint8* dst_argb, int width) = ARGBBlendRow_C;
538 #if defined(HAS_ARGBBLENDROW_SSSE3)
539 if (TestCpuFlag(kCpuHasSSSE3)) {
540 ARGBBlendRow = ARGBBlendRow_SSSE3;
541 return ARGBBlendRow;
542 }
543 #endif
544 #if defined(HAS_ARGBBLENDROW_SSE2)
545 if (TestCpuFlag(kCpuHasSSE2)) {
546 ARGBBlendRow = ARGBBlendRow_SSE2;
547 }
548 #endif
549 #if defined(HAS_ARGBBLENDROW_NEON)
550 if (TestCpuFlag(kCpuHasNEON)) {
551 ARGBBlendRow = ARGBBlendRow_NEON;
552 }
553 #endif
554 return ARGBBlendRow;
555 }
556
557 // Alpha Blend 2 ARGB images and store to destination.
558 LIBYUV_API
ARGBBlend(const uint8 * src_argb0,int src_stride_argb0,const uint8 * src_argb1,int src_stride_argb1,uint8 * dst_argb,int dst_stride_argb,int width,int height)559 int ARGBBlend(const uint8* src_argb0, int src_stride_argb0,
560 const uint8* src_argb1, int src_stride_argb1,
561 uint8* dst_argb, int dst_stride_argb,
562 int width, int height) {
563 int y;
564 void (*ARGBBlendRow)(const uint8* src_argb, const uint8* src_argb1,
565 uint8* dst_argb, int width) = GetARGBBlend();
566 if (!src_argb0 || !src_argb1 || !dst_argb || width <= 0 || height == 0) {
567 return -1;
568 }
569 // Negative height means invert the image.
570 if (height < 0) {
571 height = -height;
572 dst_argb = dst_argb + (height - 1) * dst_stride_argb;
573 dst_stride_argb = -dst_stride_argb;
574 }
575 // Coalesce rows.
576 if (src_stride_argb0 == width * 4 &&
577 src_stride_argb1 == width * 4 &&
578 dst_stride_argb == width * 4) {
579 width *= height;
580 height = 1;
581 src_stride_argb0 = src_stride_argb1 = dst_stride_argb = 0;
582 }
583
584 for (y = 0; y < height; ++y) {
585 ARGBBlendRow(src_argb0, src_argb1, dst_argb, width);
586 src_argb0 += src_stride_argb0;
587 src_argb1 += src_stride_argb1;
588 dst_argb += dst_stride_argb;
589 }
590 return 0;
591 }
592
593 // Multiply 2 ARGB images and store to destination.
594 LIBYUV_API
ARGBMultiply(const uint8 * src_argb0,int src_stride_argb0,const uint8 * src_argb1,int src_stride_argb1,uint8 * dst_argb,int dst_stride_argb,int width,int height)595 int ARGBMultiply(const uint8* src_argb0, int src_stride_argb0,
596 const uint8* src_argb1, int src_stride_argb1,
597 uint8* dst_argb, int dst_stride_argb,
598 int width, int height) {
599 int y;
600 void (*ARGBMultiplyRow)(const uint8* src0, const uint8* src1, uint8* dst,
601 int width) = ARGBMultiplyRow_C;
602 if (!src_argb0 || !src_argb1 || !dst_argb || width <= 0 || height == 0) {
603 return -1;
604 }
605 // Negative height means invert the image.
606 if (height < 0) {
607 height = -height;
608 dst_argb = dst_argb + (height - 1) * dst_stride_argb;
609 dst_stride_argb = -dst_stride_argb;
610 }
611 // Coalesce rows.
612 if (src_stride_argb0 == width * 4 &&
613 src_stride_argb1 == width * 4 &&
614 dst_stride_argb == width * 4) {
615 width *= height;
616 height = 1;
617 src_stride_argb0 = src_stride_argb1 = dst_stride_argb = 0;
618 }
619 #if defined(HAS_ARGBMULTIPLYROW_SSE2)
620 if (TestCpuFlag(kCpuHasSSE2)) {
621 ARGBMultiplyRow = ARGBMultiplyRow_Any_SSE2;
622 if (IS_ALIGNED(width, 4)) {
623 ARGBMultiplyRow = ARGBMultiplyRow_SSE2;
624 }
625 }
626 #endif
627 #if defined(HAS_ARGBMULTIPLYROW_AVX2)
628 if (TestCpuFlag(kCpuHasAVX2)) {
629 ARGBMultiplyRow = ARGBMultiplyRow_Any_AVX2;
630 if (IS_ALIGNED(width, 8)) {
631 ARGBMultiplyRow = ARGBMultiplyRow_AVX2;
632 }
633 }
634 #endif
635 #if defined(HAS_ARGBMULTIPLYROW_NEON)
636 if (TestCpuFlag(kCpuHasNEON)) {
637 ARGBMultiplyRow = ARGBMultiplyRow_Any_NEON;
638 if (IS_ALIGNED(width, 8)) {
639 ARGBMultiplyRow = ARGBMultiplyRow_NEON;
640 }
641 }
642 #endif
643
644 // Multiply plane
645 for (y = 0; y < height; ++y) {
646 ARGBMultiplyRow(src_argb0, src_argb1, dst_argb, width);
647 src_argb0 += src_stride_argb0;
648 src_argb1 += src_stride_argb1;
649 dst_argb += dst_stride_argb;
650 }
651 return 0;
652 }
653
654 // Add 2 ARGB images and store to destination.
655 LIBYUV_API
ARGBAdd(const uint8 * src_argb0,int src_stride_argb0,const uint8 * src_argb1,int src_stride_argb1,uint8 * dst_argb,int dst_stride_argb,int width,int height)656 int ARGBAdd(const uint8* src_argb0, int src_stride_argb0,
657 const uint8* src_argb1, int src_stride_argb1,
658 uint8* dst_argb, int dst_stride_argb,
659 int width, int height) {
660 int y;
661 void (*ARGBAddRow)(const uint8* src0, const uint8* src1, uint8* dst,
662 int width) = ARGBAddRow_C;
663 if (!src_argb0 || !src_argb1 || !dst_argb || width <= 0 || height == 0) {
664 return -1;
665 }
666 // Negative height means invert the image.
667 if (height < 0) {
668 height = -height;
669 dst_argb = dst_argb + (height - 1) * dst_stride_argb;
670 dst_stride_argb = -dst_stride_argb;
671 }
672 // Coalesce rows.
673 if (src_stride_argb0 == width * 4 &&
674 src_stride_argb1 == width * 4 &&
675 dst_stride_argb == width * 4) {
676 width *= height;
677 height = 1;
678 src_stride_argb0 = src_stride_argb1 = dst_stride_argb = 0;
679 }
680 #if defined(HAS_ARGBADDROW_SSE2) && (defined(_MSC_VER) && !defined(__clang__))
681 if (TestCpuFlag(kCpuHasSSE2)) {
682 ARGBAddRow = ARGBAddRow_SSE2;
683 }
684 #endif
685 #if defined(HAS_ARGBADDROW_SSE2) && !(defined(_MSC_VER) && !defined(__clang__))
686 if (TestCpuFlag(kCpuHasSSE2)) {
687 ARGBAddRow = ARGBAddRow_Any_SSE2;
688 if (IS_ALIGNED(width, 4)) {
689 ARGBAddRow = ARGBAddRow_SSE2;
690 }
691 }
692 #endif
693 #if defined(HAS_ARGBADDROW_AVX2)
694 if (TestCpuFlag(kCpuHasAVX2)) {
695 ARGBAddRow = ARGBAddRow_Any_AVX2;
696 if (IS_ALIGNED(width, 8)) {
697 ARGBAddRow = ARGBAddRow_AVX2;
698 }
699 }
700 #endif
701 #if defined(HAS_ARGBADDROW_NEON)
702 if (TestCpuFlag(kCpuHasNEON)) {
703 ARGBAddRow = ARGBAddRow_Any_NEON;
704 if (IS_ALIGNED(width, 8)) {
705 ARGBAddRow = ARGBAddRow_NEON;
706 }
707 }
708 #endif
709
710 // Add plane
711 for (y = 0; y < height; ++y) {
712 ARGBAddRow(src_argb0, src_argb1, dst_argb, width);
713 src_argb0 += src_stride_argb0;
714 src_argb1 += src_stride_argb1;
715 dst_argb += dst_stride_argb;
716 }
717 return 0;
718 }
719
720 // Subtract 2 ARGB images and store to destination.
721 LIBYUV_API
ARGBSubtract(const uint8 * src_argb0,int src_stride_argb0,const uint8 * src_argb1,int src_stride_argb1,uint8 * dst_argb,int dst_stride_argb,int width,int height)722 int ARGBSubtract(const uint8* src_argb0, int src_stride_argb0,
723 const uint8* src_argb1, int src_stride_argb1,
724 uint8* dst_argb, int dst_stride_argb,
725 int width, int height) {
726 int y;
727 void (*ARGBSubtractRow)(const uint8* src0, const uint8* src1, uint8* dst,
728 int width) = ARGBSubtractRow_C;
729 if (!src_argb0 || !src_argb1 || !dst_argb || width <= 0 || height == 0) {
730 return -1;
731 }
732 // Negative height means invert the image.
733 if (height < 0) {
734 height = -height;
735 dst_argb = dst_argb + (height - 1) * dst_stride_argb;
736 dst_stride_argb = -dst_stride_argb;
737 }
738 // Coalesce rows.
739 if (src_stride_argb0 == width * 4 &&
740 src_stride_argb1 == width * 4 &&
741 dst_stride_argb == width * 4) {
742 width *= height;
743 height = 1;
744 src_stride_argb0 = src_stride_argb1 = dst_stride_argb = 0;
745 }
746 #if defined(HAS_ARGBSUBTRACTROW_SSE2)
747 if (TestCpuFlag(kCpuHasSSE2)) {
748 ARGBSubtractRow = ARGBSubtractRow_Any_SSE2;
749 if (IS_ALIGNED(width, 4)) {
750 ARGBSubtractRow = ARGBSubtractRow_SSE2;
751 }
752 }
753 #endif
754 #if defined(HAS_ARGBSUBTRACTROW_AVX2)
755 if (TestCpuFlag(kCpuHasAVX2)) {
756 ARGBSubtractRow = ARGBSubtractRow_Any_AVX2;
757 if (IS_ALIGNED(width, 8)) {
758 ARGBSubtractRow = ARGBSubtractRow_AVX2;
759 }
760 }
761 #endif
762 #if defined(HAS_ARGBSUBTRACTROW_NEON)
763 if (TestCpuFlag(kCpuHasNEON)) {
764 ARGBSubtractRow = ARGBSubtractRow_Any_NEON;
765 if (IS_ALIGNED(width, 8)) {
766 ARGBSubtractRow = ARGBSubtractRow_NEON;
767 }
768 }
769 #endif
770
771 // Subtract plane
772 for (y = 0; y < height; ++y) {
773 ARGBSubtractRow(src_argb0, src_argb1, dst_argb, width);
774 src_argb0 += src_stride_argb0;
775 src_argb1 += src_stride_argb1;
776 dst_argb += dst_stride_argb;
777 }
778 return 0;
779 }
780
781 // Convert I422 to BGRA.
782 LIBYUV_API
I422ToBGRA(const uint8 * src_y,int src_stride_y,const uint8 * src_u,int src_stride_u,const uint8 * src_v,int src_stride_v,uint8 * dst_bgra,int dst_stride_bgra,int width,int height)783 int I422ToBGRA(const uint8* src_y, int src_stride_y,
784 const uint8* src_u, int src_stride_u,
785 const uint8* src_v, int src_stride_v,
786 uint8* dst_bgra, int dst_stride_bgra,
787 int width, int height) {
788 int y;
789 void (*I422ToBGRARow)(const uint8* y_buf,
790 const uint8* u_buf,
791 const uint8* v_buf,
792 uint8* rgb_buf,
793 int width) = I422ToBGRARow_C;
794 if (!src_y || !src_u || !src_v ||
795 !dst_bgra ||
796 width <= 0 || height == 0) {
797 return -1;
798 }
799 // Negative height means invert the image.
800 if (height < 0) {
801 height = -height;
802 dst_bgra = dst_bgra + (height - 1) * dst_stride_bgra;
803 dst_stride_bgra = -dst_stride_bgra;
804 }
805 // Coalesce rows.
806 if (src_stride_y == width &&
807 src_stride_u * 2 == width &&
808 src_stride_v * 2 == width &&
809 dst_stride_bgra == width * 4) {
810 width *= height;
811 height = 1;
812 src_stride_y = src_stride_u = src_stride_v = dst_stride_bgra = 0;
813 }
814 #if defined(HAS_I422TOBGRAROW_SSSE3)
815 if (TestCpuFlag(kCpuHasSSSE3)) {
816 I422ToBGRARow = I422ToBGRARow_Any_SSSE3;
817 if (IS_ALIGNED(width, 8)) {
818 I422ToBGRARow = I422ToBGRARow_SSSE3;
819 }
820 }
821 #endif
822 #if defined(HAS_I422TOBGRAROW_AVX2)
823 if (TestCpuFlag(kCpuHasAVX2)) {
824 I422ToBGRARow = I422ToBGRARow_Any_AVX2;
825 if (IS_ALIGNED(width, 16)) {
826 I422ToBGRARow = I422ToBGRARow_AVX2;
827 }
828 }
829 #endif
830 #if defined(HAS_I422TOBGRAROW_NEON)
831 if (TestCpuFlag(kCpuHasNEON)) {
832 I422ToBGRARow = I422ToBGRARow_Any_NEON;
833 if (IS_ALIGNED(width, 8)) {
834 I422ToBGRARow = I422ToBGRARow_NEON;
835 }
836 }
837 #endif
838 #if defined(HAS_I422TOBGRAROW_MIPS_DSPR2)
839 if (TestCpuFlag(kCpuHasMIPS_DSPR2) && IS_ALIGNED(width, 4) &&
840 IS_ALIGNED(src_y, 4) && IS_ALIGNED(src_stride_y, 4) &&
841 IS_ALIGNED(src_u, 2) && IS_ALIGNED(src_stride_u, 2) &&
842 IS_ALIGNED(src_v, 2) && IS_ALIGNED(src_stride_v, 2) &&
843 IS_ALIGNED(dst_bgra, 4) && IS_ALIGNED(dst_stride_bgra, 4)) {
844 I422ToBGRARow = I422ToBGRARow_MIPS_DSPR2;
845 }
846 #endif
847
848 for (y = 0; y < height; ++y) {
849 I422ToBGRARow(src_y, src_u, src_v, dst_bgra, width);
850 dst_bgra += dst_stride_bgra;
851 src_y += src_stride_y;
852 src_u += src_stride_u;
853 src_v += src_stride_v;
854 }
855 return 0;
856 }
857
858 // Convert I422 to ABGR.
859 LIBYUV_API
I422ToABGR(const uint8 * src_y,int src_stride_y,const uint8 * src_u,int src_stride_u,const uint8 * src_v,int src_stride_v,uint8 * dst_abgr,int dst_stride_abgr,int width,int height)860 int I422ToABGR(const uint8* src_y, int src_stride_y,
861 const uint8* src_u, int src_stride_u,
862 const uint8* src_v, int src_stride_v,
863 uint8* dst_abgr, int dst_stride_abgr,
864 int width, int height) {
865 int y;
866 void (*I422ToABGRRow)(const uint8* y_buf,
867 const uint8* u_buf,
868 const uint8* v_buf,
869 uint8* rgb_buf,
870 int width) = I422ToABGRRow_C;
871 if (!src_y || !src_u || !src_v ||
872 !dst_abgr ||
873 width <= 0 || height == 0) {
874 return -1;
875 }
876 // Negative height means invert the image.
877 if (height < 0) {
878 height = -height;
879 dst_abgr = dst_abgr + (height - 1) * dst_stride_abgr;
880 dst_stride_abgr = -dst_stride_abgr;
881 }
882 // Coalesce rows.
883 if (src_stride_y == width &&
884 src_stride_u * 2 == width &&
885 src_stride_v * 2 == width &&
886 dst_stride_abgr == width * 4) {
887 width *= height;
888 height = 1;
889 src_stride_y = src_stride_u = src_stride_v = dst_stride_abgr = 0;
890 }
891 #if defined(HAS_I422TOABGRROW_NEON)
892 if (TestCpuFlag(kCpuHasNEON) && width >= 8) {
893 I422ToABGRRow = I422ToABGRRow_Any_NEON;
894 if (IS_ALIGNED(width, 8)) {
895 I422ToABGRRow = I422ToABGRRow_NEON;
896 }
897 }
898 #endif
899 #if defined(HAS_I422TOABGRROW_SSSE3)
900 if (TestCpuFlag(kCpuHasSSSE3)) {
901 I422ToABGRRow = I422ToABGRRow_Any_SSSE3;
902 if (IS_ALIGNED(width, 8)) {
903 I422ToABGRRow = I422ToABGRRow_SSSE3;
904 }
905 }
906 #endif
907 #if defined(HAS_I422TOABGRROW_AVX2)
908 if (TestCpuFlag(kCpuHasAVX2)) {
909 I422ToABGRRow = I422ToABGRRow_Any_AVX2;
910 if (IS_ALIGNED(width, 16)) {
911 I422ToABGRRow = I422ToABGRRow_AVX2;
912 }
913 }
914 #endif
915
916 for (y = 0; y < height; ++y) {
917 I422ToABGRRow(src_y, src_u, src_v, dst_abgr, width);
918 dst_abgr += dst_stride_abgr;
919 src_y += src_stride_y;
920 src_u += src_stride_u;
921 src_v += src_stride_v;
922 }
923 return 0;
924 }
925
926 // Convert I422 to RGBA.
927 LIBYUV_API
I422ToRGBA(const uint8 * src_y,int src_stride_y,const uint8 * src_u,int src_stride_u,const uint8 * src_v,int src_stride_v,uint8 * dst_rgba,int dst_stride_rgba,int width,int height)928 int I422ToRGBA(const uint8* src_y, int src_stride_y,
929 const uint8* src_u, int src_stride_u,
930 const uint8* src_v, int src_stride_v,
931 uint8* dst_rgba, int dst_stride_rgba,
932 int width, int height) {
933 int y;
934 void (*I422ToRGBARow)(const uint8* y_buf,
935 const uint8* u_buf,
936 const uint8* v_buf,
937 uint8* rgb_buf,
938 int width) = I422ToRGBARow_C;
939 if (!src_y || !src_u || !src_v ||
940 !dst_rgba ||
941 width <= 0 || height == 0) {
942 return -1;
943 }
944 // Negative height means invert the image.
945 if (height < 0) {
946 height = -height;
947 dst_rgba = dst_rgba + (height - 1) * dst_stride_rgba;
948 dst_stride_rgba = -dst_stride_rgba;
949 }
950 // Coalesce rows.
951 if (src_stride_y == width &&
952 src_stride_u * 2 == width &&
953 src_stride_v * 2 == width &&
954 dst_stride_rgba == width * 4) {
955 width *= height;
956 height = 1;
957 src_stride_y = src_stride_u = src_stride_v = dst_stride_rgba = 0;
958 }
959 #if defined(HAS_I422TORGBAROW_NEON)
960 if (TestCpuFlag(kCpuHasNEON) && width >= 8) {
961 I422ToRGBARow = I422ToRGBARow_Any_NEON;
962 if (IS_ALIGNED(width, 8)) {
963 I422ToRGBARow = I422ToRGBARow_NEON;
964 }
965 }
966 #endif
967 #if defined(HAS_I422TORGBAROW_SSSE3)
968 if (TestCpuFlag(kCpuHasSSSE3)) {
969 I422ToRGBARow = I422ToRGBARow_Any_SSSE3;
970 if (IS_ALIGNED(width, 8)) {
971 I422ToRGBARow = I422ToRGBARow_SSSE3;
972 }
973 }
974 #endif
975 #if defined(HAS_I422TORGBAROW_AVX2)
976 if (TestCpuFlag(kCpuHasAVX2)) {
977 I422ToRGBARow = I422ToRGBARow_Any_AVX2;
978 if (IS_ALIGNED(width, 16)) {
979 I422ToRGBARow = I422ToRGBARow_AVX2;
980 }
981 }
982 #endif
983
984 for (y = 0; y < height; ++y) {
985 I422ToRGBARow(src_y, src_u, src_v, dst_rgba, width);
986 dst_rgba += dst_stride_rgba;
987 src_y += src_stride_y;
988 src_u += src_stride_u;
989 src_v += src_stride_v;
990 }
991 return 0;
992 }
993
994 // Convert NV12 to RGB565.
995 LIBYUV_API
NV12ToRGB565(const uint8 * src_y,int src_stride_y,const uint8 * src_uv,int src_stride_uv,uint8 * dst_rgb565,int dst_stride_rgb565,int width,int height)996 int NV12ToRGB565(const uint8* src_y, int src_stride_y,
997 const uint8* src_uv, int src_stride_uv,
998 uint8* dst_rgb565, int dst_stride_rgb565,
999 int width, int height) {
1000 int y;
1001 void (*NV12ToRGB565Row)(const uint8* y_buf,
1002 const uint8* uv_buf,
1003 uint8* rgb_buf,
1004 int width) = NV12ToRGB565Row_C;
1005 if (!src_y || !src_uv || !dst_rgb565 ||
1006 width <= 0 || height == 0) {
1007 return -1;
1008 }
1009 // Negative height means invert the image.
1010 if (height < 0) {
1011 height = -height;
1012 dst_rgb565 = dst_rgb565 + (height - 1) * dst_stride_rgb565;
1013 dst_stride_rgb565 = -dst_stride_rgb565;
1014 }
1015 #if defined(HAS_NV12TORGB565ROW_SSSE3)
1016 if (TestCpuFlag(kCpuHasSSSE3)) {
1017 NV12ToRGB565Row = NV12ToRGB565Row_Any_SSSE3;
1018 if (IS_ALIGNED(width, 8)) {
1019 NV12ToRGB565Row = NV12ToRGB565Row_SSSE3;
1020 }
1021 }
1022 #endif
1023 #if defined(HAS_NV12TORGB565ROW_AVX2)
1024 if (TestCpuFlag(kCpuHasAVX2)) {
1025 NV12ToRGB565Row = NV12ToRGB565Row_Any_AVX2;
1026 if (IS_ALIGNED(width, 16)) {
1027 NV12ToRGB565Row = NV12ToRGB565Row_AVX2;
1028 }
1029 }
1030 #endif
1031 #if defined(HAS_NV12TORGB565ROW_NEON)
1032 if (TestCpuFlag(kCpuHasNEON)) {
1033 NV12ToRGB565Row = NV12ToRGB565Row_Any_NEON;
1034 if (IS_ALIGNED(width, 8)) {
1035 NV12ToRGB565Row = NV12ToRGB565Row_NEON;
1036 }
1037 }
1038 #endif
1039
1040 for (y = 0; y < height; ++y) {
1041 NV12ToRGB565Row(src_y, src_uv, dst_rgb565, width);
1042 dst_rgb565 += dst_stride_rgb565;
1043 src_y += src_stride_y;
1044 if (y & 1) {
1045 src_uv += src_stride_uv;
1046 }
1047 }
1048 return 0;
1049 }
1050
1051 // Convert NV21 to RGB565.
1052 LIBYUV_API
NV21ToRGB565(const uint8 * src_y,int src_stride_y,const uint8 * src_vu,int src_stride_vu,uint8 * dst_rgb565,int dst_stride_rgb565,int width,int height)1053 int NV21ToRGB565(const uint8* src_y, int src_stride_y,
1054 const uint8* src_vu, int src_stride_vu,
1055 uint8* dst_rgb565, int dst_stride_rgb565,
1056 int width, int height) {
1057 int y;
1058 void (*NV21ToRGB565Row)(const uint8* y_buf,
1059 const uint8* src_vu,
1060 uint8* rgb_buf,
1061 int width) = NV21ToRGB565Row_C;
1062 if (!src_y || !src_vu || !dst_rgb565 ||
1063 width <= 0 || height == 0) {
1064 return -1;
1065 }
1066 // Negative height means invert the image.
1067 if (height < 0) {
1068 height = -height;
1069 dst_rgb565 = dst_rgb565 + (height - 1) * dst_stride_rgb565;
1070 dst_stride_rgb565 = -dst_stride_rgb565;
1071 }
1072 #if defined(HAS_NV21TORGB565ROW_SSSE3)
1073 if (TestCpuFlag(kCpuHasSSSE3)) {
1074 NV21ToRGB565Row = NV21ToRGB565Row_Any_SSSE3;
1075 if (IS_ALIGNED(width, 8)) {
1076 NV21ToRGB565Row = NV21ToRGB565Row_SSSE3;
1077 }
1078 }
1079 #endif
1080 #if defined(HAS_NV21TORGB565ROW_AVX2)
1081 if (TestCpuFlag(kCpuHasAVX2)) {
1082 NV21ToRGB565Row = NV21ToRGB565Row_Any_AVX2;
1083 if (IS_ALIGNED(width, 16)) {
1084 NV21ToRGB565Row = NV21ToRGB565Row_AVX2;
1085 }
1086 }
1087 #endif
1088 #if defined(HAS_NV21TORGB565ROW_NEON)
1089 if (TestCpuFlag(kCpuHasNEON)) {
1090 NV21ToRGB565Row = NV21ToRGB565Row_Any_NEON;
1091 if (IS_ALIGNED(width, 8)) {
1092 NV21ToRGB565Row = NV21ToRGB565Row_NEON;
1093 }
1094 }
1095 #endif
1096
1097 for (y = 0; y < height; ++y) {
1098 NV21ToRGB565Row(src_y, src_vu, dst_rgb565, width);
1099 dst_rgb565 += dst_stride_rgb565;
1100 src_y += src_stride_y;
1101 if (y & 1) {
1102 src_vu += src_stride_vu;
1103 }
1104 }
1105 return 0;
1106 }
1107
1108 LIBYUV_API
SetPlane(uint8 * dst_y,int dst_stride_y,int width,int height,uint32 value)1109 void SetPlane(uint8* dst_y, int dst_stride_y,
1110 int width, int height,
1111 uint32 value) {
1112 int y;
1113 void (*SetRow)(uint8* dst, uint8 value, int pix) = SetRow_C;
1114 if (height < 0) {
1115 height = -height;
1116 dst_y = dst_y + (height - 1) * dst_stride_y;
1117 dst_stride_y = -dst_stride_y;
1118 }
1119 // Coalesce rows.
1120 if (dst_stride_y == width) {
1121 width *= height;
1122 height = 1;
1123 dst_stride_y = 0;
1124 }
1125 #if defined(HAS_SETROW_NEON)
1126 if (TestCpuFlag(kCpuHasNEON)) {
1127 SetRow = SetRow_Any_NEON;
1128 if (IS_ALIGNED(width, 16)) {
1129 SetRow = SetRow_NEON;
1130 }
1131 }
1132 #endif
1133 #if defined(HAS_SETROW_X86)
1134 if (TestCpuFlag(kCpuHasX86)) {
1135 SetRow = SetRow_Any_X86;
1136 if (IS_ALIGNED(width, 4)) {
1137 SetRow = SetRow_X86;
1138 }
1139 }
1140 #endif
1141 #if defined(HAS_SETROW_ERMS)
1142 if (TestCpuFlag(kCpuHasERMS)) {
1143 SetRow = SetRow_ERMS;
1144 }
1145 #endif
1146
1147 // Set plane
1148 for (y = 0; y < height; ++y) {
1149 SetRow(dst_y, value, width);
1150 dst_y += dst_stride_y;
1151 }
1152 }
1153
1154 // Draw a rectangle into I420
1155 LIBYUV_API
I420Rect(uint8 * dst_y,int dst_stride_y,uint8 * dst_u,int dst_stride_u,uint8 * dst_v,int dst_stride_v,int x,int y,int width,int height,int value_y,int value_u,int value_v)1156 int I420Rect(uint8* dst_y, int dst_stride_y,
1157 uint8* dst_u, int dst_stride_u,
1158 uint8* dst_v, int dst_stride_v,
1159 int x, int y,
1160 int width, int height,
1161 int value_y, int value_u, int value_v) {
1162 int halfwidth = (width + 1) >> 1;
1163 int halfheight = (height + 1) >> 1;
1164 uint8* start_y = dst_y + y * dst_stride_y + x;
1165 uint8* start_u = dst_u + (y / 2) * dst_stride_u + (x / 2);
1166 uint8* start_v = dst_v + (y / 2) * dst_stride_v + (x / 2);
1167 if (!dst_y || !dst_u || !dst_v ||
1168 width <= 0 || height == 0 ||
1169 x < 0 || y < 0 ||
1170 value_y < 0 || value_y > 255 ||
1171 value_u < 0 || value_u > 255 ||
1172 value_v < 0 || value_v > 255) {
1173 return -1;
1174 }
1175
1176 SetPlane(start_y, dst_stride_y, width, height, value_y);
1177 SetPlane(start_u, dst_stride_u, halfwidth, halfheight, value_u);
1178 SetPlane(start_v, dst_stride_v, halfwidth, halfheight, value_v);
1179 return 0;
1180 }
1181
1182 // Draw a rectangle into ARGB
1183 LIBYUV_API
ARGBRect(uint8 * dst_argb,int dst_stride_argb,int dst_x,int dst_y,int width,int height,uint32 value)1184 int ARGBRect(uint8* dst_argb, int dst_stride_argb,
1185 int dst_x, int dst_y,
1186 int width, int height,
1187 uint32 value) {
1188 int y;
1189 void (*ARGBSetRow)(uint8* dst_argb, uint32 value, int pix) = ARGBSetRow_C;
1190 if (!dst_argb ||
1191 width <= 0 || height == 0 ||
1192 dst_x < 0 || dst_y < 0) {
1193 return -1;
1194 }
1195 if (height < 0) {
1196 height = -height;
1197 dst_argb = dst_argb + (height - 1) * dst_stride_argb;
1198 dst_stride_argb = -dst_stride_argb;
1199 }
1200 dst_argb += dst_y * dst_stride_argb + dst_x * 4;
1201 // Coalesce rows.
1202 if (dst_stride_argb == width * 4) {
1203 width *= height;
1204 height = 1;
1205 dst_stride_argb = 0;
1206 }
1207
1208 #if defined(HAS_ARGBSETROW_NEON)
1209 if (TestCpuFlag(kCpuHasNEON)) {
1210 ARGBSetRow = ARGBSetRow_Any_NEON;
1211 if (IS_ALIGNED(width, 4)) {
1212 ARGBSetRow = ARGBSetRow_NEON;
1213 }
1214 }
1215 #endif
1216 #if defined(HAS_ARGBSETROW_X86)
1217 if (TestCpuFlag(kCpuHasX86)) {
1218 ARGBSetRow = ARGBSetRow_X86;
1219 }
1220 #endif
1221
1222 // Set plane
1223 for (y = 0; y < height; ++y) {
1224 ARGBSetRow(dst_argb, value, width);
1225 dst_argb += dst_stride_argb;
1226 }
1227 return 0;
1228 }
1229
1230 // Convert unattentuated ARGB to preattenuated ARGB.
1231 // An unattenutated ARGB alpha blend uses the formula
1232 // p = a * f + (1 - a) * b
1233 // where
1234 // p is output pixel
1235 // f is foreground pixel
1236 // b is background pixel
1237 // a is alpha value from foreground pixel
1238 // An preattenutated ARGB alpha blend uses the formula
1239 // p = f + (1 - a) * b
1240 // where
1241 // f is foreground pixel premultiplied by alpha
1242
1243 LIBYUV_API
ARGBAttenuate(const uint8 * src_argb,int src_stride_argb,uint8 * dst_argb,int dst_stride_argb,int width,int height)1244 int ARGBAttenuate(const uint8* src_argb, int src_stride_argb,
1245 uint8* dst_argb, int dst_stride_argb,
1246 int width, int height) {
1247 int y;
1248 void (*ARGBAttenuateRow)(const uint8* src_argb, uint8* dst_argb,
1249 int width) = ARGBAttenuateRow_C;
1250 if (!src_argb || !dst_argb || width <= 0 || height == 0) {
1251 return -1;
1252 }
1253 if (height < 0) {
1254 height = -height;
1255 src_argb = src_argb + (height - 1) * src_stride_argb;
1256 src_stride_argb = -src_stride_argb;
1257 }
1258 // Coalesce rows.
1259 if (src_stride_argb == width * 4 &&
1260 dst_stride_argb == width * 4) {
1261 width *= height;
1262 height = 1;
1263 src_stride_argb = dst_stride_argb = 0;
1264 }
1265 #if defined(HAS_ARGBATTENUATEROW_SSE2)
1266 if (TestCpuFlag(kCpuHasSSE2)) {
1267 ARGBAttenuateRow = ARGBAttenuateRow_Any_SSE2;
1268 if (IS_ALIGNED(width, 4)) {
1269 ARGBAttenuateRow = ARGBAttenuateRow_SSE2;
1270 }
1271 }
1272 #endif
1273 #if defined(HAS_ARGBATTENUATEROW_SSSE3)
1274 if (TestCpuFlag(kCpuHasSSSE3)) {
1275 ARGBAttenuateRow = ARGBAttenuateRow_Any_SSSE3;
1276 if (IS_ALIGNED(width, 4)) {
1277 ARGBAttenuateRow = ARGBAttenuateRow_SSSE3;
1278 }
1279 }
1280 #endif
1281 #if defined(HAS_ARGBATTENUATEROW_AVX2)
1282 if (TestCpuFlag(kCpuHasAVX2)) {
1283 ARGBAttenuateRow = ARGBAttenuateRow_Any_AVX2;
1284 if (IS_ALIGNED(width, 8)) {
1285 ARGBAttenuateRow = ARGBAttenuateRow_AVX2;
1286 }
1287 }
1288 #endif
1289 #if defined(HAS_ARGBATTENUATEROW_NEON)
1290 if (TestCpuFlag(kCpuHasNEON)) {
1291 ARGBAttenuateRow = ARGBAttenuateRow_Any_NEON;
1292 if (IS_ALIGNED(width, 8)) {
1293 ARGBAttenuateRow = ARGBAttenuateRow_NEON;
1294 }
1295 }
1296 #endif
1297
1298 for (y = 0; y < height; ++y) {
1299 ARGBAttenuateRow(src_argb, dst_argb, width);
1300 src_argb += src_stride_argb;
1301 dst_argb += dst_stride_argb;
1302 }
1303 return 0;
1304 }
1305
1306 // Convert preattentuated ARGB to unattenuated ARGB.
1307 LIBYUV_API
ARGBUnattenuate(const uint8 * src_argb,int src_stride_argb,uint8 * dst_argb,int dst_stride_argb,int width,int height)1308 int ARGBUnattenuate(const uint8* src_argb, int src_stride_argb,
1309 uint8* dst_argb, int dst_stride_argb,
1310 int width, int height) {
1311 int y;
1312 void (*ARGBUnattenuateRow)(const uint8* src_argb, uint8* dst_argb,
1313 int width) = ARGBUnattenuateRow_C;
1314 if (!src_argb || !dst_argb || width <= 0 || height == 0) {
1315 return -1;
1316 }
1317 if (height < 0) {
1318 height = -height;
1319 src_argb = src_argb + (height - 1) * src_stride_argb;
1320 src_stride_argb = -src_stride_argb;
1321 }
1322 // Coalesce rows.
1323 if (src_stride_argb == width * 4 &&
1324 dst_stride_argb == width * 4) {
1325 width *= height;
1326 height = 1;
1327 src_stride_argb = dst_stride_argb = 0;
1328 }
1329 #if defined(HAS_ARGBUNATTENUATEROW_SSE2)
1330 if (TestCpuFlag(kCpuHasSSE2)) {
1331 ARGBUnattenuateRow = ARGBUnattenuateRow_Any_SSE2;
1332 if (IS_ALIGNED(width, 4)) {
1333 ARGBUnattenuateRow = ARGBUnattenuateRow_SSE2;
1334 }
1335 }
1336 #endif
1337 #if defined(HAS_ARGBUNATTENUATEROW_AVX2)
1338 if (TestCpuFlag(kCpuHasAVX2)) {
1339 ARGBUnattenuateRow = ARGBUnattenuateRow_Any_AVX2;
1340 if (IS_ALIGNED(width, 8)) {
1341 ARGBUnattenuateRow = ARGBUnattenuateRow_AVX2;
1342 }
1343 }
1344 #endif
1345 // TODO(fbarchard): Neon version.
1346
1347 for (y = 0; y < height; ++y) {
1348 ARGBUnattenuateRow(src_argb, dst_argb, width);
1349 src_argb += src_stride_argb;
1350 dst_argb += dst_stride_argb;
1351 }
1352 return 0;
1353 }
1354
1355 // Convert ARGB to Grayed ARGB.
1356 LIBYUV_API
ARGBGrayTo(const uint8 * src_argb,int src_stride_argb,uint8 * dst_argb,int dst_stride_argb,int width,int height)1357 int ARGBGrayTo(const uint8* src_argb, int src_stride_argb,
1358 uint8* dst_argb, int dst_stride_argb,
1359 int width, int height) {
1360 int y;
1361 void (*ARGBGrayRow)(const uint8* src_argb, uint8* dst_argb,
1362 int width) = ARGBGrayRow_C;
1363 if (!src_argb || !dst_argb || width <= 0 || height == 0) {
1364 return -1;
1365 }
1366 if (height < 0) {
1367 height = -height;
1368 src_argb = src_argb + (height - 1) * src_stride_argb;
1369 src_stride_argb = -src_stride_argb;
1370 }
1371 // Coalesce rows.
1372 if (src_stride_argb == width * 4 &&
1373 dst_stride_argb == width * 4) {
1374 width *= height;
1375 height = 1;
1376 src_stride_argb = dst_stride_argb = 0;
1377 }
1378 #if defined(HAS_ARGBGRAYROW_SSSE3)
1379 if (TestCpuFlag(kCpuHasSSSE3) && IS_ALIGNED(width, 8)) {
1380 ARGBGrayRow = ARGBGrayRow_SSSE3;
1381 }
1382 #endif
1383 #if defined(HAS_ARGBGRAYROW_NEON)
1384 if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 8)) {
1385 ARGBGrayRow = ARGBGrayRow_NEON;
1386 }
1387 #endif
1388
1389 for (y = 0; y < height; ++y) {
1390 ARGBGrayRow(src_argb, dst_argb, width);
1391 src_argb += src_stride_argb;
1392 dst_argb += dst_stride_argb;
1393 }
1394 return 0;
1395 }
1396
1397 // Make a rectangle of ARGB gray scale.
1398 LIBYUV_API
ARGBGray(uint8 * dst_argb,int dst_stride_argb,int dst_x,int dst_y,int width,int height)1399 int ARGBGray(uint8* dst_argb, int dst_stride_argb,
1400 int dst_x, int dst_y,
1401 int width, int height) {
1402 int y;
1403 void (*ARGBGrayRow)(const uint8* src_argb, uint8* dst_argb,
1404 int width) = ARGBGrayRow_C;
1405 uint8* dst = dst_argb + dst_y * dst_stride_argb + dst_x * 4;
1406 if (!dst_argb || width <= 0 || height <= 0 || dst_x < 0 || dst_y < 0) {
1407 return -1;
1408 }
1409 // Coalesce rows.
1410 if (dst_stride_argb == width * 4) {
1411 width *= height;
1412 height = 1;
1413 dst_stride_argb = 0;
1414 }
1415 #if defined(HAS_ARGBGRAYROW_SSSE3)
1416 if (TestCpuFlag(kCpuHasSSSE3) && IS_ALIGNED(width, 8)) {
1417 ARGBGrayRow = ARGBGrayRow_SSSE3;
1418 }
1419 #endif
1420 #if defined(HAS_ARGBGRAYROW_NEON)
1421 if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 8)) {
1422 ARGBGrayRow = ARGBGrayRow_NEON;
1423 }
1424 #endif
1425 for (y = 0; y < height; ++y) {
1426 ARGBGrayRow(dst, dst, width);
1427 dst += dst_stride_argb;
1428 }
1429 return 0;
1430 }
1431
1432 // Make a rectangle of ARGB Sepia tone.
1433 LIBYUV_API
ARGBSepia(uint8 * dst_argb,int dst_stride_argb,int dst_x,int dst_y,int width,int height)1434 int ARGBSepia(uint8* dst_argb, int dst_stride_argb,
1435 int dst_x, int dst_y, int width, int height) {
1436 int y;
1437 void (*ARGBSepiaRow)(uint8* dst_argb, int width) = ARGBSepiaRow_C;
1438 uint8* dst = dst_argb + dst_y * dst_stride_argb + dst_x * 4;
1439 if (!dst_argb || width <= 0 || height <= 0 || dst_x < 0 || dst_y < 0) {
1440 return -1;
1441 }
1442 // Coalesce rows.
1443 if (dst_stride_argb == width * 4) {
1444 width *= height;
1445 height = 1;
1446 dst_stride_argb = 0;
1447 }
1448 #if defined(HAS_ARGBSEPIAROW_SSSE3)
1449 if (TestCpuFlag(kCpuHasSSSE3) && IS_ALIGNED(width, 8)) {
1450 ARGBSepiaRow = ARGBSepiaRow_SSSE3;
1451 }
1452 #endif
1453 #if defined(HAS_ARGBSEPIAROW_NEON)
1454 if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 8)) {
1455 ARGBSepiaRow = ARGBSepiaRow_NEON;
1456 }
1457 #endif
1458 for (y = 0; y < height; ++y) {
1459 ARGBSepiaRow(dst, width);
1460 dst += dst_stride_argb;
1461 }
1462 return 0;
1463 }
1464
1465 // Apply a 4x4 matrix to each ARGB pixel.
1466 // Note: Normally for shading, but can be used to swizzle or invert.
1467 LIBYUV_API
ARGBColorMatrix(const uint8 * src_argb,int src_stride_argb,uint8 * dst_argb,int dst_stride_argb,const int8 * matrix_argb,int width,int height)1468 int ARGBColorMatrix(const uint8* src_argb, int src_stride_argb,
1469 uint8* dst_argb, int dst_stride_argb,
1470 const int8* matrix_argb,
1471 int width, int height) {
1472 int y;
1473 void (*ARGBColorMatrixRow)(const uint8* src_argb, uint8* dst_argb,
1474 const int8* matrix_argb, int width) = ARGBColorMatrixRow_C;
1475 if (!src_argb || !dst_argb || !matrix_argb || width <= 0 || height == 0) {
1476 return -1;
1477 }
1478 if (height < 0) {
1479 height = -height;
1480 src_argb = src_argb + (height - 1) * src_stride_argb;
1481 src_stride_argb = -src_stride_argb;
1482 }
1483 // Coalesce rows.
1484 if (src_stride_argb == width * 4 &&
1485 dst_stride_argb == width * 4) {
1486 width *= height;
1487 height = 1;
1488 src_stride_argb = dst_stride_argb = 0;
1489 }
1490 #if defined(HAS_ARGBCOLORMATRIXROW_SSSE3)
1491 if (TestCpuFlag(kCpuHasSSSE3) && IS_ALIGNED(width, 8)) {
1492 ARGBColorMatrixRow = ARGBColorMatrixRow_SSSE3;
1493 }
1494 #endif
1495 #if defined(HAS_ARGBCOLORMATRIXROW_NEON)
1496 if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 8)) {
1497 ARGBColorMatrixRow = ARGBColorMatrixRow_NEON;
1498 }
1499 #endif
1500 for (y = 0; y < height; ++y) {
1501 ARGBColorMatrixRow(src_argb, dst_argb, matrix_argb, width);
1502 src_argb += src_stride_argb;
1503 dst_argb += dst_stride_argb;
1504 }
1505 return 0;
1506 }
1507
1508 // Apply a 4x3 matrix to each ARGB pixel.
1509 // Deprecated.
1510 LIBYUV_API
RGBColorMatrix(uint8 * dst_argb,int dst_stride_argb,const int8 * matrix_rgb,int dst_x,int dst_y,int width,int height)1511 int RGBColorMatrix(uint8* dst_argb, int dst_stride_argb,
1512 const int8* matrix_rgb,
1513 int dst_x, int dst_y, int width, int height) {
1514 SIMD_ALIGNED(int8 matrix_argb[16]);
1515 uint8* dst = dst_argb + dst_y * dst_stride_argb + dst_x * 4;
1516 if (!dst_argb || !matrix_rgb || width <= 0 || height <= 0 ||
1517 dst_x < 0 || dst_y < 0) {
1518 return -1;
1519 }
1520
1521 // Convert 4x3 7 bit matrix to 4x4 6 bit matrix.
1522 matrix_argb[0] = matrix_rgb[0] / 2;
1523 matrix_argb[1] = matrix_rgb[1] / 2;
1524 matrix_argb[2] = matrix_rgb[2] / 2;
1525 matrix_argb[3] = matrix_rgb[3] / 2;
1526 matrix_argb[4] = matrix_rgb[4] / 2;
1527 matrix_argb[5] = matrix_rgb[5] / 2;
1528 matrix_argb[6] = matrix_rgb[6] / 2;
1529 matrix_argb[7] = matrix_rgb[7] / 2;
1530 matrix_argb[8] = matrix_rgb[8] / 2;
1531 matrix_argb[9] = matrix_rgb[9] / 2;
1532 matrix_argb[10] = matrix_rgb[10] / 2;
1533 matrix_argb[11] = matrix_rgb[11] / 2;
1534 matrix_argb[14] = matrix_argb[13] = matrix_argb[12] = 0;
1535 matrix_argb[15] = 64; // 1.0
1536
1537 return ARGBColorMatrix((const uint8*)(dst), dst_stride_argb,
1538 dst, dst_stride_argb,
1539 &matrix_argb[0], width, height);
1540 }
1541
1542 // Apply a color table each ARGB pixel.
1543 // Table contains 256 ARGB values.
1544 LIBYUV_API
ARGBColorTable(uint8 * dst_argb,int dst_stride_argb,const uint8 * table_argb,int dst_x,int dst_y,int width,int height)1545 int ARGBColorTable(uint8* dst_argb, int dst_stride_argb,
1546 const uint8* table_argb,
1547 int dst_x, int dst_y, int width, int height) {
1548 int y;
1549 void (*ARGBColorTableRow)(uint8* dst_argb, const uint8* table_argb,
1550 int width) = ARGBColorTableRow_C;
1551 uint8* dst = dst_argb + dst_y * dst_stride_argb + dst_x * 4;
1552 if (!dst_argb || !table_argb || width <= 0 || height <= 0 ||
1553 dst_x < 0 || dst_y < 0) {
1554 return -1;
1555 }
1556 // Coalesce rows.
1557 if (dst_stride_argb == width * 4) {
1558 width *= height;
1559 height = 1;
1560 dst_stride_argb = 0;
1561 }
1562 #if defined(HAS_ARGBCOLORTABLEROW_X86)
1563 if (TestCpuFlag(kCpuHasX86)) {
1564 ARGBColorTableRow = ARGBColorTableRow_X86;
1565 }
1566 #endif
1567 for (y = 0; y < height; ++y) {
1568 ARGBColorTableRow(dst, table_argb, width);
1569 dst += dst_stride_argb;
1570 }
1571 return 0;
1572 }
1573
1574 // Apply a color table each ARGB pixel but preserve destination alpha.
1575 // Table contains 256 ARGB values.
1576 LIBYUV_API
RGBColorTable(uint8 * dst_argb,int dst_stride_argb,const uint8 * table_argb,int dst_x,int dst_y,int width,int height)1577 int RGBColorTable(uint8* dst_argb, int dst_stride_argb,
1578 const uint8* table_argb,
1579 int dst_x, int dst_y, int width, int height) {
1580 int y;
1581 void (*RGBColorTableRow)(uint8* dst_argb, const uint8* table_argb,
1582 int width) = RGBColorTableRow_C;
1583 uint8* dst = dst_argb + dst_y * dst_stride_argb + dst_x * 4;
1584 if (!dst_argb || !table_argb || width <= 0 || height <= 0 ||
1585 dst_x < 0 || dst_y < 0) {
1586 return -1;
1587 }
1588 // Coalesce rows.
1589 if (dst_stride_argb == width * 4) {
1590 width *= height;
1591 height = 1;
1592 dst_stride_argb = 0;
1593 }
1594 #if defined(HAS_RGBCOLORTABLEROW_X86)
1595 if (TestCpuFlag(kCpuHasX86)) {
1596 RGBColorTableRow = RGBColorTableRow_X86;
1597 }
1598 #endif
1599 for (y = 0; y < height; ++y) {
1600 RGBColorTableRow(dst, table_argb, width);
1601 dst += dst_stride_argb;
1602 }
1603 return 0;
1604 }
1605
1606 // ARGBQuantize is used to posterize art.
1607 // e.g. rgb / qvalue * qvalue + qvalue / 2
1608 // But the low levels implement efficiently with 3 parameters, and could be
1609 // used for other high level operations.
1610 // dst_argb[0] = (b * scale >> 16) * interval_size + interval_offset;
1611 // where scale is 1 / interval_size as a fixed point value.
1612 // The divide is replaces with a multiply by reciprocal fixed point multiply.
1613 // Caveat - although SSE2 saturates, the C function does not and should be used
1614 // with care if doing anything but quantization.
1615 LIBYUV_API
ARGBQuantize(uint8 * dst_argb,int dst_stride_argb,int scale,int interval_size,int interval_offset,int dst_x,int dst_y,int width,int height)1616 int ARGBQuantize(uint8* dst_argb, int dst_stride_argb,
1617 int scale, int interval_size, int interval_offset,
1618 int dst_x, int dst_y, int width, int height) {
1619 int y;
1620 void (*ARGBQuantizeRow)(uint8* dst_argb, int scale, int interval_size,
1621 int interval_offset, int width) = ARGBQuantizeRow_C;
1622 uint8* dst = dst_argb + dst_y * dst_stride_argb + dst_x * 4;
1623 if (!dst_argb || width <= 0 || height <= 0 || dst_x < 0 || dst_y < 0 ||
1624 interval_size < 1 || interval_size > 255) {
1625 return -1;
1626 }
1627 // Coalesce rows.
1628 if (dst_stride_argb == width * 4) {
1629 width *= height;
1630 height = 1;
1631 dst_stride_argb = 0;
1632 }
1633 #if defined(HAS_ARGBQUANTIZEROW_SSE2)
1634 if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(width, 4)) {
1635 ARGBQuantizeRow = ARGBQuantizeRow_SSE2;
1636 }
1637 #endif
1638 #if defined(HAS_ARGBQUANTIZEROW_NEON)
1639 if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 8)) {
1640 ARGBQuantizeRow = ARGBQuantizeRow_NEON;
1641 }
1642 #endif
1643 for (y = 0; y < height; ++y) {
1644 ARGBQuantizeRow(dst, scale, interval_size, interval_offset, width);
1645 dst += dst_stride_argb;
1646 }
1647 return 0;
1648 }
1649
1650 // Computes table of cumulative sum for image where the value is the sum
1651 // of all values above and to the left of the entry. Used by ARGBBlur.
1652 LIBYUV_API
ARGBComputeCumulativeSum(const uint8 * src_argb,int src_stride_argb,int32 * dst_cumsum,int dst_stride32_cumsum,int width,int height)1653 int ARGBComputeCumulativeSum(const uint8* src_argb, int src_stride_argb,
1654 int32* dst_cumsum, int dst_stride32_cumsum,
1655 int width, int height) {
1656 int y;
1657 void (*ComputeCumulativeSumRow)(const uint8* row, int32* cumsum,
1658 const int32* previous_cumsum, int width) = ComputeCumulativeSumRow_C;
1659 int32* previous_cumsum = dst_cumsum;
1660 if (!dst_cumsum || !src_argb || width <= 0 || height <= 0) {
1661 return -1;
1662 }
1663 #if defined(HAS_CUMULATIVESUMTOAVERAGEROW_SSE2)
1664 if (TestCpuFlag(kCpuHasSSE2)) {
1665 ComputeCumulativeSumRow = ComputeCumulativeSumRow_SSE2;
1666 }
1667 #endif
1668 memset(dst_cumsum, 0, width * sizeof(dst_cumsum[0]) * 4); // 4 int per pixel.
1669 for (y = 0; y < height; ++y) {
1670 ComputeCumulativeSumRow(src_argb, dst_cumsum, previous_cumsum, width);
1671 previous_cumsum = dst_cumsum;
1672 dst_cumsum += dst_stride32_cumsum;
1673 src_argb += src_stride_argb;
1674 }
1675 return 0;
1676 }
1677
1678 // Blur ARGB image.
1679 // Caller should allocate CumulativeSum table of width * height * 16 bytes
1680 // aligned to 16 byte boundary. height can be radius * 2 + 2 to save memory
1681 // as the buffer is treated as circular.
1682 LIBYUV_API
ARGBBlur(const uint8 * src_argb,int src_stride_argb,uint8 * dst_argb,int dst_stride_argb,int32 * dst_cumsum,int dst_stride32_cumsum,int width,int height,int radius)1683 int ARGBBlur(const uint8* src_argb, int src_stride_argb,
1684 uint8* dst_argb, int dst_stride_argb,
1685 int32* dst_cumsum, int dst_stride32_cumsum,
1686 int width, int height, int radius) {
1687 int y;
1688 void (*ComputeCumulativeSumRow)(const uint8 *row, int32 *cumsum,
1689 const int32* previous_cumsum, int width) = ComputeCumulativeSumRow_C;
1690 void (*CumulativeSumToAverageRow)(const int32* topleft, const int32* botleft,
1691 int width, int area, uint8* dst, int count) = CumulativeSumToAverageRow_C;
1692 int32* cumsum_bot_row;
1693 int32* max_cumsum_bot_row;
1694 int32* cumsum_top_row;
1695
1696 if (!src_argb || !dst_argb || width <= 0 || height == 0) {
1697 return -1;
1698 }
1699 if (height < 0) {
1700 height = -height;
1701 src_argb = src_argb + (height - 1) * src_stride_argb;
1702 src_stride_argb = -src_stride_argb;
1703 }
1704 if (radius > height) {
1705 radius = height;
1706 }
1707 if (radius > (width / 2 - 1)) {
1708 radius = width / 2 - 1;
1709 }
1710 if (radius <= 0) {
1711 return -1;
1712 }
1713 #if defined(HAS_CUMULATIVESUMTOAVERAGEROW_SSE2)
1714 if (TestCpuFlag(kCpuHasSSE2)) {
1715 ComputeCumulativeSumRow = ComputeCumulativeSumRow_SSE2;
1716 CumulativeSumToAverageRow = CumulativeSumToAverageRow_SSE2;
1717 }
1718 #endif
1719 // Compute enough CumulativeSum for first row to be blurred. After this
1720 // one row of CumulativeSum is updated at a time.
1721 ARGBComputeCumulativeSum(src_argb, src_stride_argb,
1722 dst_cumsum, dst_stride32_cumsum,
1723 width, radius);
1724
1725 src_argb = src_argb + radius * src_stride_argb;
1726 cumsum_bot_row = &dst_cumsum[(radius - 1) * dst_stride32_cumsum];
1727
1728 max_cumsum_bot_row = &dst_cumsum[(radius * 2 + 2) * dst_stride32_cumsum];
1729 cumsum_top_row = &dst_cumsum[0];
1730
1731 for (y = 0; y < height; ++y) {
1732 int top_y = ((y - radius - 1) >= 0) ? (y - radius - 1) : 0;
1733 int bot_y = ((y + radius) < height) ? (y + radius) : (height - 1);
1734 int area = radius * (bot_y - top_y);
1735 int boxwidth = radius * 4;
1736 int x;
1737 int n;
1738
1739 // Increment cumsum_top_row pointer with circular buffer wrap around.
1740 if (top_y) {
1741 cumsum_top_row += dst_stride32_cumsum;
1742 if (cumsum_top_row >= max_cumsum_bot_row) {
1743 cumsum_top_row = dst_cumsum;
1744 }
1745 }
1746 // Increment cumsum_bot_row pointer with circular buffer wrap around and
1747 // then fill in a row of CumulativeSum.
1748 if ((y + radius) < height) {
1749 const int32* prev_cumsum_bot_row = cumsum_bot_row;
1750 cumsum_bot_row += dst_stride32_cumsum;
1751 if (cumsum_bot_row >= max_cumsum_bot_row) {
1752 cumsum_bot_row = dst_cumsum;
1753 }
1754 ComputeCumulativeSumRow(src_argb, cumsum_bot_row, prev_cumsum_bot_row,
1755 width);
1756 src_argb += src_stride_argb;
1757 }
1758
1759 // Left clipped.
1760 for (x = 0; x < radius + 1; ++x) {
1761 CumulativeSumToAverageRow(cumsum_top_row, cumsum_bot_row,
1762 boxwidth, area, &dst_argb[x * 4], 1);
1763 area += (bot_y - top_y);
1764 boxwidth += 4;
1765 }
1766
1767 // Middle unclipped.
1768 n = (width - 1) - radius - x + 1;
1769 CumulativeSumToAverageRow(cumsum_top_row, cumsum_bot_row,
1770 boxwidth, area, &dst_argb[x * 4], n);
1771
1772 // Right clipped.
1773 for (x += n; x <= width - 1; ++x) {
1774 area -= (bot_y - top_y);
1775 boxwidth -= 4;
1776 CumulativeSumToAverageRow(cumsum_top_row + (x - radius - 1) * 4,
1777 cumsum_bot_row + (x - radius - 1) * 4,
1778 boxwidth, area, &dst_argb[x * 4], 1);
1779 }
1780 dst_argb += dst_stride_argb;
1781 }
1782 return 0;
1783 }
1784
1785 // Multiply ARGB image by a specified ARGB value.
1786 LIBYUV_API
ARGBShade(const uint8 * src_argb,int src_stride_argb,uint8 * dst_argb,int dst_stride_argb,int width,int height,uint32 value)1787 int ARGBShade(const uint8* src_argb, int src_stride_argb,
1788 uint8* dst_argb, int dst_stride_argb,
1789 int width, int height, uint32 value) {
1790 int y;
1791 void (*ARGBShadeRow)(const uint8* src_argb, uint8* dst_argb,
1792 int width, uint32 value) = ARGBShadeRow_C;
1793 if (!src_argb || !dst_argb || width <= 0 || height == 0 || value == 0u) {
1794 return -1;
1795 }
1796 if (height < 0) {
1797 height = -height;
1798 src_argb = src_argb + (height - 1) * src_stride_argb;
1799 src_stride_argb = -src_stride_argb;
1800 }
1801 // Coalesce rows.
1802 if (src_stride_argb == width * 4 &&
1803 dst_stride_argb == width * 4) {
1804 width *= height;
1805 height = 1;
1806 src_stride_argb = dst_stride_argb = 0;
1807 }
1808 #if defined(HAS_ARGBSHADEROW_SSE2)
1809 if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(width, 4)) {
1810 ARGBShadeRow = ARGBShadeRow_SSE2;
1811 }
1812 #endif
1813 #if defined(HAS_ARGBSHADEROW_NEON)
1814 if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 8)) {
1815 ARGBShadeRow = ARGBShadeRow_NEON;
1816 }
1817 #endif
1818
1819 for (y = 0; y < height; ++y) {
1820 ARGBShadeRow(src_argb, dst_argb, width, value);
1821 src_argb += src_stride_argb;
1822 dst_argb += dst_stride_argb;
1823 }
1824 return 0;
1825 }
1826
1827 // Interpolate 2 ARGB images by specified amount (0 to 255).
1828 LIBYUV_API
ARGBInterpolate(const uint8 * src_argb0,int src_stride_argb0,const uint8 * src_argb1,int src_stride_argb1,uint8 * dst_argb,int dst_stride_argb,int width,int height,int interpolation)1829 int ARGBInterpolate(const uint8* src_argb0, int src_stride_argb0,
1830 const uint8* src_argb1, int src_stride_argb1,
1831 uint8* dst_argb, int dst_stride_argb,
1832 int width, int height, int interpolation) {
1833 int y;
1834 void (*InterpolateRow)(uint8* dst_ptr, const uint8* src_ptr,
1835 ptrdiff_t src_stride, int dst_width,
1836 int source_y_fraction) = InterpolateRow_C;
1837 if (!src_argb0 || !src_argb1 || !dst_argb || width <= 0 || height == 0) {
1838 return -1;
1839 }
1840 // Negative height means invert the image.
1841 if (height < 0) {
1842 height = -height;
1843 dst_argb = dst_argb + (height - 1) * dst_stride_argb;
1844 dst_stride_argb = -dst_stride_argb;
1845 }
1846 // Coalesce rows.
1847 if (src_stride_argb0 == width * 4 &&
1848 src_stride_argb1 == width * 4 &&
1849 dst_stride_argb == width * 4) {
1850 width *= height;
1851 height = 1;
1852 src_stride_argb0 = src_stride_argb1 = dst_stride_argb = 0;
1853 }
1854 #if defined(HAS_INTERPOLATEROW_SSE2)
1855 if (TestCpuFlag(kCpuHasSSE2)) {
1856 InterpolateRow = InterpolateRow_Any_SSE2;
1857 if (IS_ALIGNED(width, 4)) {
1858 InterpolateRow = InterpolateRow_SSE2;
1859 }
1860 }
1861 #endif
1862 #if defined(HAS_INTERPOLATEROW_SSSE3)
1863 if (TestCpuFlag(kCpuHasSSSE3)) {
1864 InterpolateRow = InterpolateRow_Any_SSSE3;
1865 if (IS_ALIGNED(width, 4)) {
1866 InterpolateRow = InterpolateRow_SSSE3;
1867 }
1868 }
1869 #endif
1870 #if defined(HAS_INTERPOLATEROW_AVX2)
1871 if (TestCpuFlag(kCpuHasAVX2)) {
1872 InterpolateRow = InterpolateRow_Any_AVX2;
1873 if (IS_ALIGNED(width, 8)) {
1874 InterpolateRow = InterpolateRow_AVX2;
1875 }
1876 }
1877 #endif
1878 #if defined(HAS_INTERPOLATEROW_NEON)
1879 if (TestCpuFlag(kCpuHasNEON)) {
1880 InterpolateRow = InterpolateRow_Any_NEON;
1881 if (IS_ALIGNED(width, 4)) {
1882 InterpolateRow = InterpolateRow_NEON;
1883 }
1884 }
1885 #endif
1886 #if defined(HAS_INTERPOLATEROW_MIPS_DSPR2)
1887 if (TestCpuFlag(kCpuHasMIPS_DSPR2) &&
1888 IS_ALIGNED(src_argb0, 4) && IS_ALIGNED(src_stride_argb0, 4) &&
1889 IS_ALIGNED(src_argb1, 4) && IS_ALIGNED(src_stride_argb1, 4) &&
1890 IS_ALIGNED(dst_argb, 4) && IS_ALIGNED(dst_stride_argb, 4)) {
1891 InterpolateRow = InterpolateRow_MIPS_DSPR2;
1892 }
1893 #endif
1894
1895 for (y = 0; y < height; ++y) {
1896 InterpolateRow(dst_argb, src_argb0, src_argb1 - src_argb0,
1897 width * 4, interpolation);
1898 src_argb0 += src_stride_argb0;
1899 src_argb1 += src_stride_argb1;
1900 dst_argb += dst_stride_argb;
1901 }
1902 return 0;
1903 }
1904
1905 // Shuffle ARGB channel order. e.g. BGRA to ARGB.
1906 LIBYUV_API
ARGBShuffle(const uint8 * src_bgra,int src_stride_bgra,uint8 * dst_argb,int dst_stride_argb,const uint8 * shuffler,int width,int height)1907 int ARGBShuffle(const uint8* src_bgra, int src_stride_bgra,
1908 uint8* dst_argb, int dst_stride_argb,
1909 const uint8* shuffler, int width, int height) {
1910 int y;
1911 void (*ARGBShuffleRow)(const uint8* src_bgra, uint8* dst_argb,
1912 const uint8* shuffler, int pix) = ARGBShuffleRow_C;
1913 if (!src_bgra || !dst_argb ||
1914 width <= 0 || height == 0) {
1915 return -1;
1916 }
1917 // Negative height means invert the image.
1918 if (height < 0) {
1919 height = -height;
1920 src_bgra = src_bgra + (height - 1) * src_stride_bgra;
1921 src_stride_bgra = -src_stride_bgra;
1922 }
1923 // Coalesce rows.
1924 if (src_stride_bgra == width * 4 &&
1925 dst_stride_argb == width * 4) {
1926 width *= height;
1927 height = 1;
1928 src_stride_bgra = dst_stride_argb = 0;
1929 }
1930 #if defined(HAS_ARGBSHUFFLEROW_SSE2)
1931 if (TestCpuFlag(kCpuHasSSE2)) {
1932 ARGBShuffleRow = ARGBShuffleRow_Any_SSE2;
1933 if (IS_ALIGNED(width, 4)) {
1934 ARGBShuffleRow = ARGBShuffleRow_SSE2;
1935 }
1936 }
1937 #endif
1938 #if defined(HAS_ARGBSHUFFLEROW_SSSE3)
1939 if (TestCpuFlag(kCpuHasSSSE3)) {
1940 ARGBShuffleRow = ARGBShuffleRow_Any_SSSE3;
1941 if (IS_ALIGNED(width, 8)) {
1942 ARGBShuffleRow = ARGBShuffleRow_SSSE3;
1943 }
1944 }
1945 #endif
1946 #if defined(HAS_ARGBSHUFFLEROW_AVX2)
1947 if (TestCpuFlag(kCpuHasAVX2)) {
1948 ARGBShuffleRow = ARGBShuffleRow_Any_AVX2;
1949 if (IS_ALIGNED(width, 16)) {
1950 ARGBShuffleRow = ARGBShuffleRow_AVX2;
1951 }
1952 }
1953 #endif
1954 #if defined(HAS_ARGBSHUFFLEROW_NEON)
1955 if (TestCpuFlag(kCpuHasNEON)) {
1956 ARGBShuffleRow = ARGBShuffleRow_Any_NEON;
1957 if (IS_ALIGNED(width, 4)) {
1958 ARGBShuffleRow = ARGBShuffleRow_NEON;
1959 }
1960 }
1961 #endif
1962
1963 for (y = 0; y < height; ++y) {
1964 ARGBShuffleRow(src_bgra, dst_argb, shuffler, width);
1965 src_bgra += src_stride_bgra;
1966 dst_argb += dst_stride_argb;
1967 }
1968 return 0;
1969 }
1970
1971 // Sobel ARGB effect.
ARGBSobelize(const uint8 * src_argb,int src_stride_argb,uint8 * dst_argb,int dst_stride_argb,int width,int height,void (* SobelRow)(const uint8 * src_sobelx,const uint8 * src_sobely,uint8 * dst,int width))1972 static int ARGBSobelize(const uint8* src_argb, int src_stride_argb,
1973 uint8* dst_argb, int dst_stride_argb,
1974 int width, int height,
1975 void (*SobelRow)(const uint8* src_sobelx,
1976 const uint8* src_sobely,
1977 uint8* dst, int width)) {
1978 int y;
1979 void (*ARGBToYJRow)(const uint8* src_argb, uint8* dst_g, int pix) =
1980 ARGBToYJRow_C;
1981 void (*SobelYRow)(const uint8* src_y0, const uint8* src_y1,
1982 uint8* dst_sobely, int width) = SobelYRow_C;
1983 void (*SobelXRow)(const uint8* src_y0, const uint8* src_y1,
1984 const uint8* src_y2, uint8* dst_sobely, int width) =
1985 SobelXRow_C;
1986 const int kEdge = 16; // Extra pixels at start of row for extrude/align.
1987 if (!src_argb || !dst_argb || width <= 0 || height == 0) {
1988 return -1;
1989 }
1990 // Negative height means invert the image.
1991 if (height < 0) {
1992 height = -height;
1993 src_argb = src_argb + (height - 1) * src_stride_argb;
1994 src_stride_argb = -src_stride_argb;
1995 }
1996
1997 #if defined(HAS_ARGBTOYJROW_SSSE3)
1998 if (TestCpuFlag(kCpuHasSSSE3)) {
1999 ARGBToYJRow = ARGBToYJRow_Any_SSSE3;
2000 if (IS_ALIGNED(width, 16)) {
2001 ARGBToYJRow = ARGBToYJRow_SSSE3;
2002 }
2003 }
2004 #endif
2005 #if defined(HAS_ARGBTOYJROW_AVX2)
2006 if (TestCpuFlag(kCpuHasAVX2)) {
2007 ARGBToYJRow = ARGBToYJRow_Any_AVX2;
2008 if (IS_ALIGNED(width, 32)) {
2009 ARGBToYJRow = ARGBToYJRow_AVX2;
2010 }
2011 }
2012 #endif
2013 #if defined(HAS_ARGBTOYJROW_NEON)
2014 if (TestCpuFlag(kCpuHasNEON)) {
2015 ARGBToYJRow = ARGBToYJRow_Any_NEON;
2016 if (IS_ALIGNED(width, 8)) {
2017 ARGBToYJRow = ARGBToYJRow_NEON;
2018 }
2019 }
2020 #endif
2021
2022 #if defined(HAS_SOBELYROW_SSE2)
2023 if (TestCpuFlag(kCpuHasSSE2)) {
2024 SobelYRow = SobelYRow_SSE2;
2025 }
2026 #endif
2027 #if defined(HAS_SOBELYROW_NEON)
2028 if (TestCpuFlag(kCpuHasNEON)) {
2029 SobelYRow = SobelYRow_NEON;
2030 }
2031 #endif
2032 #if defined(HAS_SOBELXROW_SSE2)
2033 if (TestCpuFlag(kCpuHasSSE2)) {
2034 SobelXRow = SobelXRow_SSE2;
2035 }
2036 #endif
2037 #if defined(HAS_SOBELXROW_NEON)
2038 if (TestCpuFlag(kCpuHasNEON)) {
2039 SobelXRow = SobelXRow_NEON;
2040 }
2041 #endif
2042 {
2043 // 3 rows with edges before/after.
2044 const int kRowSize = (width + kEdge + 31) & ~31;
2045 align_buffer_64(rows, kRowSize * 2 + (kEdge + kRowSize * 3 + kEdge));
2046 uint8* row_sobelx = rows;
2047 uint8* row_sobely = rows + kRowSize;
2048 uint8* row_y = rows + kRowSize * 2;
2049
2050 // Convert first row.
2051 uint8* row_y0 = row_y + kEdge;
2052 uint8* row_y1 = row_y0 + kRowSize;
2053 uint8* row_y2 = row_y1 + kRowSize;
2054 ARGBToYJRow(src_argb, row_y0, width);
2055 row_y0[-1] = row_y0[0];
2056 memset(row_y0 + width, row_y0[width - 1], 16); // Extrude 16 for valgrind.
2057 ARGBToYJRow(src_argb, row_y1, width);
2058 row_y1[-1] = row_y1[0];
2059 memset(row_y1 + width, row_y1[width - 1], 16);
2060 memset(row_y2 + width, 0, 16);
2061
2062 for (y = 0; y < height; ++y) {
2063 // Convert next row of ARGB to G.
2064 if (y < (height - 1)) {
2065 src_argb += src_stride_argb;
2066 }
2067 ARGBToYJRow(src_argb, row_y2, width);
2068 row_y2[-1] = row_y2[0];
2069 row_y2[width] = row_y2[width - 1];
2070
2071 SobelXRow(row_y0 - 1, row_y1 - 1, row_y2 - 1, row_sobelx, width);
2072 SobelYRow(row_y0 - 1, row_y2 - 1, row_sobely, width);
2073 SobelRow(row_sobelx, row_sobely, dst_argb, width);
2074
2075 // Cycle thru circular queue of 3 row_y buffers.
2076 {
2077 uint8* row_yt = row_y0;
2078 row_y0 = row_y1;
2079 row_y1 = row_y2;
2080 row_y2 = row_yt;
2081 }
2082
2083 dst_argb += dst_stride_argb;
2084 }
2085 free_aligned_buffer_64(rows);
2086 }
2087 return 0;
2088 }
2089
2090 // Sobel ARGB effect.
2091 LIBYUV_API
ARGBSobel(const uint8 * src_argb,int src_stride_argb,uint8 * dst_argb,int dst_stride_argb,int width,int height)2092 int ARGBSobel(const uint8* src_argb, int src_stride_argb,
2093 uint8* dst_argb, int dst_stride_argb,
2094 int width, int height) {
2095 void (*SobelRow)(const uint8* src_sobelx, const uint8* src_sobely,
2096 uint8* dst_argb, int width) = SobelRow_C;
2097 #if defined(HAS_SOBELROW_SSE2)
2098 if (TestCpuFlag(kCpuHasSSE2)) {
2099 SobelRow = SobelRow_Any_SSE2;
2100 if (IS_ALIGNED(width, 16)) {
2101 SobelRow = SobelRow_SSE2;
2102 }
2103 }
2104 #endif
2105 #if defined(HAS_SOBELROW_NEON)
2106 if (TestCpuFlag(kCpuHasNEON)) {
2107 SobelRow = SobelRow_Any_NEON;
2108 if (IS_ALIGNED(width, 8)) {
2109 SobelRow = SobelRow_NEON;
2110 }
2111 }
2112 #endif
2113 return ARGBSobelize(src_argb, src_stride_argb, dst_argb, dst_stride_argb,
2114 width, height, SobelRow);
2115 }
2116
2117 // Sobel ARGB effect with planar output.
2118 LIBYUV_API
ARGBSobelToPlane(const uint8 * src_argb,int src_stride_argb,uint8 * dst_y,int dst_stride_y,int width,int height)2119 int ARGBSobelToPlane(const uint8* src_argb, int src_stride_argb,
2120 uint8* dst_y, int dst_stride_y,
2121 int width, int height) {
2122 void (*SobelToPlaneRow)(const uint8* src_sobelx, const uint8* src_sobely,
2123 uint8* dst_, int width) = SobelToPlaneRow_C;
2124 #if defined(HAS_SOBELTOPLANEROW_SSE2)
2125 if (TestCpuFlag(kCpuHasSSE2)) {
2126 SobelToPlaneRow = SobelToPlaneRow_Any_SSE2;
2127 if (IS_ALIGNED(width, 16)) {
2128 SobelToPlaneRow = SobelToPlaneRow_SSE2;
2129 }
2130 }
2131 #endif
2132 #if defined(HAS_SOBELTOPLANEROW_NEON)
2133 if (TestCpuFlag(kCpuHasNEON)) {
2134 SobelToPlaneRow = SobelToPlaneRow_Any_NEON;
2135 if (IS_ALIGNED(width, 16)) {
2136 SobelToPlaneRow = SobelToPlaneRow_NEON;
2137 }
2138 }
2139 #endif
2140 return ARGBSobelize(src_argb, src_stride_argb, dst_y, dst_stride_y,
2141 width, height, SobelToPlaneRow);
2142 }
2143
2144 // SobelXY ARGB effect.
2145 // Similar to Sobel, but also stores Sobel X in R and Sobel Y in B. G = Sobel.
2146 LIBYUV_API
ARGBSobelXY(const uint8 * src_argb,int src_stride_argb,uint8 * dst_argb,int dst_stride_argb,int width,int height)2147 int ARGBSobelXY(const uint8* src_argb, int src_stride_argb,
2148 uint8* dst_argb, int dst_stride_argb,
2149 int width, int height) {
2150 void (*SobelXYRow)(const uint8* src_sobelx, const uint8* src_sobely,
2151 uint8* dst_argb, int width) = SobelXYRow_C;
2152 #if defined(HAS_SOBELXYROW_SSE2)
2153 if (TestCpuFlag(kCpuHasSSE2)) {
2154 SobelXYRow = SobelXYRow_Any_SSE2;
2155 if (IS_ALIGNED(width, 16)) {
2156 SobelXYRow = SobelXYRow_SSE2;
2157 }
2158 }
2159 #endif
2160 #if defined(HAS_SOBELXYROW_NEON)
2161 if (TestCpuFlag(kCpuHasNEON)) {
2162 SobelXYRow = SobelXYRow_Any_NEON;
2163 if (IS_ALIGNED(width, 8)) {
2164 SobelXYRow = SobelXYRow_NEON;
2165 }
2166 }
2167 #endif
2168 return ARGBSobelize(src_argb, src_stride_argb, dst_argb, dst_stride_argb,
2169 width, height, SobelXYRow);
2170 }
2171
2172 // Apply a 4x4 polynomial to each ARGB pixel.
2173 LIBYUV_API
ARGBPolynomial(const uint8 * src_argb,int src_stride_argb,uint8 * dst_argb,int dst_stride_argb,const float * poly,int width,int height)2174 int ARGBPolynomial(const uint8* src_argb, int src_stride_argb,
2175 uint8* dst_argb, int dst_stride_argb,
2176 const float* poly,
2177 int width, int height) {
2178 int y;
2179 void (*ARGBPolynomialRow)(const uint8* src_argb,
2180 uint8* dst_argb, const float* poly,
2181 int width) = ARGBPolynomialRow_C;
2182 if (!src_argb || !dst_argb || !poly || width <= 0 || height == 0) {
2183 return -1;
2184 }
2185 // Negative height means invert the image.
2186 if (height < 0) {
2187 height = -height;
2188 src_argb = src_argb + (height - 1) * src_stride_argb;
2189 src_stride_argb = -src_stride_argb;
2190 }
2191 // Coalesce rows.
2192 if (src_stride_argb == width * 4 &&
2193 dst_stride_argb == width * 4) {
2194 width *= height;
2195 height = 1;
2196 src_stride_argb = dst_stride_argb = 0;
2197 }
2198 #if defined(HAS_ARGBPOLYNOMIALROW_SSE2)
2199 if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(width, 2)) {
2200 ARGBPolynomialRow = ARGBPolynomialRow_SSE2;
2201 }
2202 #endif
2203 #if defined(HAS_ARGBPOLYNOMIALROW_AVX2)
2204 if (TestCpuFlag(kCpuHasAVX2) && TestCpuFlag(kCpuHasFMA3) &&
2205 IS_ALIGNED(width, 2)) {
2206 ARGBPolynomialRow = ARGBPolynomialRow_AVX2;
2207 }
2208 #endif
2209
2210 for (y = 0; y < height; ++y) {
2211 ARGBPolynomialRow(src_argb, dst_argb, poly, width);
2212 src_argb += src_stride_argb;
2213 dst_argb += dst_stride_argb;
2214 }
2215 return 0;
2216 }
2217
2218 // Apply a lumacolortable to each ARGB pixel.
2219 LIBYUV_API
ARGBLumaColorTable(const uint8 * src_argb,int src_stride_argb,uint8 * dst_argb,int dst_stride_argb,const uint8 * luma,int width,int height)2220 int ARGBLumaColorTable(const uint8* src_argb, int src_stride_argb,
2221 uint8* dst_argb, int dst_stride_argb,
2222 const uint8* luma,
2223 int width, int height) {
2224 int y;
2225 void (*ARGBLumaColorTableRow)(const uint8* src_argb, uint8* dst_argb,
2226 int width, const uint8* luma, const uint32 lumacoeff) =
2227 ARGBLumaColorTableRow_C;
2228 if (!src_argb || !dst_argb || !luma || width <= 0 || height == 0) {
2229 return -1;
2230 }
2231 // Negative height means invert the image.
2232 if (height < 0) {
2233 height = -height;
2234 src_argb = src_argb + (height - 1) * src_stride_argb;
2235 src_stride_argb = -src_stride_argb;
2236 }
2237 // Coalesce rows.
2238 if (src_stride_argb == width * 4 &&
2239 dst_stride_argb == width * 4) {
2240 width *= height;
2241 height = 1;
2242 src_stride_argb = dst_stride_argb = 0;
2243 }
2244 #if defined(HAS_ARGBLUMACOLORTABLEROW_SSSE3)
2245 if (TestCpuFlag(kCpuHasSSSE3) && IS_ALIGNED(width, 4)) {
2246 ARGBLumaColorTableRow = ARGBLumaColorTableRow_SSSE3;
2247 }
2248 #endif
2249
2250 for (y = 0; y < height; ++y) {
2251 ARGBLumaColorTableRow(src_argb, dst_argb, width, luma, 0x00264b0f);
2252 src_argb += src_stride_argb;
2253 dst_argb += dst_stride_argb;
2254 }
2255 return 0;
2256 }
2257
2258 // Copy Alpha from one ARGB image to another.
2259 LIBYUV_API
ARGBCopyAlpha(const uint8 * src_argb,int src_stride_argb,uint8 * dst_argb,int dst_stride_argb,int width,int height)2260 int ARGBCopyAlpha(const uint8* src_argb, int src_stride_argb,
2261 uint8* dst_argb, int dst_stride_argb,
2262 int width, int height) {
2263 int y;
2264 void (*ARGBCopyAlphaRow)(const uint8* src_argb, uint8* dst_argb, int width) =
2265 ARGBCopyAlphaRow_C;
2266 if (!src_argb || !dst_argb || width <= 0 || height == 0) {
2267 return -1;
2268 }
2269 // Negative height means invert the image.
2270 if (height < 0) {
2271 height = -height;
2272 src_argb = src_argb + (height - 1) * src_stride_argb;
2273 src_stride_argb = -src_stride_argb;
2274 }
2275 // Coalesce rows.
2276 if (src_stride_argb == width * 4 &&
2277 dst_stride_argb == width * 4) {
2278 width *= height;
2279 height = 1;
2280 src_stride_argb = dst_stride_argb = 0;
2281 }
2282 #if defined(HAS_ARGBCOPYALPHAROW_SSE2)
2283 if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(width, 8)) {
2284 ARGBCopyAlphaRow = ARGBCopyAlphaRow_SSE2;
2285 }
2286 #endif
2287 #if defined(HAS_ARGBCOPYALPHAROW_AVX2)
2288 if (TestCpuFlag(kCpuHasAVX2) && IS_ALIGNED(width, 16)) {
2289 ARGBCopyAlphaRow = ARGBCopyAlphaRow_AVX2;
2290 }
2291 #endif
2292
2293 for (y = 0; y < height; ++y) {
2294 ARGBCopyAlphaRow(src_argb, dst_argb, width);
2295 src_argb += src_stride_argb;
2296 dst_argb += dst_stride_argb;
2297 }
2298 return 0;
2299 }
2300
2301 // Copy a planar Y channel to the alpha channel of a destination ARGB image.
2302 LIBYUV_API
ARGBCopyYToAlpha(const uint8 * src_y,int src_stride_y,uint8 * dst_argb,int dst_stride_argb,int width,int height)2303 int ARGBCopyYToAlpha(const uint8* src_y, int src_stride_y,
2304 uint8* dst_argb, int dst_stride_argb,
2305 int width, int height) {
2306 int y;
2307 void (*ARGBCopyYToAlphaRow)(const uint8* src_y, uint8* dst_argb, int width) =
2308 ARGBCopyYToAlphaRow_C;
2309 if (!src_y || !dst_argb || width <= 0 || height == 0) {
2310 return -1;
2311 }
2312 // Negative height means invert the image.
2313 if (height < 0) {
2314 height = -height;
2315 src_y = src_y + (height - 1) * src_stride_y;
2316 src_stride_y = -src_stride_y;
2317 }
2318 // Coalesce rows.
2319 if (src_stride_y == width &&
2320 dst_stride_argb == width * 4) {
2321 width *= height;
2322 height = 1;
2323 src_stride_y = dst_stride_argb = 0;
2324 }
2325 #if defined(HAS_ARGBCOPYYTOALPHAROW_SSE2)
2326 if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(width, 8)) {
2327 ARGBCopyYToAlphaRow = ARGBCopyYToAlphaRow_SSE2;
2328 }
2329 #endif
2330 #if defined(HAS_ARGBCOPYYTOALPHAROW_AVX2)
2331 if (TestCpuFlag(kCpuHasAVX2) && IS_ALIGNED(width, 16)) {
2332 ARGBCopyYToAlphaRow = ARGBCopyYToAlphaRow_AVX2;
2333 }
2334 #endif
2335
2336 for (y = 0; y < height; ++y) {
2337 ARGBCopyYToAlphaRow(src_y, dst_argb, width);
2338 src_y += src_stride_y;
2339 dst_argb += dst_stride_argb;
2340 }
2341 return 0;
2342 }
2343
2344 LIBYUV_API
YUY2ToNV12(const uint8 * src_yuy2,int src_stride_yuy2,uint8 * dst_y,int dst_stride_y,uint8 * dst_uv,int dst_stride_uv,int width,int height)2345 int YUY2ToNV12(const uint8* src_yuy2, int src_stride_yuy2,
2346 uint8* dst_y, int dst_stride_y,
2347 uint8* dst_uv, int dst_stride_uv,
2348 int width, int height) {
2349 int y;
2350 int halfwidth = (width + 1) >> 1;
2351 void (*SplitUVRow)(const uint8* src_uv, uint8* dst_u, uint8* dst_v, int pix) =
2352 SplitUVRow_C;
2353 void (*InterpolateRow)(uint8* dst_ptr, const uint8* src_ptr,
2354 ptrdiff_t src_stride, int dst_width,
2355 int source_y_fraction) = InterpolateRow_C;
2356 if (!src_yuy2 ||
2357 !dst_y || !dst_uv ||
2358 width <= 0 || height == 0) {
2359 return -1;
2360 }
2361 // Negative height means invert the image.
2362 if (height < 0) {
2363 height = -height;
2364 src_yuy2 = src_yuy2 + (height - 1) * src_stride_yuy2;
2365 src_stride_yuy2 = -src_stride_yuy2;
2366 }
2367 #if defined(HAS_SPLITUVROW_SSE2)
2368 if (TestCpuFlag(kCpuHasSSE2)) {
2369 SplitUVRow = SplitUVRow_Any_SSE2;
2370 if (IS_ALIGNED(width, 16)) {
2371 SplitUVRow = SplitUVRow_SSE2;
2372 }
2373 }
2374 #endif
2375 #if defined(HAS_SPLITUVROW_AVX2)
2376 if (TestCpuFlag(kCpuHasAVX2)) {
2377 SplitUVRow = SplitUVRow_Any_AVX2;
2378 if (IS_ALIGNED(width, 32)) {
2379 SplitUVRow = SplitUVRow_AVX2;
2380 }
2381 }
2382 #endif
2383 #if defined(HAS_SPLITUVROW_NEON)
2384 if (TestCpuFlag(kCpuHasNEON)) {
2385 SplitUVRow = SplitUVRow_Any_NEON;
2386 if (IS_ALIGNED(width, 16)) {
2387 SplitUVRow = SplitUVRow_NEON;
2388 }
2389 }
2390 #endif
2391 #if defined(HAS_INTERPOLATEROW_SSE2)
2392 if (TestCpuFlag(kCpuHasSSE2)) {
2393 InterpolateRow = InterpolateRow_Any_SSE2;
2394 if (IS_ALIGNED(width, 16)) {
2395 InterpolateRow = InterpolateRow_SSE2;
2396 }
2397 }
2398 #endif
2399 #if defined(HAS_INTERPOLATEROW_SSSE3)
2400 if (TestCpuFlag(kCpuHasSSSE3)) {
2401 InterpolateRow = InterpolateRow_Any_SSSE3;
2402 if (IS_ALIGNED(width, 16)) {
2403 InterpolateRow = InterpolateRow_SSSE3;
2404 }
2405 }
2406 #endif
2407 #if defined(HAS_INTERPOLATEROW_AVX2)
2408 if (TestCpuFlag(kCpuHasAVX2)) {
2409 InterpolateRow = InterpolateRow_Any_AVX2;
2410 if (IS_ALIGNED(width, 32)) {
2411 InterpolateRow = InterpolateRow_AVX2;
2412 }
2413 }
2414 #endif
2415 #if defined(HAS_INTERPOLATEROW_NEON)
2416 if (TestCpuFlag(kCpuHasNEON)) {
2417 InterpolateRow = InterpolateRow_Any_NEON;
2418 if (IS_ALIGNED(width, 16)) {
2419 InterpolateRow = InterpolateRow_NEON;
2420 }
2421 }
2422 #endif
2423
2424 {
2425 int awidth = halfwidth * 2;
2426 // 2 rows of uv
2427 align_buffer_64(rows, awidth * 2);
2428
2429 for (y = 0; y < height - 1; y += 2) {
2430 // Split Y from UV.
2431 SplitUVRow(src_yuy2, dst_y, rows, awidth);
2432 SplitUVRow(src_yuy2 + src_stride_yuy2, dst_y + dst_stride_y,
2433 rows + awidth, awidth);
2434 InterpolateRow(dst_uv, rows, awidth, awidth, 128);
2435 src_yuy2 += src_stride_yuy2 * 2;
2436 dst_y += dst_stride_y * 2;
2437 dst_uv += dst_stride_uv;
2438 }
2439 if (height & 1) {
2440 // Split Y from UV.
2441 SplitUVRow(src_yuy2, dst_y, dst_uv, width);
2442 }
2443 free_aligned_buffer_64(rows);
2444 }
2445 return 0;
2446 }
2447
2448 LIBYUV_API
UYVYToNV12(const uint8 * src_uyvy,int src_stride_uyvy,uint8 * dst_y,int dst_stride_y,uint8 * dst_uv,int dst_stride_uv,int width,int height)2449 int UYVYToNV12(const uint8* src_uyvy, int src_stride_uyvy,
2450 uint8* dst_y, int dst_stride_y,
2451 uint8* dst_uv, int dst_stride_uv,
2452 int width, int height) {
2453 int y;
2454 int halfwidth = (width + 1) >> 1;
2455 void (*SplitUVRow)(const uint8* src_uv, uint8* dst_u, uint8* dst_v, int pix) =
2456 SplitUVRow_C;
2457 void (*InterpolateRow)(uint8* dst_ptr, const uint8* src_ptr,
2458 ptrdiff_t src_stride, int dst_width,
2459 int source_y_fraction) = InterpolateRow_C;
2460 if (!src_uyvy ||
2461 !dst_y || !dst_uv ||
2462 width <= 0 || height == 0) {
2463 return -1;
2464 }
2465 // Negative height means invert the image.
2466 if (height < 0) {
2467 height = -height;
2468 src_uyvy = src_uyvy + (height - 1) * src_stride_uyvy;
2469 src_stride_uyvy = -src_stride_uyvy;
2470 }
2471 #if defined(HAS_SPLITUVROW_SSE2)
2472 if (TestCpuFlag(kCpuHasSSE2)) {
2473 SplitUVRow = SplitUVRow_Any_SSE2;
2474 if (IS_ALIGNED(width, 16)) {
2475 SplitUVRow = SplitUVRow_SSE2;
2476 }
2477 }
2478 #endif
2479 #if defined(HAS_SPLITUVROW_AVX2)
2480 if (TestCpuFlag(kCpuHasAVX2)) {
2481 SplitUVRow = SplitUVRow_Any_AVX2;
2482 if (IS_ALIGNED(width, 32)) {
2483 SplitUVRow = SplitUVRow_AVX2;
2484 }
2485 }
2486 #endif
2487 #if defined(HAS_SPLITUVROW_NEON)
2488 if (TestCpuFlag(kCpuHasNEON)) {
2489 SplitUVRow = SplitUVRow_Any_NEON;
2490 if (IS_ALIGNED(width, 16)) {
2491 SplitUVRow = SplitUVRow_NEON;
2492 }
2493 }
2494 #endif
2495 #if defined(HAS_INTERPOLATEROW_SSE2)
2496 if (TestCpuFlag(kCpuHasSSE2)) {
2497 InterpolateRow = InterpolateRow_Any_SSE2;
2498 if (IS_ALIGNED(width, 16)) {
2499 InterpolateRow = InterpolateRow_SSE2;
2500 }
2501 }
2502 #endif
2503 #if defined(HAS_INTERPOLATEROW_SSSE3)
2504 if (TestCpuFlag(kCpuHasSSSE3)) {
2505 InterpolateRow = InterpolateRow_Any_SSSE3;
2506 if (IS_ALIGNED(width, 16)) {
2507 InterpolateRow = InterpolateRow_SSSE3;
2508 }
2509 }
2510 #endif
2511 #if defined(HAS_INTERPOLATEROW_AVX2)
2512 if (TestCpuFlag(kCpuHasAVX2)) {
2513 InterpolateRow = InterpolateRow_Any_AVX2;
2514 if (IS_ALIGNED(width, 32)) {
2515 InterpolateRow = InterpolateRow_AVX2;
2516 }
2517 }
2518 #endif
2519 #if defined(HAS_INTERPOLATEROW_NEON)
2520 if (TestCpuFlag(kCpuHasNEON)) {
2521 InterpolateRow = InterpolateRow_Any_NEON;
2522 if (IS_ALIGNED(width, 16)) {
2523 InterpolateRow = InterpolateRow_NEON;
2524 }
2525 }
2526 #endif
2527
2528 {
2529 int awidth = halfwidth * 2;
2530 // 2 rows of uv
2531 align_buffer_64(rows, awidth * 2);
2532
2533 for (y = 0; y < height - 1; y += 2) {
2534 // Split Y from UV.
2535 SplitUVRow(src_uyvy, rows, dst_y, awidth);
2536 SplitUVRow(src_uyvy + src_stride_uyvy, rows + awidth,
2537 dst_y + dst_stride_y, awidth);
2538 InterpolateRow(dst_uv, rows, awidth, awidth, 128);
2539 src_uyvy += src_stride_uyvy * 2;
2540 dst_y += dst_stride_y * 2;
2541 dst_uv += dst_stride_uv;
2542 }
2543 if (height & 1) {
2544 // Split Y from UV.
2545 SplitUVRow(src_uyvy, dst_y, dst_uv, width);
2546 }
2547 free_aligned_buffer_64(rows);
2548 }
2549 return 0;
2550 }
2551
2552 #ifdef __cplusplus
2553 } // extern "C"
2554 } // namespace libyuv
2555 #endif
2556