FFmpeg
sw_yuv2rgb.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License along
15  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17  */
18 
19 #include <string.h>
20 
21 #include "libavutil/common.h"
22 #include "libavutil/intreadwrite.h"
23 #include "libavutil/mem_internal.h"
24 #include "libavutil/pixdesc.h"
25 
26 #include "libswscale/swscale.h"
27 #include "libswscale/swscale_internal.h"
28 
29 #include "checkasm.h"
30 
31 #define randomize_buffers(buf, size) \
32  do { \
33  for (int j = 0; j < size; j += 4) \
34  AV_WN32(buf + j, rnd()); \
35  } while (0)
36 
37 static const int dst_fmts[] = {
38 // AV_PIX_FMT_BGR48BE,
39 // AV_PIX_FMT_BGR48LE,
40 // AV_PIX_FMT_RGB48BE,
41 // AV_PIX_FMT_RGB48LE,
42  AV_PIX_FMT_ARGB,
43  AV_PIX_FMT_ABGR,
44  AV_PIX_FMT_RGBA,
45  AV_PIX_FMT_BGRA,
46  AV_PIX_FMT_RGB24,
47  AV_PIX_FMT_BGR24,
48  AV_PIX_FMT_RGB565,
49  AV_PIX_FMT_BGR565,
50  AV_PIX_FMT_RGB555,
51  AV_PIX_FMT_BGR555,
52 // AV_PIX_FMT_RGB444,
53 // AV_PIX_FMT_BGR444,
54 // AV_PIX_FMT_RGB8,
55 // AV_PIX_FMT_BGR8,
56 // AV_PIX_FMT_RGB4,
57 // AV_PIX_FMT_BGR4,
58 // AV_PIX_FMT_RGB4_BYTE,
59 // AV_PIX_FMT_BGR4_BYTE,
60 // AV_PIX_FMT_MONOBLACK,
61  AV_PIX_FMT_GBRP,
62 };
63 
64 static int cmp_off_by_n(const uint8_t *ref, const uint8_t *test, size_t n, int accuracy)
65 {
66  for (size_t i = 0; i < n; i++) {
67  if (abs(ref[i] - test[i]) > accuracy)
68  return 1;
69  }
70  return 0;
71 }
72 
73 static int cmp_555_by_n(const uint8_t *ref, const uint8_t *test, size_t n, int accuracy)
74 {
75  const uint16_t *ref16 = (const uint16_t *) ref;
76  const uint16_t *test16 = (const uint16_t *) test;
77  for (size_t i = 0; i < n; i++) {
78  if (abs(( ref16[i] & 0x1f) - ( test16[i] & 0x1f)) > accuracy)
79  return 1;
80  if (abs(((ref16[i] >> 5) & 0x1f) - ((test16[i] >> 5) & 0x1f)) > accuracy)
81  return 1;
82  if (abs(((ref16[i] >> 10) & 0x1f) - ((test16[i] >> 10) & 0x1f)) > accuracy)
83  return 1;
84  }
85  return 0;
86 }
87 
88 static int cmp_565_by_n(const uint8_t *ref, const uint8_t *test, size_t n, int accuracy)
89 {
90  const uint16_t *ref16 = (const uint16_t *) ref;
91  const uint16_t *test16 = (const uint16_t *) test;
92  for (size_t i = 0; i < n; i++) {
93  if (abs(( ref16[i] & 0x1f) - ( test16[i] & 0x1f)) > accuracy)
94  return 1;
95  if (abs(((ref16[i] >> 5) & 0x3f) - ((test16[i] >> 5) & 0x3f)) > accuracy)
96  return 1;
97  if (abs(((ref16[i] >> 11) & 0x1f) - ((test16[i] >> 11) & 0x1f)) > accuracy)
98  return 1;
99  }
100  return 0;
101 }
102 
103 static void check_yuv2rgb(int src_pix_fmt)
104 {
105  const AVPixFmtDescriptor *src_desc = av_pix_fmt_desc_get(src_pix_fmt);
106 #define MAX_LINE_SIZE 1920
107  static const int input_sizes[] = {8, 128, 1080, MAX_LINE_SIZE};
108 
109  declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT,
110  int, SwsContext *c, const uint8_t *src[],
111  int srcStride[], int srcSliceY, int srcSliceH,
112  uint8_t *dst[], int dstStride[]);
113 
114  LOCAL_ALIGNED_8(uint8_t, src_y, [MAX_LINE_SIZE * 2]);
115  LOCAL_ALIGNED_8(uint8_t, src_u, [MAX_LINE_SIZE]);
116  LOCAL_ALIGNED_8(uint8_t, src_v, [MAX_LINE_SIZE]);
117  LOCAL_ALIGNED_8(uint8_t, src_a, [MAX_LINE_SIZE * 2]);
118  const uint8_t *src[4] = { src_y, src_u, src_v, src_a };
119 
120  LOCAL_ALIGNED_8(uint8_t, dst0_0, [2 * MAX_LINE_SIZE * 6]);
121  LOCAL_ALIGNED_8(uint8_t, dst0_1, [2 * MAX_LINE_SIZE]);
122  LOCAL_ALIGNED_8(uint8_t, dst0_2, [2 * MAX_LINE_SIZE]);
123  uint8_t *dst0[4] = { dst0_0, dst0_1, dst0_2 };
124  uint8_t *lines0[4][2] = {
125  { dst0_0, dst0_0 + MAX_LINE_SIZE * 6 },
126  { dst0_1, dst0_1 + MAX_LINE_SIZE },
127  { dst0_2, dst0_2 + MAX_LINE_SIZE }
128  };
129 
130  LOCAL_ALIGNED_8(uint8_t, dst1_0, [2 * MAX_LINE_SIZE * 6]);
131  LOCAL_ALIGNED_8(uint8_t, dst1_1, [2 * MAX_LINE_SIZE]);
132  LOCAL_ALIGNED_8(uint8_t, dst1_2, [2 * MAX_LINE_SIZE]);
133  uint8_t *dst1[4] = { dst1_0, dst1_1, dst1_2 };
134  uint8_t *lines1[4][2] = {
135  { dst1_0, dst1_0 + MAX_LINE_SIZE * 6 },
136  { dst1_1, dst1_1 + MAX_LINE_SIZE },
137  { dst1_2, dst1_2 + MAX_LINE_SIZE }
138  };
139 
140  randomize_buffers(src_y, MAX_LINE_SIZE * 2);
141  randomize_buffers(src_u, MAX_LINE_SIZE);
142  randomize_buffers(src_v, MAX_LINE_SIZE);
143  randomize_buffers(src_a, MAX_LINE_SIZE * 2);
144 
145  for (int dfi = 0; dfi < FF_ARRAY_ELEMS(dst_fmts); dfi++) {
146  int dst_pix_fmt = dst_fmts[dfi];
147  const AVPixFmtDescriptor *dst_desc = av_pix_fmt_desc_get(dst_pix_fmt);
148  int sample_size = av_get_padded_bits_per_pixel(dst_desc) >> 3;
149  for (int isi = 0; isi < FF_ARRAY_ELEMS(input_sizes); isi++) {
150  struct SwsContext *ctx;
151  int log_level;
152  int width = input_sizes[isi];
153  int srcSliceY = 0;
154  int srcSliceH = 2;
155  int srcStride[4] = {
156  width,
157  width >> src_desc->log2_chroma_w,
158  width >> src_desc->log2_chroma_w,
159  width,
160  };
161  int dstStride[4] = {
162  MAX_LINE_SIZE * 6,
163  MAX_LINE_SIZE,
164  MAX_LINE_SIZE,
165  };
166 
167  // override log level to prevent spamming of the message
168  // "No accelerated colorspace conversion found from %s to %s"
169  log_level = av_log_get_level();
170  av_log_set_level(AV_LOG_ERROR);
171  ctx = sws_getContext(width, srcSliceH, src_pix_fmt,
172  width, srcSliceH, dst_pix_fmt,
173  0, NULL, NULL, NULL);
174  av_log_set_level(log_level);
175  if (!ctx)
176  fail();
177 
178  if (check_func(ctx->convert_unscaled, "%s_%s_%d", src_desc->name, dst_desc->name, width)) {
179  memset(dst0_0, 0xFF, 2 * MAX_LINE_SIZE * 6);
180  memset(dst1_0, 0xFF, 2 * MAX_LINE_SIZE * 6);
181  if (dst_pix_fmt == AV_PIX_FMT_GBRP) {
182  memset(dst0_1, 0xFF, MAX_LINE_SIZE);
183  memset(dst0_2, 0xFF, MAX_LINE_SIZE);
184  memset(dst1_1, 0xFF, MAX_LINE_SIZE);
185  memset(dst1_2, 0xFF, MAX_LINE_SIZE);
186  }
187 
188  call_ref(ctx, src, srcStride, srcSliceY,
189  srcSliceH, dst0, dstStride);
190  call_new(ctx, src, srcStride, srcSliceY,
191  srcSliceH, dst1, dstStride);
192 
193  if (dst_pix_fmt == AV_PIX_FMT_ARGB ||
194  dst_pix_fmt == AV_PIX_FMT_ABGR ||
195  dst_pix_fmt == AV_PIX_FMT_RGBA ||
196  dst_pix_fmt == AV_PIX_FMT_BGRA ||
197  dst_pix_fmt == AV_PIX_FMT_RGB24 ||
198  dst_pix_fmt == AV_PIX_FMT_BGR24) {
199  if (cmp_off_by_n(lines0[0][0], lines1[0][0], width * sample_size, 3) ||
200  cmp_off_by_n(lines0[0][1], lines1[0][1], width * sample_size, 3))
201  fail();
202  } else if (dst_pix_fmt == AV_PIX_FMT_RGB565 ||
203  dst_pix_fmt == AV_PIX_FMT_BGR565) {
204  if (cmp_565_by_n(lines0[0][0], lines1[0][0], width, 2) ||
205  cmp_565_by_n(lines0[0][1], lines1[0][1], width, 2))
206  fail();
207  } else if (dst_pix_fmt == AV_PIX_FMT_RGB555 ||
208  dst_pix_fmt == AV_PIX_FMT_BGR555) {
209  if (cmp_555_by_n(lines0[0][0], lines1[0][0], width, 2) ||
210  cmp_555_by_n(lines0[0][1], lines1[0][1], width, 2))
211  fail();
212  } else if (dst_pix_fmt == AV_PIX_FMT_GBRP) {
213  for (int p = 0; p < 3; p++)
214  for (int l = 0; l < 2; l++)
215  if (cmp_off_by_n(lines0[p][l], lines1[p][l], width, 3))
216  fail();
217  } else {
218  fail();
219  }
220 
221  bench_new(ctx, src, srcStride, srcSliceY,
222  srcSliceH, dst0, dstStride);
223  }
224  sws_freeContext(ctx);
225  }
226  }
227 }
228 
229 #undef MAX_LINE_SIZE
230 
231 void checkasm_check_sw_yuv2rgb(void)
232 {
233  check_yuv2rgb(AV_PIX_FMT_YUV420P);
234  report("yuv420p");
235  check_yuv2rgb(AV_PIX_FMT_YUV422P);
236  report("yuv422p");
237  check_yuv2rgb(AV_PIX_FMT_YUVA420P);
238  report("yuva420p");
239 }
declare_func_emms
#define declare_func_emms(cpu_flags, ret,...)
Definition: checkasm.h:185
mem_internal.h
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
pixdesc.h
AVPixFmtDescriptor::name
const char * name
Definition: pixdesc.h:70
check_func
#define check_func(func,...)
Definition: checkasm.h:179
test
Definition: idctdsp.c:35
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:76
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
call_ref
#define call_ref(...)
Definition: checkasm.h:194
randomize_buffers
#define randomize_buffers(buf, size)
Definition: sw_yuv2rgb.c:31
cmp_565_by_n
static int cmp_565_by_n(const uint8_t *ref, const uint8_t *test, size_t n, int accuracy)
Definition: sw_yuv2rgb.c:88
fail
#define fail()
Definition: checkasm.h:188
checkasm.h
MAX_LINE_SIZE
#define MAX_LINE_SIZE
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
cmp_555_by_n
static int cmp_555_by_n(const uint8_t *ref, const uint8_t *test, size_t n, int accuracy)
Definition: sw_yuv2rgb.c:73
width
#define width
intreadwrite.h
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:108
input_sizes
static const int input_sizes[]
Definition: sw_rgb.c:346
check_yuv2rgb
static void check_yuv2rgb(int src_pix_fmt)
Definition: sw_yuv2rgb.c:103
ctx
AVFormatContext * ctx
Definition: movenc.c:49
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:80
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_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
LOCAL_ALIGNED_8
#define LOCAL_ALIGNED_8(t, v,...)
Definition: mem_internal.h:144
av_log_get_level
int av_log_get_level(void)
Get the current log level.
Definition: log.c:442
call_new
#define call_new(...)
Definition: checkasm.h:297
NULL
#define NULL
Definition: coverity.c:32
abs
#define abs(x)
Definition: cuda_runtime.h:35
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_yuv2rgb.c:64
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:101
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
av_get_padded_bits_per_pixel
int av_get_padded_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel for the pixel format described by pixdesc, including any padding ...
Definition: pixdesc.c:2930
sws_getContext
struct 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:2101
checkasm_check_sw_yuv2rgb
void checkasm_check_sw_yuv2rgb(void)
Definition: sw_yuv2rgb.c:231
AV_PIX_FMT_BGR555
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:471
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:99
report
#define report
Definition: checkasm.h:191
av_log_set_level
void av_log_set_level(int level)
Set the log level.
Definition: log.c:447
bench_new
#define bench_new(...)
Definition: checkasm.h:368
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
common.h
AV_PIX_FMT_RGB555
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:466
swscale_internal.h
AV_PIX_FMT_BGR565
#define AV_PIX_FMT_BGR565
Definition: pixfmt.h:470
AV_PIX_FMT_RGB565
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:465
AV_CPU_FLAG_MMX
#define AV_CPU_FLAG_MMX
standard MMX
Definition: cpu.h:30
sws_freeContext
void sws_freeContext(struct SwsContext *swsContext)
Free the swscaler context swsContext.
Definition: utils.c:2432
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
AV_CPU_FLAG_MMXEXT
#define AV_CPU_FLAG_MMXEXT
SSE integer functions or AMD MMX ext.
Definition: cpu.h:31
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
dst_fmts
static const int dst_fmts[]
Definition: sw_yuv2rgb.c:37
SwsContext
Definition: swscale_internal.h:299
swscale.h
Generated on Sat Sep 7 2024 19:23:01 for FFmpeg by   doxygen 1.8.17