FFmpeg
Loading...
Searching...
No Matches
sw_rgb.c
Go to the documentation of this file.
1/*
2 *
3 * This file is part of FFmpeg.
4 *
5 * FFmpeg is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * FFmpeg is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20#include <string.h>
21
22#include "libavutil/common.h"
23#include "libavutil/intreadwrite.h"
24#include "libavutil/mem_internal.h"
25#include "libavutil/pixdesc.h"
26
27#include "libswscale/rgb2rgb.h"
28#include "libswscale/swscale.h"
29#include "libswscale/swscale_internal.h"
30
31#include "checkasm.h"
32
33#define randomize_buffers(buf, size) \
34 do { \
35 int j; \
36 for (j = 0; j < size; j+=4) \
37 AV_WN32(buf + j, rnd()); \
38 } while (0)
39
40static const uint8_t width[] = {12, 16, 20, 32, 36, 128};
41static const struct {uint8_t w, h;} planes[] = {
42 {12,16}, {16,16}, {20,23}, {32,18}, {8,128}, {128,128},
43 {1,1}, {1,4}, {3,8}, {13,16}, {21,9}, {63,7}, {127,5},
44 {13,1}, {32,1}, {66,1}
45};
46
47#define MAX_STRIDE 128
48#define MAX_HEIGHT 128
49
50static void check_shuffle_bytes(void * func, const char * report)
51{
52 int i;
53 LOCAL_ALIGNED_32(uint8_t, src0, [MAX_STRIDE]);
54 LOCAL_ALIGNED_32(uint8_t, src1, [MAX_STRIDE]);
55 LOCAL_ALIGNED_32(uint8_t, dst0, [MAX_STRIDE]);
56 LOCAL_ALIGNED_32(uint8_t, dst1, [MAX_STRIDE]);
57
58 declare_func(void, const uint8_t *src, uint8_t *dst, int src_size);
59
60 memset(dst0, 0, MAX_STRIDE);
61 memset(dst1, 0, MAX_STRIDE);
62 randomize_buffers(src0, MAX_STRIDE);
63 memcpy(src1, src0, MAX_STRIDE);
64
65 if (check_func(func, "%s", report)) {
66 for (i = 0; i < 6; i ++) {
67 call_ref(src0, dst0, width[i]);
68 call_new(src1, dst1, width[i]);
69 if (memcmp(dst0, dst1, MAX_STRIDE))
70 fail();
71 }
72 bench_new(src0, dst0, width[5]);
73 }
74}
75
76static void check_interleaved_to_planar(void *func, const char *report, int odd_tail)
77{
78 int i;
79
80 LOCAL_ALIGNED_32(uint8_t, src0, [MAX_STRIDE * MAX_HEIGHT * 2]);
81 LOCAL_ALIGNED_32(uint8_t, src1, [MAX_STRIDE * MAX_HEIGHT * 2]);
82 LOCAL_ALIGNED_32(uint8_t, dst_y_0, [MAX_STRIDE * MAX_HEIGHT]);
83 LOCAL_ALIGNED_32(uint8_t, dst_y_1, [MAX_STRIDE * MAX_HEIGHT]);
84 LOCAL_ALIGNED_32(uint8_t, dst_u_0, [(MAX_STRIDE/2) * MAX_HEIGHT]);
85 LOCAL_ALIGNED_32(uint8_t, dst_u_1, [(MAX_STRIDE/2) * MAX_HEIGHT]);
86 LOCAL_ALIGNED_32(uint8_t, dst_v_0, [(MAX_STRIDE/2) * MAX_HEIGHT]);
87 LOCAL_ALIGNED_32(uint8_t, dst_v_1, [(MAX_STRIDE/2) * MAX_HEIGHT]);
88
89 declare_func(void, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
90 const uint8_t *src, int width, int height,
91 int lumStride, int chromStride, int srcStride);
92
93 randomize_buffers(src0, MAX_STRIDE * MAX_HEIGHT * 2);
94 memcpy(src1, src0, MAX_STRIDE * MAX_HEIGHT * 2);
95
96 if (check_func(func, "%s", report)) {
97 for (i = 0; i < FF_ARRAY_ELEMS(planes); i ++) {
98 int w = planes[i].w, h = planes[i].h;
99 int srcStride = 2 * w + (w & 1 ? odd_tail : 0);
100
101 memset(dst_y_0, 0, MAX_STRIDE * MAX_HEIGHT);
102 memset(dst_y_1, 0, MAX_STRIDE * MAX_HEIGHT);
103 memset(dst_u_0, 0, (MAX_STRIDE/2) * MAX_HEIGHT);
104 memset(dst_u_1, 0, (MAX_STRIDE/2) * MAX_HEIGHT);
105 memset(dst_v_0, 0, (MAX_STRIDE/2) * MAX_HEIGHT);
106 memset(dst_v_1, 0, (MAX_STRIDE/2) * MAX_HEIGHT);
107
108 call_ref(dst_y_0, dst_u_0, dst_v_0, src0, w, h,
109 MAX_STRIDE, MAX_STRIDE / 2, srcStride);
110 call_new(dst_y_1, dst_u_1, dst_v_1, src1, w, h,
111 MAX_STRIDE, MAX_STRIDE / 2, srcStride);
112 if (memcmp(dst_y_0, dst_y_1, MAX_STRIDE * MAX_HEIGHT) ||
113 memcmp(dst_u_0, dst_u_1, (MAX_STRIDE/2) * MAX_HEIGHT) ||
114 memcmp(dst_v_0, dst_v_1, (MAX_STRIDE/2) * MAX_HEIGHT))
115 fail();
116 }
117 bench_new(dst_y_1, dst_u_1, dst_v_1, src1, planes[5].w, planes[5].h,
118 MAX_STRIDE, MAX_STRIDE / 2, 2 * planes[5].w);
119 }
120}
121
122#define NUM_LINES 5
123#define MAX_LINE_SIZE 1920
124#define BUFSIZE (NUM_LINES * MAX_LINE_SIZE)
125
126static int cmp_off_by_n(const uint8_t *ref, const uint8_t *test, size_t n, int accuracy)
127{
128 for (size_t i = 0; i < n; i++) {
129 if (abs(ref[i] - test[i]) > accuracy)
130 return 1;
131 }
132 return 0;
133}
134
135static void check_rgb24toyv12(SwsContext *sws)
136{
137 static const int input_sizes[] = {16, 128, 512, MAX_LINE_SIZE, -MAX_LINE_SIZE};
138 SwsInternal *ctx = sws_internal(sws);
139
140 LOCAL_ALIGNED_32(uint8_t, src, [BUFSIZE * 3]);
141 LOCAL_ALIGNED_32(uint8_t, buf_y_0, [BUFSIZE]);
142 LOCAL_ALIGNED_32(uint8_t, buf_y_1, [BUFSIZE]);
143 LOCAL_ALIGNED_32(uint8_t, buf_u_0, [BUFSIZE / 4]);
144 LOCAL_ALIGNED_32(uint8_t, buf_u_1, [BUFSIZE / 4]);
145 LOCAL_ALIGNED_32(uint8_t, buf_v_0, [BUFSIZE / 4]);
146 LOCAL_ALIGNED_32(uint8_t, buf_v_1, [BUFSIZE / 4]);
147
148 declare_func(void, const uint8_t *src, uint8_t *ydst, uint8_t *udst,
149 uint8_t *vdst, int width, int height, int lumStride,
150 int chromStride, int srcStride, const int32_t *rgb2yuv);
151
152 randomize_buffers(src, BUFSIZE * 3);
153
154 for (int isi = 0; isi < FF_ARRAY_ELEMS(input_sizes); isi++) {
155 int input_size = input_sizes[isi];
156 int negstride = input_size < 0;
157 const char *negstride_str = negstride ? "_negstride" : "";
158 int width = FFABS(input_size);
159 int linesize = width + 32;
160 /* calculate height based on specified width to use the entire buffer. */
161 int height = (BUFSIZE / linesize) & ~1;
162 uint8_t *src0 = src;
163 uint8_t *src1 = src;
164 uint8_t *dst_y_0 = buf_y_0;
165 uint8_t *dst_y_1 = buf_y_1;
166 uint8_t *dst_u_0 = buf_u_0;
167 uint8_t *dst_u_1 = buf_u_1;
168 uint8_t *dst_v_0 = buf_v_0;
169 uint8_t *dst_v_1 = buf_v_1;
170
171 if (negstride) {
172 src0 += (height - 1) * (linesize * 3);
173 src1 += (height - 1) * (linesize * 3);
174 dst_y_0 += (height - 1) * linesize;
175 dst_y_1 += (height - 1) * linesize;
176 dst_u_0 += ((height / 2) - 1) * (linesize / 2);
177 dst_u_1 += ((height / 2) - 1) * (linesize / 2);
178 dst_v_0 += ((height / 2) - 1) * (linesize / 2);
179 dst_v_1 += ((height / 2) - 1) * (linesize / 2);
180 linesize *= -1;
181 }
182
183 if (check_func(ff_rgb24toyv12, "rgb24toyv12_%d_%d%s", width, height, negstride_str)) {
184 memset(buf_y_0, 0xFF, BUFSIZE);
185 memset(buf_y_1, 0xFF, BUFSIZE);
186 memset(buf_u_0, 0xFF, BUFSIZE / 4);
187 memset(buf_u_1, 0xFF, BUFSIZE / 4);
188 memset(buf_v_0, 0xFF, BUFSIZE / 4);
189 memset(buf_v_1, 0xFF, BUFSIZE / 4);
190
191 call_ref(src0, dst_y_0, dst_u_0, dst_v_0, width, height,
192 linesize, linesize / 2, linesize * 3, ctx->input_rgb2yuv_table);
193 call_new(src1, dst_y_1, dst_u_1, dst_v_1, width, height,
194 linesize, linesize / 2, linesize * 3, ctx->input_rgb2yuv_table);
195 if (cmp_off_by_n(buf_y_0, buf_y_1, BUFSIZE, 1) ||
196 cmp_off_by_n(buf_u_0, buf_u_1, BUFSIZE / 4, 1) ||
197 cmp_off_by_n(buf_v_0, buf_v_1, BUFSIZE / 4, 1))
198 fail();
199 bench_new(src1, dst_y_1, dst_u_1, dst_v_1, width, height,
200 linesize, linesize / 2, linesize * 3, ctx->input_rgb2yuv_table);
201 }
202 }
203}
204
205#undef NUM_LINES
206#undef MAX_LINE_SIZE
207#undef BUFSIZE
208
209static void check_interleave_bytes(void)
210{
211 LOCAL_ALIGNED_16(uint8_t, src0_buf, [MAX_STRIDE*MAX_HEIGHT+1]);
212 LOCAL_ALIGNED_16(uint8_t, src1_buf, [MAX_STRIDE*MAX_HEIGHT+1]);
213 LOCAL_ALIGNED_16(uint8_t, dst0_buf, [2*MAX_STRIDE*MAX_HEIGHT+2]);
214 LOCAL_ALIGNED_16(uint8_t, dst1_buf, [2*MAX_STRIDE*MAX_HEIGHT+2]);
215 // Intentionally using unaligned buffers, as this function doesn't have
216 // any alignment requirements.
217 uint8_t *src0 = src0_buf + 1;
218 uint8_t *src1 = src1_buf + 1;
219 uint8_t *dst0 = dst0_buf + 2;
220 uint8_t *dst1 = dst1_buf + 2;
221
222 declare_func(void, const uint8_t *, const uint8_t *,
223 uint8_t *, int, int, int, int, int);
224
225 randomize_buffers(src0, MAX_STRIDE * MAX_HEIGHT);
226 randomize_buffers(src1, MAX_STRIDE * MAX_HEIGHT);
227
228 if (check_func(interleaveBytes, "interleave_bytes")) {
229 for (int i = 0; i <= 16; i++) {
230 // Try all widths [1,16], and try one random width.
231
232 int w = i > 0 ? i : (1 + (rnd() % (MAX_STRIDE-2)));
233 int h = 1 + (rnd() % (MAX_HEIGHT-2));
234
235 int src0_offset = 0, src0_stride = MAX_STRIDE;
236 int src1_offset = 0, src1_stride = MAX_STRIDE;
237 int dst_offset = 0, dst_stride = 2 * MAX_STRIDE;
238
239 memset(dst0, 0, 2 * MAX_STRIDE * MAX_HEIGHT);
240 memset(dst1, 0, 2 * MAX_STRIDE * MAX_HEIGHT);
241
242 // Try different combinations of negative strides
243 if (i & 1) {
244 src0_offset = (h-1)*src0_stride;
245 src0_stride = -src0_stride;
246 }
247 if (i & 2) {
248 src1_offset = (h-1)*src1_stride;
249 src1_stride = -src1_stride;
250 }
251 if (i & 4) {
252 dst_offset = (h-1)*dst_stride;
253 dst_stride = -dst_stride;
254 }
255
256 call_ref(src0 + src0_offset, src1 + src1_offset, dst0 + dst_offset,
257 w, h, src0_stride, src1_stride, dst_stride);
258 call_new(src0 + src0_offset, src1 + src1_offset, dst1 + dst_offset,
259 w, h, src0_stride, src1_stride, dst_stride);
260 // Check a one pixel-pair edge around the destination area,
261 // to catch overwrites past the end.
262 checkasm_check(uint8_t, dst0, 2*MAX_STRIDE, dst1, 2*MAX_STRIDE,
263 2 * w + 2, h + 1, "dst");
264 }
265
266 bench_new(src0, src1, dst1, 127, MAX_HEIGHT,
267 MAX_STRIDE, MAX_STRIDE, 2*MAX_STRIDE);
268 }
269 if (check_func(interleaveBytes, "interleave_bytes_aligned")) {
270 // Bench the function in a more typical case, with aligned
271 // buffers and widths.
272 bench_new(src0_buf, src1_buf, dst1_buf, 128, MAX_HEIGHT,
273 MAX_STRIDE, MAX_STRIDE, 2*MAX_STRIDE);
274 }
275}
276
277static void check_deinterleave_bytes(void)
278{
279 LOCAL_ALIGNED_16(uint8_t, src_buf, [2*MAX_STRIDE*MAX_HEIGHT+2]);
280 LOCAL_ALIGNED_16(uint8_t, dst0_u_buf, [MAX_STRIDE*MAX_HEIGHT+1]);
281 LOCAL_ALIGNED_16(uint8_t, dst0_v_buf, [MAX_STRIDE*MAX_HEIGHT+1]);
282 LOCAL_ALIGNED_16(uint8_t, dst1_u_buf, [MAX_STRIDE*MAX_HEIGHT+1]);
283 LOCAL_ALIGNED_16(uint8_t, dst1_v_buf, [MAX_STRIDE*MAX_HEIGHT+1]);
284 // Intentionally using unaligned buffers, as this function doesn't have
285 // any alignment requirements.
286 uint8_t *src = src_buf + 2;
287 uint8_t *dst0_u = dst0_u_buf + 1;
288 uint8_t *dst0_v = dst0_v_buf + 1;
289 uint8_t *dst1_u = dst1_u_buf + 1;
290 uint8_t *dst1_v = dst1_v_buf + 1;
291
292 declare_func(void, const uint8_t *src, uint8_t *dst1, uint8_t *dst2,
293 int width, int height, int srcStride,
294 int dst1Stride, int dst2Stride);
295
296 randomize_buffers(src, 2*MAX_STRIDE*MAX_HEIGHT);
297
298 if (check_func(deinterleaveBytes, "deinterleave_bytes")) {
299 for (int i = 0; i <= 16; i++) {
300 // Try all widths [1,16], and try one random width.
301
302 int w = i > 0 ? i : (1 + (rnd() % (MAX_STRIDE-2)));
303 int h = 1 + (rnd() % (MAX_HEIGHT-2));
304
305 int src_offset = 0, src_stride = 2 * MAX_STRIDE;
306 int dst_u_offset = 0, dst_u_stride = MAX_STRIDE;
307 int dst_v_offset = 0, dst_v_stride = MAX_STRIDE;
308
309 memset(dst0_u, 0, MAX_STRIDE * MAX_HEIGHT);
310 memset(dst0_v, 0, MAX_STRIDE * MAX_HEIGHT);
311 memset(dst1_u, 0, MAX_STRIDE * MAX_HEIGHT);
312 memset(dst1_v, 0, MAX_STRIDE * MAX_HEIGHT);
313
314 // Try different combinations of negative strides
315 if (i & 1) {
316 src_offset = (h-1)*src_stride;
317 src_stride = -src_stride;
318 }
319 if (i & 2) {
320 dst_u_offset = (h-1)*dst_u_stride;
321 dst_u_stride = -dst_u_stride;
322 }
323 if (i & 4) {
324 dst_v_offset = (h-1)*dst_v_stride;
325 dst_v_stride = -dst_v_stride;
326 }
327
328 call_ref(src + src_offset, dst0_u + dst_u_offset, dst0_v + dst_v_offset,
329 w, h, src_stride, dst_u_stride, dst_v_stride);
330 call_new(src + src_offset, dst1_u + dst_u_offset, dst1_v + dst_v_offset,
331 w, h, src_stride, dst_u_stride, dst_v_stride);
332 // Check a one pixel-pair edge around the destination area,
333 // to catch overwrites past the end.
334 checkasm_check(uint8_t, dst0_u, MAX_STRIDE, dst1_u, MAX_STRIDE,
335 w + 1, h + 1, "dst_u");
336 checkasm_check(uint8_t, dst0_v, MAX_STRIDE, dst1_v, MAX_STRIDE,
337 w + 1, h + 1, "dst_v");
338 }
339
340 bench_new(src, dst1_u, dst1_v, 127, MAX_HEIGHT,
341 2*MAX_STRIDE, MAX_STRIDE, MAX_STRIDE);
342 }
343 if (check_func(deinterleaveBytes, "deinterleave_bytes_aligned")) {
344 // Bench the function in a more typical case, with aligned
345 // buffers and widths.
346 bench_new(src_buf, dst1_u_buf, dst1_v_buf, 128, MAX_HEIGHT,
347 2*MAX_STRIDE, MAX_STRIDE, MAX_STRIDE);
348 }
349}
350
351#define MAX_LINE_SIZE 1920
352static const int input_sizes[] = {8, 128, 1080, MAX_LINE_SIZE};
361
362static void check_rgb_to_y(SwsContext *sws)
363{
364 SwsInternal *ctx = sws_internal(sws);
365
366 LOCAL_ALIGNED_16(uint8_t, src24, [MAX_LINE_SIZE * 3]);
367 LOCAL_ALIGNED_16(uint8_t, src32, [MAX_LINE_SIZE * 4]);
368 LOCAL_ALIGNED_32(uint8_t, dst0_y, [MAX_LINE_SIZE * 2]);
369 LOCAL_ALIGNED_32(uint8_t, dst1_y, [MAX_LINE_SIZE * 2]);
370
371 declare_func(void, uint8_t *dst, const uint8_t *src,
372 const uint8_t *unused1, const uint8_t *unused2, int width,
373 uint32_t *rgb2yuv, void *opq);
374
375 randomize_buffers(src24, MAX_LINE_SIZE * 3);
376 randomize_buffers(src32, MAX_LINE_SIZE * 4);
377
378 for (int i = 0; i < FF_ARRAY_ELEMS(rgb_formats); i++) {
379 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(rgb_formats[i]);
380
381 sws->src_format = rgb_formats[i];
382 ff_sws_init_scale(ctx);
383
384 for (int j = 0; j < FF_ARRAY_ELEMS(input_sizes); j++) {
385 int w = input_sizes[j];
386
387 if (check_func(ctx->lumToYV12, "%s_to_y_%d", desc->name, w)) {
388 const uint8_t *src = desc->nb_components == 3 ? src24 : src32;
389 memset(dst0_y, 0xFA, MAX_LINE_SIZE * 2);
390 memset(dst1_y, 0xFA, MAX_LINE_SIZE * 2);
391
392 call_ref(dst0_y, src, NULL, NULL, w, ctx->input_rgb2yuv_table, NULL);
393 call_new(dst1_y, src, NULL, NULL, w, ctx->input_rgb2yuv_table, NULL);
394
395 if (memcmp(dst0_y, dst1_y, w * 2))
396 fail();
397
398 if (desc->nb_components == 3 ||
399 // only bench native endian formats
400 (sws->src_format == AV_PIX_FMT_RGB32 || sws->src_format == AV_PIX_FMT_RGB32_1))
401 bench_new(dst1_y, src, NULL, NULL, w, ctx->input_rgb2yuv_table, NULL);
402 }
403 }
404 }
405}
406
407static void check_rgb_to_uv(SwsContext *sws)
408{
409 SwsInternal *ctx = sws_internal(sws);
410
411 LOCAL_ALIGNED_16(uint8_t, src24, [MAX_LINE_SIZE * 3]);
412 LOCAL_ALIGNED_16(uint8_t, src32, [MAX_LINE_SIZE * 4]);
413 LOCAL_ALIGNED_16(uint8_t, dst0_u, [MAX_LINE_SIZE * 2]);
414 LOCAL_ALIGNED_16(uint8_t, dst0_v, [MAX_LINE_SIZE * 2]);
415 LOCAL_ALIGNED_16(uint8_t, dst1_u, [MAX_LINE_SIZE * 2]);
416 LOCAL_ALIGNED_16(uint8_t, dst1_v, [MAX_LINE_SIZE * 2]);
417
418 declare_func(void, uint8_t *dstU, uint8_t *dstV,
419 const uint8_t *src1, const uint8_t *src2, const uint8_t *src3,
420 int width, uint32_t *pal, void *opq);
421
422 randomize_buffers(src24, MAX_LINE_SIZE * 3);
423 randomize_buffers(src32, MAX_LINE_SIZE * 4);
424
425 for (int i = 0; i < 2 * FF_ARRAY_ELEMS(rgb_formats); i++) {
426 enum AVPixelFormat src_fmt = rgb_formats[i / 2];
427 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(src_fmt);
428
429 ctx->chrSrcHSubSample = (i % 2) ? 0 : 1;
430 sws->src_format = src_fmt;
431 sws->dst_format = ctx->chrSrcHSubSample ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUV444P;
432 ff_sws_init_scale(ctx);
433
434 for (int j = 0; j < FF_ARRAY_ELEMS(input_sizes); j++) {
435 int w = input_sizes[j] >> ctx->chrSrcHSubSample;
436
437 if (check_func(ctx->chrToYV12, "%s_to_uv%s_%d", desc->name,
438 ctx->chrSrcHSubSample ? "_half" : "",
439 input_sizes[j])) {
440 const uint8_t *src = desc->nb_components == 3 ? src24 : src32;
441 memset(dst0_u, 0xFF, MAX_LINE_SIZE * 2);
442 memset(dst0_v, 0xFF, MAX_LINE_SIZE * 2);
443 memset(dst1_u, 0xFF, MAX_LINE_SIZE * 2);
444 memset(dst1_v, 0xFF, MAX_LINE_SIZE * 2);
445
446 call_ref(dst0_u, dst0_v, NULL, src, src, w, ctx->input_rgb2yuv_table, NULL);
447 call_new(dst1_u, dst1_v, NULL, src, src, w, ctx->input_rgb2yuv_table, NULL);
448
449 if (memcmp(dst0_u, dst1_u, w * 2) || memcmp(dst0_v, dst1_v, w * 2))
450 fail();
451
452 if (desc->nb_components == 3 ||
453 // only bench native endian formats
454 (sws->src_format == AV_PIX_FMT_RGB32 || sws->src_format == AV_PIX_FMT_RGB32_1))
455 bench_new(dst1_u, dst1_v, NULL, src, src, w, ctx->input_rgb2yuv_table, NULL);
456 }
457 }
458 }
459}
460
461static void check_rgba_to_a(SwsContext *sws)
462{
463 SwsInternal *ctx = sws_internal(sws);
464
465 LOCAL_ALIGNED_16(uint8_t, src, [MAX_LINE_SIZE * 4]);
466 LOCAL_ALIGNED_32(uint8_t, dst0_y, [MAX_LINE_SIZE * 2]);
467 LOCAL_ALIGNED_32(uint8_t, dst1_y, [MAX_LINE_SIZE * 2]);
468
469 declare_func(void, uint8_t *dst, const uint8_t *src1,
470 const uint8_t *src2, const uint8_t *src3, int width,
471 uint32_t *rgb2yuv, void *opq);
472
473 randomize_buffers(src, MAX_LINE_SIZE * 4);
474
475 for (int i = 0; i < FF_ARRAY_ELEMS(rgb_formats); i++) {
476 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(rgb_formats[i]);
477 if (desc->nb_components < 4)
478 continue;
479
480 sws->src_format = rgb_formats[i];
481 ff_sws_init_scale(ctx);
482
483 for (int j = 0; j < FF_ARRAY_ELEMS(input_sizes); j++) {
484 int w = input_sizes[j];
485
486 if (check_func(ctx->alpToYV12, "%s_to_y_%d", desc->name, w)) {
487 memset(dst0_y, 0xFA, MAX_LINE_SIZE * 2);
488 memset(dst1_y, 0xFA, MAX_LINE_SIZE * 2);
489
490 call_ref(dst0_y, NULL, NULL, src, w, ctx->input_rgb2yuv_table, NULL);
491 call_new(dst1_y, NULL, NULL, src, w, ctx->input_rgb2yuv_table, NULL);
492
493 if (memcmp(dst0_y, dst1_y, w * 2))
494 fail();
495
496 // only bench native endian formats
497 if (sws->src_format == AV_PIX_FMT_RGB32 || sws->src_format == AV_PIX_FMT_RGB32_1)
498 bench_new(dst1_y, NULL, NULL, src, w, ctx->input_rgb2yuv_table, NULL);
499 }
500 }
501 }
502}
503
504
539
540#define INPUT_SIZE 512
541
542static void check_yuv2packed1(void)
543{
544 static const int alpha_values[] = {0, 2048, 4096};
545
546 declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT,
547 void, SwsInternal *c, const int16_t *lumSrc,
548 const int16_t *chrUSrc[2], const int16_t *chrVSrc[2],
549 const int16_t *alpSrc, uint8_t *dest,
550 int dstW, int uvalpha, int y);
551
552 const int16_t *luma;
553 const int16_t *chru[2];
554 const int16_t *chrv[2];
555 const int16_t *alpha;
556
557 LOCAL_ALIGNED_8(int32_t, src_y, [2 * INPUT_SIZE]);
558 LOCAL_ALIGNED_8(int32_t, src_u, [2 * INPUT_SIZE]);
559 LOCAL_ALIGNED_8(int32_t, src_v, [2 * INPUT_SIZE]);
560 LOCAL_ALIGNED_8(int32_t, src_a, [2 * INPUT_SIZE]);
561
562 LOCAL_ALIGNED_8(uint8_t, dst0, [INPUT_SIZE * sizeof(int32_t[4])]);
563 LOCAL_ALIGNED_8(uint8_t, dst1, [INPUT_SIZE * sizeof(int32_t[4])]);
564
565 randomize_buffers((uint8_t*)src_y, 2 * INPUT_SIZE * sizeof(int32_t));
566 randomize_buffers((uint8_t*)src_u, 2 * INPUT_SIZE * sizeof(int32_t));
567 randomize_buffers((uint8_t*)src_v, 2 * INPUT_SIZE * sizeof(int32_t));
568 randomize_buffers((uint8_t*)src_a, 2 * INPUT_SIZE * sizeof(int32_t));
569
570 /* Limit to 14 bit input range */
571 for (int i = 0; i < 2 * INPUT_SIZE; i++) {
572 src_y[i] &= 0x3FFF3FFF;
573 src_a[i] &= 0x3FFF3FFF;
574 src_u[i] &= 0x3FFF3FFF;
575 src_v[i] &= 0x3FFF3FFF;
576 }
577
578 luma = (int16_t *)src_y;
579 alpha = (int16_t *)src_a;
580 for (int i = 0; i < 2; i++) {
581 chru[i] = (int16_t *)(src_u + i*INPUT_SIZE);
582 chrv[i] = (int16_t *)(src_v + i*INPUT_SIZE);
583 }
584
585 for (int fmi = 0; fmi < FF_ARRAY_ELEMS(packed_rgb_fmts); fmi++) {
586 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(packed_rgb_fmts[fmi]);
587 int line_size = INPUT_SIZE * desc->comp[0].step;
588 SwsContext *sws;
589 SwsInternal *c;
590
591 if (desc->flags & AV_PIX_FMT_FLAG_BITSTREAM)
592 line_size = AV_CEIL_RSHIFT(line_size, 3);
593
594 sws = sws_getContext(MAX_LINE_SIZE, MAX_LINE_SIZE, AV_PIX_FMT_YUV420P,
595 MAX_LINE_SIZE, MAX_LINE_SIZE, packed_rgb_fmts[fmi],
596 SWS_ACCURATE_RND | SWS_BITEXACT, NULL, NULL, NULL);
597 if (!sws)
598 fail();
599
600 c = sws_internal(sws);
601
602 for (int ai = 0; ai < FF_ARRAY_ELEMS(alpha_values); ai++) {
603 const int chr_alpha = alpha_values[ai];
604 if (check_func(c->yuv2packed1, "yuv2%s_1_%d_%d", desc->name, chr_alpha, INPUT_SIZE)) {
605 memset(dst0, 0xFF, INPUT_SIZE * sizeof(int32_t[4]));
606 memset(dst1, 0xFF, INPUT_SIZE * sizeof(int32_t[4]));
607
608 call_ref(c, luma, chru, chrv, alpha, dst0, INPUT_SIZE, chr_alpha, 0);
609 call_new(c, luma, chru, chrv, alpha, dst1, INPUT_SIZE, chr_alpha, 0);
610
611 if (memcmp(dst0, dst1, line_size))
612 fail();
613
614 bench_new(c, luma, chru, chrv, alpha, dst1, INPUT_SIZE, chr_alpha, 0);
615 }
616 }
617
618 sws_freeContext(sws);
619 }
620}
621
622static void check_yuv2packed2(void)
623{
624 static const int alpha_values[] = {0, 2048, 4096};
625
626 declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT,
627 void, SwsInternal *c, const int16_t *lumSrc[2],
628 const int16_t *chrUSrc[2], const int16_t *chrVSrc[2],
629 const int16_t *alpSrc[2], uint8_t *dest,
630 int dstW, int yalpha, int uvalpha, int y);
631
632 const int16_t *luma[2];
633 const int16_t *chru[2];
634 const int16_t *chrv[2];
635 const int16_t *alpha[2];
636
637 LOCAL_ALIGNED_8(int32_t, src_y, [2 * INPUT_SIZE]);
638 LOCAL_ALIGNED_8(int32_t, src_u, [2 * INPUT_SIZE]);
639 LOCAL_ALIGNED_8(int32_t, src_v, [2 * INPUT_SIZE]);
640 LOCAL_ALIGNED_8(int32_t, src_a, [2 * INPUT_SIZE]);
641
642 LOCAL_ALIGNED_8(uint8_t, dst0, [INPUT_SIZE * sizeof(int32_t[4])]);
643 LOCAL_ALIGNED_8(uint8_t, dst1, [INPUT_SIZE * sizeof(int32_t[4])]);
644
645 randomize_buffers((uint8_t*)src_y, 2 * INPUT_SIZE * sizeof(int32_t));
646 randomize_buffers((uint8_t*)src_u, 2 * INPUT_SIZE * sizeof(int32_t));
647 randomize_buffers((uint8_t*)src_v, 2 * INPUT_SIZE * sizeof(int32_t));
648 randomize_buffers((uint8_t*)src_a, 2 * INPUT_SIZE * sizeof(int32_t));
649
650 /* Limit to 14 bit input range */
651 for (int i = 0; i < 2 * INPUT_SIZE; i++) {
652 src_y[i] &= 0x3FFF3FFF;
653 src_u[i] &= 0x3FFF3FFF;
654 src_v[i] &= 0x3FFF3FFF;
655 src_a[i] &= 0x3FFF3FFF;
656 }
657
658 for (int i = 0; i < 2; i++) {
659 luma[i] = (int16_t *)(src_y + i*INPUT_SIZE);
660 chru[i] = (int16_t *)(src_u + i*INPUT_SIZE);
661 chrv[i] = (int16_t *)(src_v + i*INPUT_SIZE);
662 alpha[i] = (int16_t *)(src_a + i*INPUT_SIZE);
663 }
664
665 for (int fmi = 0; fmi < FF_ARRAY_ELEMS(packed_rgb_fmts); fmi++) {
666 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(packed_rgb_fmts[fmi]);
667 int line_size = INPUT_SIZE * desc->comp[0].step;
668 SwsContext *sws;
669 SwsInternal *c;
670
671 if (desc->flags & AV_PIX_FMT_FLAG_BITSTREAM)
672 line_size = AV_CEIL_RSHIFT(line_size, 3);
673
674 sws = sws_getContext(MAX_LINE_SIZE, MAX_LINE_SIZE, AV_PIX_FMT_YUV420P,
675 MAX_LINE_SIZE, MAX_LINE_SIZE, packed_rgb_fmts[fmi],
676 SWS_ACCURATE_RND | SWS_BITEXACT, NULL, NULL, NULL);
677 if (!sws)
678 fail();
679
680 c = sws_internal(sws);
681
682 for (int ai = 0; ai < FF_ARRAY_ELEMS(alpha_values); ai++) {
683 const int lum_alpha = alpha_values[ai];
684 const int chr_alpha = alpha_values[ai];
685 if (check_func(c->yuv2packed2, "yuv2%s_2_%d_%d", desc->name, lum_alpha, INPUT_SIZE)) {
686 memset(dst0, 0xFF, INPUT_SIZE * sizeof(int32_t[4]));
687 memset(dst1, 0xFF, INPUT_SIZE * sizeof(int32_t[4]));
688
689 call_ref(c, luma, chru, chrv, alpha, dst0, INPUT_SIZE, lum_alpha, chr_alpha, 0);
690 call_new(c, luma, chru, chrv, alpha, dst1, INPUT_SIZE, lum_alpha, chr_alpha, 0);
691
692 if (memcmp(dst0, dst1, line_size))
693 fail();
694
695 bench_new(c, luma, chru, chrv, alpha, dst1, INPUT_SIZE, lum_alpha, chr_alpha, 0);
696 }
697 }
698
699 sws_freeContext(sws);
700 }
701}
702
703static void check_yuv2packedX(void)
704{
705#define LARGEST_FILTER 16
706 static const int filter_sizes[] = {2, 16};
707
708 declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT,
709 void, SwsInternal *c, const int16_t *lumFilter,
710 const int16_t **lumSrcx, int lumFilterSize,
711 const int16_t *chrFilter, const int16_t **chrUSrcx,
712 const int16_t **chrVSrcx, int chrFilterSize,
713 const int16_t **alpSrcx, uint8_t *dest,
714 int dstW, int y);
715
716 const int16_t *luma[LARGEST_FILTER];
717 const int16_t *chru[LARGEST_FILTER];
718 const int16_t *chrv[LARGEST_FILTER];
719 const int16_t *alpha[LARGEST_FILTER];
720
721 LOCAL_ALIGNED_8(int16_t, luma_filter, [LARGEST_FILTER]);
722 LOCAL_ALIGNED_8(int16_t, chr_filter, [LARGEST_FILTER]);
723
724 LOCAL_ALIGNED_8(int32_t, src_y, [LARGEST_FILTER * INPUT_SIZE]);
725 LOCAL_ALIGNED_8(int32_t, src_u, [LARGEST_FILTER * INPUT_SIZE]);
726 LOCAL_ALIGNED_8(int32_t, src_v, [LARGEST_FILTER * INPUT_SIZE]);
727 LOCAL_ALIGNED_8(int32_t, src_a, [LARGEST_FILTER * INPUT_SIZE]);
728
729 LOCAL_ALIGNED_8(uint8_t, dst0, [INPUT_SIZE * sizeof(int32_t[4])]);
730 LOCAL_ALIGNED_8(uint8_t, dst1, [INPUT_SIZE * sizeof(int32_t[4])]);
731
732 randomize_buffers((uint8_t*)src_y, LARGEST_FILTER * INPUT_SIZE * sizeof(int32_t));
733 randomize_buffers((uint8_t*)src_u, LARGEST_FILTER * INPUT_SIZE * sizeof(int32_t));
734 randomize_buffers((uint8_t*)src_v, LARGEST_FILTER * INPUT_SIZE * sizeof(int32_t));
735 randomize_buffers((uint8_t*)src_a, LARGEST_FILTER * INPUT_SIZE * sizeof(int32_t));
736
737 /* Limit to 14 bit input range */
738 for (int i = 0; i < LARGEST_FILTER * INPUT_SIZE; i++) {
739 src_y[i] &= 0x3FFF3FFF;
740 src_u[i] &= 0x3FFF3FFF;
741 src_v[i] &= 0x3FFF3FFF;
742 src_a[i] &= 0x3FFF3FFF;
743 }
744
745 for (int i = 0; i < LARGEST_FILTER; i++) {
746 luma[i] = (int16_t *)(src_y + i*INPUT_SIZE);
747 chru[i] = (int16_t *)(src_u + i*INPUT_SIZE);
748 chrv[i] = (int16_t *)(src_v + i*INPUT_SIZE);
749 alpha[i] = (int16_t *)(src_a + i*INPUT_SIZE);
750 }
751
752 for (int fmi = 0; fmi < FF_ARRAY_ELEMS(packed_rgb_fmts); fmi++) {
753 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(packed_rgb_fmts[fmi]);
754 int line_size = INPUT_SIZE * desc->comp[0].step;
755 SwsContext *sws;
756 SwsInternal *c;
757
758 if (desc->flags & AV_PIX_FMT_FLAG_BITSTREAM)
759 line_size = AV_CEIL_RSHIFT(line_size, 3);
760
761 sws = sws_getContext(MAX_LINE_SIZE, MAX_LINE_SIZE, AV_PIX_FMT_YUV420P,
762 MAX_LINE_SIZE, MAX_LINE_SIZE, packed_rgb_fmts[fmi],
763 SWS_ACCURATE_RND | SWS_BITEXACT, NULL, NULL, NULL);
764 if (!sws)
765 fail();
766
767 c = sws_internal(sws);
768
769 for (int fsi = 0; fsi < FF_ARRAY_ELEMS(filter_sizes); fsi++) {
770 const int luma_filter_size = filter_sizes[fsi];
771 const int chr_filter_size = filter_sizes[fsi];
772
773 for (int i = 0; i < luma_filter_size; i++)
774 luma_filter[i] = -((1 << 12) / (luma_filter_size - 1));
775 luma_filter[rnd() % luma_filter_size] = (1 << 13) - 1;
776
777 for (int i = 0; i < chr_filter_size; i++)
778 chr_filter[i] = -((1 << 12) / (chr_filter_size - 1));
779 chr_filter[rnd() % chr_filter_size] = (1 << 13) - 1;
780
781 if (check_func(c->yuv2packedX, "yuv2%s_X_%d_%d", desc->name, luma_filter_size, INPUT_SIZE)) {
782 memset(dst0, 0xFF, INPUT_SIZE * sizeof(int32_t[4]));
783 memset(dst1, 0xFF, INPUT_SIZE * sizeof(int32_t[4]));
784
785 call_ref(c, luma_filter, luma, luma_filter_size,
786 chr_filter, chru, chrv, chr_filter_size,
787 alpha, dst0, INPUT_SIZE, 0);
788
789 call_new(c, luma_filter, luma, luma_filter_size,
790 chr_filter, chru, chrv, chr_filter_size,
791 alpha, dst1, INPUT_SIZE, 0);
792
793 if (memcmp(dst0, dst1, line_size))
794 fail();
795
796 bench_new(c, luma_filter, luma, luma_filter_size,
797 chr_filter, chru, chrv, chr_filter_size,
798 alpha, dst1, INPUT_SIZE, 0);
799 }
800 }
801
802 sws_freeContext(sws);
803 }
804}
805
806#undef INPUT_SIZE
807#undef LARGEST_FILTER
808
809void checkasm_check_sw_rgb(void)
810{
811 SwsContext *sws;
812
813 ff_sws_rgb2rgb_init();
814
815 check_shuffle_bytes(shuffle_bytes_2103, "shuffle_bytes_2103");
816 report("shuffle_bytes_2103");
817
818 check_shuffle_bytes(shuffle_bytes_0321, "shuffle_bytes_0321");
819 report("shuffle_bytes_0321");
820
821 check_shuffle_bytes(shuffle_bytes_1230, "shuffle_bytes_1230");
822 report("shuffle_bytes_1230");
823
824 check_shuffle_bytes(shuffle_bytes_3012, "shuffle_bytes_3012");
825 report("shuffle_bytes_3012");
826
827 check_shuffle_bytes(shuffle_bytes_3210, "shuffle_bytes_3210");
828 report("shuffle_bytes_3210");
829
830 check_shuffle_bytes(shuffle_bytes_3102, "shuffle_bytes_3102");
831 report("shuffle_bytes_3102");
832
833 check_shuffle_bytes(shuffle_bytes_2013, "shuffle_bytes_2013");
834 report("shuffle_bytes_2013");
835
836 check_shuffle_bytes(shuffle_bytes_1203, "shuffle_bytes_1203");
837 report("shuffle_bytes_1203");
838
839 check_shuffle_bytes(shuffle_bytes_2130, "shuffle_bytes_2130");
840 report("shuffle_bytes_2130");
841
842 {
843 /* rgb24tobgr24 operates on 3-byte pixels, so test widths must be
844 * multiples of 3 to avoid reading past the source buffer. */
845 static const int rgb24_width[] = {3, 12, 24, 36, 48, 126, 1920 * 3};
846 int i;
847#define RGB24_BENCH_WIDTH (1920 * 3)
848 LOCAL_ALIGNED_32(uint8_t, src0, [RGB24_BENCH_WIDTH]);
849 LOCAL_ALIGNED_32(uint8_t, src1, [RGB24_BENCH_WIDTH]);
850 LOCAL_ALIGNED_32(uint8_t, dst0, [RGB24_BENCH_WIDTH]);
851 LOCAL_ALIGNED_32(uint8_t, dst1, [RGB24_BENCH_WIDTH]);
852
853 declare_func(void, const uint8_t *src, uint8_t *dst, int src_size);
854
855 memset(dst0, 0, RGB24_BENCH_WIDTH);
856 memset(dst1, 0, RGB24_BENCH_WIDTH);
857 randomize_buffers(src0, RGB24_BENCH_WIDTH);
858 memcpy(src1, src0, RGB24_BENCH_WIDTH);
859
860 if (check_func(rgb24tobgr24, "rgb24tobgr24")) {
861 for (i = 0; i < FF_ARRAY_ELEMS(rgb24_width); i++) {
862 call_ref(src0, dst0, rgb24_width[i]);
863 call_new(src1, dst1, rgb24_width[i]);
864 if (memcmp(dst0, dst1, rgb24_width[i]))
865 fail();
866 }
867 bench_new(src0, dst0, RGB24_BENCH_WIDTH);
868 }
869#undef RGB24_BENCH_WIDTH
870 }
871 report("rgb24tobgr24");
872
873 {
874 /* rgb32tobgr24: 4-byte pixels → 3-byte pixels.
875 * Test widths must be multiples of 4 (one pixel).
876 * Sizes chosen to exercise each codepath tier:
877 * 4 = scalar only (1 pixel)
878 * 16 = scalar only (4 pixels, loop iteration)
879 * 32 = medium only
880 * 48 = medium + scalar
881 * 64 = fast only (exact)
882 * 68 = fast + scalar (skip medium)
883 * 100 = fast + medium + scalar (all tiers)
884 * 128 = fast only (multi-iteration)
885 * 1920*4 = fast only (benchmark width)
886 */
887 static const int rgb32_widths[] = {4, 16, 32, 48, 64, 68, 100, 128, 1920 * 4};
888#define RGB32_BENCH_WIDTH (1920 * 4)
889#define RGB32_DST_SIZE (RGB32_BENCH_WIDTH * 3 / 4 + 8)
890 LOCAL_ALIGNED_32(uint8_t, src0, [RGB32_BENCH_WIDTH]);
891 LOCAL_ALIGNED_32(uint8_t, src1, [RGB32_BENCH_WIDTH]);
892 LOCAL_ALIGNED_32(uint8_t, dst0, [RGB32_DST_SIZE]);
893 LOCAL_ALIGNED_32(uint8_t, dst1, [RGB32_DST_SIZE]);
894
895 declare_func(void, const uint8_t *src, uint8_t *dst, int src_size);
896
897 randomize_buffers(src0, RGB32_BENCH_WIDTH);
898 memcpy(src1, src0, RGB32_BENCH_WIDTH);
899
900 if (check_func(rgb32tobgr24, "rgb32tobgr24")) {
901 for (int i = 0; i < FF_ARRAY_ELEMS(rgb32_widths); i++) {
902 int out_size = rgb32_widths[i] * 3 / 4;
903 memset(dst0, 0xAA, RGB32_DST_SIZE);
904 memset(dst1, 0xAA, RGB32_DST_SIZE);
905 call_ref(src0, dst0, rgb32_widths[i]);
906 call_new(src1, dst1, rgb32_widths[i]);
907 if (memcmp(dst0, dst1, out_size) ||
908 dst0[out_size] != 0xAA ||
909 dst1[out_size] != 0xAA)
910 fail();
911 }
912 bench_new(src0, dst0, RGB32_BENCH_WIDTH);
913 }
914#undef RGB32_DST_SIZE
915#undef RGB32_BENCH_WIDTH
916 }
917 report("rgb32tobgr24");
918
919 {
920 /* rgb24tobgr32: 3-byte pixels → 4-byte pixels.
921 * Test widths must be multiples of 3 (one pixel).
922 * Sizes chosen to exercise each codepath tier:
923 * 3 = scalar only (1 pixel)
924 * 12 = scalar only (4 pixels, loop iteration)
925 * 24 = medium only
926 * 36 = medium + scalar
927 * 48 = fast only (exact)
928 * 51 = fast + scalar (skip medium)
929 * 126 = fast + medium + scalar (all tiers)
930 * 1920*3 = fast only (benchmark width)
931 */
932 static const int rgb24to32_widths[] = {3, 12, 24, 36, 48, 51, 126, 1920 * 3};
933#define RGB24TO32_BENCH_WIDTH (1920 * 3)
934#define RGB24TO32_DST_SIZE (RGB24TO32_BENCH_WIDTH * 4 / 3 + 8)
935 LOCAL_ALIGNED_32(uint8_t, src0, [RGB24TO32_BENCH_WIDTH]);
936 LOCAL_ALIGNED_32(uint8_t, src1, [RGB24TO32_BENCH_WIDTH]);
937 LOCAL_ALIGNED_32(uint8_t, dst0, [RGB24TO32_DST_SIZE]);
938 LOCAL_ALIGNED_32(uint8_t, dst1, [RGB24TO32_DST_SIZE]);
939
940 declare_func(void, const uint8_t *src, uint8_t *dst, int src_size);
941
942 randomize_buffers(src0, RGB24TO32_BENCH_WIDTH);
943 memcpy(src1, src0, RGB24TO32_BENCH_WIDTH);
944
945 if (check_func(rgb24tobgr32, "rgb24tobgr32")) {
946 for (int i = 0; i < FF_ARRAY_ELEMS(rgb24to32_widths); i++) {
947 int out_size = rgb24to32_widths[i] * 4 / 3;
948 memset(dst0, 0xAA, RGB24TO32_DST_SIZE);
949 memset(dst1, 0xAA, RGB24TO32_DST_SIZE);
950 call_ref(src0, dst0, rgb24to32_widths[i]);
951 call_new(src1, dst1, rgb24to32_widths[i]);
952 if (memcmp(dst0, dst1, out_size) ||
953 dst0[out_size] != 0xAA ||
954 dst1[out_size] != 0xAA)
955 fail();
956 }
957 bench_new(src0, dst0, RGB24TO32_BENCH_WIDTH);
958 }
959#undef RGB24TO32_DST_SIZE
960#undef RGB24TO32_BENCH_WIDTH
961 }
962 report("rgb24tobgr32");
963
964 check_interleaved_to_planar(uyvytoyuv422, "uyvytoyuv422", 1);
965 report("uyvytoyuv422");
966 check_interleaved_to_planar(yuyvtoyuv422, "yuyvtoyuv422", 2);
967 report("yuyvtoyuv422");
968 check_interleaved_to_planar(uyvytoyuv420, "uyvytoyuv420", 1);
969 report("uyvytoyuv420");
970 check_interleaved_to_planar(yuyvtoyuv420, "yuyvtoyuv420", 2);
971 report("yuyvtoyuv420");
972
973 check_interleave_bytes();
974 report("interleave_bytes");
975
976 check_deinterleave_bytes();
977 report("deinterleave_bytes");
978
979 sws = sws_getContext(MAX_LINE_SIZE, MAX_LINE_SIZE, AV_PIX_FMT_RGB24,
980 MAX_LINE_SIZE, MAX_LINE_SIZE, AV_PIX_FMT_YUV420P,
981 SWS_ACCURATE_RND | SWS_BITEXACT, NULL, NULL, NULL);
982 if (!sws)
983 fail();
984
985 check_rgb_to_y(sws);
986 report("rgb_to_y");
987
988 check_rgb_to_uv(sws);
989 report("rgb_to_uv");
990
991 check_rgba_to_a(sws);
992 report("rgba_to_a");
993
994 check_rgb24toyv12(sws);
995 report("rgb24toyv12");
996
997 sws_freeContext(sws);
998
999 check_yuv2packed1();
1000 report("yuv2packed1");
1001
1002 check_yuv2packed2();
1003 report("yuv2packed2");
1004
1005 check_yuv2packedX();
1006 report("yuv2packedX");
1007}
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition dsp.h:97
INPUT_SIZE
#define INPUT_SIZE
Definition af_arnndn.c:1332
out_size
static int out_size
Definition api-movenc-test.c:56
ctx
static AVFormatContext * ctx
Definition api-movenc-test.c:49
int32_t
int32_t
Definition audioconvert.c:58
i
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
rnd
#define rnd
Definition checkasm.h:137
rgb2yuv
static void fn rgb2yuv(uint8_t *_yuv[3], const ptrdiff_t yuv_stride[3], int16_t *rgb[3], ptrdiff_t s, int w, int h, const int16_t rgb2yuv_coeffs[3][3][8], const int16_t yuv_offset[8])
Definition colorspacedsp_template.c:130
common.h
common internal and external API header
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition common.h:60
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition common.h:74
NULL
#define NULL
Definition coverity.c:32
abs
#define abs(x)
Definition cuda_runtime.h:35
declare_func
#define declare_func
Definition test.h:489
fail
#define fail
Definition test.h:479
bench_new
#define bench_new
Definition test.h:487
check_func
#define check_func
Definition test.h:481
call_new
#define call_new
Definition test.h:486
call_ref
#define call_ref
Definition test.h:485
report
#define report
Definition test.h:480
declare_func_emms
#define declare_func_emms
Definition test.h:490
sws_getContext
SwsContext * sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat, int dstW, int dstH, enum AVPixelFormat dstFormat, int flags, SwsFilter *srcFilter, SwsFilter *dstFilter, const double *param)
Allocate and return an SwsContext.
Definition utils.c:1972
sws_freeContext
void sws_freeContext(SwsContext *swsContext)
Free the swscaler context swsContext.
Definition utils.c:2303
SWS_BITEXACT
@ SWS_BITEXACT
Definition swscale.h:178
SWS_ACCURATE_RND
@ SWS_ACCURATE_RND
Force bit-exact output.
Definition swscale.h:177
src2
const pixel * src2
Definition h264pred_template.c:421
BUFSIZE
#define BUFSIZE
Definition hlsenc.c:78
alpha
static const int16_t alpha[]
Definition ilbcdata.h:55
func
int(* func)(AVBPrint *dst, const char *in, const char *arg)
Definition jacosubdec.c:66
AV_CPU_FLAG_MMXEXT
#define AV_CPU_FLAG_MMXEXT
SSE integer functions or AMD MMX ext.
Definition cpu.h:33
AV_CPU_FLAG_MMX
#define AV_CPU_FLAG_MMX
standard MMX
Definition cpu.h:32
desc
const char * desc
Definition libsvtav1.c:83
planes
static const struct @257111027162314367033347246032313251342043035002 planes[]
w
uint8_t w
Definition llvidencdsp.c:39
mem_internal.h
LOCAL_ALIGNED_32
#define LOCAL_ALIGNED_32(t, v,...)
Definition mem_internal.h:132
LOCAL_ALIGNED_16
#define LOCAL_ALIGNED_16(t, v,...)
Definition mem_internal.h:130
LOCAL_ALIGNED_8
#define LOCAL_ALIGNED_8(t, v,...)
Definition mem_internal.h:128
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition pixdesc.c:3484
AV_PIX_FMT_FLAG_BITSTREAM
#define AV_PIX_FMT_FLAG_BITSTREAM
All values of a component are bit-wise packed end to end.
Definition pixdesc.h:124
AVPixelFormat
AVPixelFormat
Pixel format.
Definition pixfmt.h:71
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition pixfmt.h:75
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition pixfmt.h:73
AV_PIX_FMT_BGR565BE
@ AV_PIX_FMT_BGR565BE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
Definition pixfmt.h:117
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition pixfmt.h:99
AV_PIX_FMT_RGB555BE
@ AV_PIX_FMT_RGB555BE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
Definition pixfmt.h:114
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition pixfmt.h:102
AV_PIX_FMT_BGR48BE
@ AV_PIX_FMT_BGR48BE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big...
Definition pixfmt.h:145
AV_PIX_FMT_RGB48BE
@ AV_PIX_FMT_RGB48BE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
Definition pixfmt.h:109
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition pixfmt.h:101
AV_PIX_FMT_RGBA64BE
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition pixfmt.h:202
AV_PIX_FMT_RGB8
@ AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)3R 3G 2B(lsb)
Definition pixfmt.h:93
AV_PIX_FMT_RGBA64LE
@ AV_PIX_FMT_RGBA64LE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition pixfmt.h:203
AV_PIX_FMT_BGR8
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition pixfmt.h:90
AV_PIX_FMT_RGB444LE
@ AV_PIX_FMT_RGB444LE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined
Definition pixfmt.h:136
AV_PIX_FMT_RGB4_BYTE
@ AV_PIX_FMT_RGB4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition pixfmt.h:95
AV_PIX_FMT_BGR4_BYTE
@ AV_PIX_FMT_BGR4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition pixfmt.h:92
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition pixfmt.h:100
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition pixfmt.h:78
AV_PIX_FMT_BGRA64BE
@ AV_PIX_FMT_BGRA64BE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition pixfmt.h:204
AV_PIX_FMT_RGB565LE
@ AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition pixfmt.h:113
AV_PIX_FMT_RGB555LE
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
Definition pixfmt.h:115
AV_PIX_FMT_BGR444BE
@ AV_PIX_FMT_BGR444BE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
Definition pixfmt.h:139
AV_PIX_FMT_RGB48LE
@ AV_PIX_FMT_RGB48LE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as lit...
Definition pixfmt.h:110
AV_PIX_FMT_BGR555BE
@ AV_PIX_FMT_BGR555BE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined
Definition pixfmt.h:119
AV_PIX_FMT_BGR444LE
@ AV_PIX_FMT_BGR444LE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined
Definition pixfmt.h:138
AV_PIX_FMT_RGB444BE
@ AV_PIX_FMT_RGB444BE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
Definition pixfmt.h:137
AV_PIX_FMT_BGR48LE
@ AV_PIX_FMT_BGR48LE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as lit...
Definition pixfmt.h:146
AV_PIX_FMT_RGB565BE
@ AV_PIX_FMT_RGB565BE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
Definition pixfmt.h:112
AV_PIX_FMT_BGR555LE
@ AV_PIX_FMT_BGR555LE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
Definition pixfmt.h:120
AV_PIX_FMT_BGRA64LE
@ AV_PIX_FMT_BGRA64LE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition pixfmt.h:205
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition pixfmt.h:76
AV_PIX_FMT_BGR565LE
@ AV_PIX_FMT_BGR565LE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
Definition pixfmt.h:118
AV_PIX_FMT_RGB4
@ AV_PIX_FMT_RGB4
packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in ...
Definition pixfmt.h:94
AV_PIX_FMT_BGR4
@ AV_PIX_FMT_BGR4
packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in ...
Definition pixfmt.h:91
AV_PIX_FMT_RGB32_1
#define AV_PIX_FMT_RGB32_1
Definition pixfmt.h:521
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition pixfmt.h:520
rgb24tobgr32
void(* rgb24tobgr32)(const uint8_t *src, uint8_t *dst, int src_size)
Definition rgb2rgb.c:38
ff_sws_rgb2rgb_init
av_cold void ff_sws_rgb2rgb_init(void)
Definition rgb2rgb.c:127
shuffle_bytes_2013
void(* shuffle_bytes_2013)(const uint8_t *src, uint8_t *dst, int src_size)
Definition rgb2rgb.c:60
ff_rgb24toyv12
void(* ff_rgb24toyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst, int width, int height, int lumStride, int chromStride, int srcStride, const int32_t *rgb2yuv)
Height should be a multiple of 2 and width should be a multiple of 2.
Definition rgb2rgb.c:81
shuffle_bytes_3102
void(* shuffle_bytes_3102)(const uint8_t *src, uint8_t *dst, int src_size)
Definition rgb2rgb.c:59
uyvytoyuv420
void(* uyvytoyuv420)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src, int width, int height, int lumStride, int chromStride, int srcStride)
Definition rgb2rgb.c:94
shuffle_bytes_2130
void(* shuffle_bytes_2130)(const uint8_t *src, uint8_t *dst, int src_size)
Definition rgb2rgb.c:61
shuffle_bytes_3210
void(* shuffle_bytes_3210)(const uint8_t *src, uint8_t *dst, int src_size)
Definition rgb2rgb.c:58
shuffle_bytes_3012
void(* shuffle_bytes_3012)(const uint8_t *src, uint8_t *dst, int src_size)
Definition rgb2rgb.c:57
shuffle_bytes_2103
void(* shuffle_bytes_2103)(const uint8_t *src, uint8_t *dst, int src_size)
Definition rgb2rgb.c:55
shuffle_bytes_1203
void(* shuffle_bytes_1203)(const uint8_t *src, uint8_t *dst, int src_size)
Definition rgb2rgb.c:62
yuyvtoyuv420
void(* yuyvtoyuv420)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src, int width, int height, int lumStride, int chromStride, int srcStride)
Definition rgb2rgb.c:100
interleaveBytes
void(* interleaveBytes)(const uint8_t *src1, const uint8_t *src2, uint8_t *dst, int width, int height, int src1Stride, int src2Stride, int dstStride)
Definition rgb2rgb.c:88
shuffle_bytes_1230
void(* shuffle_bytes_1230)(const uint8_t *src, uint8_t *dst, int src_size)
Definition rgb2rgb.c:56
rgb32tobgr24
void(* rgb32tobgr24)(const uint8_t *src, uint8_t *dst, int src_size)
Definition rgb2rgb.c:35
deinterleaveBytes
void(* deinterleaveBytes)(const uint8_t *src, uint8_t *dst1, uint8_t *dst2, int width, int height, int srcStride, int dst1Stride, int dst2Stride)
Definition rgb2rgb.c:91
yuyvtoyuv422
void(* yuyvtoyuv422)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src, int width, int height, int lumStride, int chromStride, int srcStride)
Definition rgb2rgb.c:103
uyvytoyuv422
void(* uyvytoyuv422)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src, int width, int height, int lumStride, int chromStride, int srcStride)
Definition rgb2rgb.c:97
rgb24tobgr24
void(* rgb24tobgr24)(const uint8_t *src, uint8_t *dst, int src_size)
Definition rgb2rgb.c:39
shuffle_bytes_0321
void(* shuffle_bytes_0321)(const uint8_t *src, uint8_t *dst, int src_size)
Definition rgb2rgb.c:54
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition sinewin_tablegen.c:29
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition pixdesc.h:69
SwsContext
Main external API structure.
Definition swscale.h:227
SwsContext::dst_format
int dst_format
Destination pixel format.
Definition swscale.h:275
SwsContext::src_format
int src_format
Source pixel format.
Definition swscale.h:274
test
Definition idctdsp.c:35
LARGEST_FILTER
#define LARGEST_FILTER
RGB24TO32_DST_SIZE
#define RGB24TO32_DST_SIZE
input_sizes
static const int input_sizes[]
Definition sw_rgb.c:352
check_rgb_to_uv
static void check_rgb_to_uv(SwsContext *sws)
Definition sw_rgb.c:407
checkasm_check_sw_rgb
void checkasm_check_sw_rgb(void)
Definition sw_rgb.c:809
check_rgb_to_y
static void check_rgb_to_y(SwsContext *sws)
Definition sw_rgb.c:362
cmp_off_by_n
static int cmp_off_by_n(const uint8_t *ref, const uint8_t *test, size_t n, int accuracy)
Definition sw_rgb.c:126
RGB32_BENCH_WIDTH
#define RGB32_BENCH_WIDTH
check_deinterleave_bytes
static void check_deinterleave_bytes(void)
Definition sw_rgb.c:277
randomize_buffers
#define randomize_buffers(buf, size)
Definition sw_rgb.c:33
check_yuv2packed2
static void check_yuv2packed2(void)
Definition sw_rgb.c:622
RGB24TO32_BENCH_WIDTH
#define RGB24TO32_BENCH_WIDTH
check_rgba_to_a
static void check_rgba_to_a(SwsContext *sws)
Definition sw_rgb.c:461
RGB24_BENCH_WIDTH
#define RGB24_BENCH_WIDTH
check_rgb24toyv12
static void check_rgb24toyv12(SwsContext *sws)
Definition sw_rgb.c:135
check_yuv2packedX
static void check_yuv2packedX(void)
Definition sw_rgb.c:703
rgb_formats
static enum AVPixelFormat rgb_formats[]
Definition sw_rgb.c:353
RGB32_DST_SIZE
#define RGB32_DST_SIZE
check_yuv2packed1
static void check_yuv2packed1(void)
Definition sw_rgb.c:542
check_interleave_bytes
static void check_interleave_bytes(void)
Definition sw_rgb.c:209
check_interleaved_to_planar
static void check_interleaved_to_planar(void *func, const char *report, int odd_tail)
Definition sw_rgb.c:76
check_shuffle_bytes
static void check_shuffle_bytes(void *func, const char *report)
Definition sw_rgb.c:50
ff_sws_init_scale
void ff_sws_init_scale(SwsInternal *c)
Definition swscale.c:697
swscale.h
external API header
swscale_internal.h
sws_internal
static SwsInternal * sws_internal(const SwsContext *sws)
Definition swscale_internal.h:79
src1
#define src1
Definition h264pred.c:141
src0
#define src0
Definition h264pred.c:140
MAX_HEIGHT
#define MAX_HEIGHT
Definition hpeldsp.c:30
MAX_STRIDE
#define MAX_STRIDE
Definition hpeldsp.c:31
src
#define src
Definition vp8dsp.c:248
ref
static int ref[MAX_W *MAX_W]
Definition jpeg2000dwt.c:117
height
#define height
Definition dsp.h:99
width
#define width
Definition dsp.h:99
MAX_LINE_SIZE
#define MAX_LINE_SIZE
Definition vf_lut3d.c:547
packed_rgb_fmts
static enum AVPixelFormat packed_rgb_fmts[]
Definition vf_thumbnail.c:352
h
h
Definition vp9dsp_template.c:2070
c
static double c[64]
Definition vsrc_mptestsrc.c:89
Generated on Fri Oct 9 2026 19:21:11 for FFmpeg by doxygen 1.13.2