FFmpeg: tests/checkasm/sw_gbrp.c Source File

FFmpeg

sw_gbrp.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/swscale.h"

28 #include "libswscale/swscale_internal.h"

29

30 #include "checkasm.h"

31

32 #define randomize_buffers(buf, size) \

33 do { \

34 int j; \

35 for (j = 0; j < size; j+=4) \

36 AV_WN32(buf + j, rnd()); \

37 } while (0)

38

39 static const int planar_fmts[] = {

40 AV_PIX_FMT_GBRP,

41 AV_PIX_FMT_GBRP9BE,

42 AV_PIX_FMT_GBRP9LE,

43 AV_PIX_FMT_GBRP10BE,

44 AV_PIX_FMT_GBRP10LE,

45 AV_PIX_FMT_GBRP12BE,

46 AV_PIX_FMT_GBRP12LE,

47 AV_PIX_FMT_GBRP14BE,

48 AV_PIX_FMT_GBRP14LE,

49 AV_PIX_FMT_GBRAP,

50 AV_PIX_FMT_GBRAP10BE,

51 AV_PIX_FMT_GBRAP10LE,

52 AV_PIX_FMT_GBRAP12BE,

53 AV_PIX_FMT_GBRAP12LE,

54 AV_PIX_FMT_GBRP16BE,

55 AV_PIX_FMT_GBRP16LE,

56 AV_PIX_FMT_GBRAP16BE,

57 AV_PIX_FMT_GBRAP16LE,

58 AV_PIX_FMT_GBRPF32BE,

59 AV_PIX_FMT_GBRPF32LE,

60 AV_PIX_FMT_GBRAPF32BE,

61 AV_PIX_FMT_GBRAPF32LE

62 };

63

64 static void check_output_yuv2gbrp(void)

65 {

66 SwsContext *sws;

67 SwsInternal *c;

68 const AVPixFmtDescriptor *desc;

69 int fmi, fsi, isi, i;

70 int dstW, byte_size, luma_filter_size, chr_filter_size;

71 #define LARGEST_FILTER 16

72 #define FILTER_SIZES 4

73 static const int filter_sizes[] = {1, 4, 8, 16};

74 #define LARGEST_INPUT_SIZE 512

75 static const int input_sizes[] = {8, 24, 128, 144, 256, 512};

76 uint8_t *dst0[4];

77 uint8_t *dst1[4];

78

79 declare_func(void, SwsInternal *c, const int16_t *lumFilter,

80 const int16_t **lumSrcx, int lumFilterSize,

81 const int16_t *chrFilter, const int16_t **chrUSrcx,

82 const int16_t **chrVSrcx, int chrFilterSize,

83 const int16_t **alpSrcx, uint8_t **dest,

84 int dstW, int y);

85

86 const int16_t *luma[LARGEST_FILTER];

87 const int16_t *chru[LARGEST_FILTER];

88 const int16_t *chrv[LARGEST_FILTER];

89 const int16_t *alpha[LARGEST_FILTER];

90

91 LOCAL_ALIGNED_8(int16_t, luma_filter, [LARGEST_FILTER]);

92 LOCAL_ALIGNED_8(int16_t, chr_filter, [LARGEST_FILTER]);

93

94 LOCAL_ALIGNED_8(int32_t, src_y, [LARGEST_FILTER * LARGEST_INPUT_SIZE]);

95 LOCAL_ALIGNED_8(int32_t, src_u, [LARGEST_FILTER * LARGEST_INPUT_SIZE]);

96 LOCAL_ALIGNED_8(int32_t, src_v, [LARGEST_FILTER * LARGEST_INPUT_SIZE]);

97 LOCAL_ALIGNED_8(int32_t, src_a, [LARGEST_FILTER * LARGEST_INPUT_SIZE]);

98

99 LOCAL_ALIGNED_8(uint8_t, dst0_r, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);

100 LOCAL_ALIGNED_8(uint8_t, dst0_g, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);

101 LOCAL_ALIGNED_8(uint8_t, dst0_b, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);

102 LOCAL_ALIGNED_8(uint8_t, dst0_a, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);

103

104 LOCAL_ALIGNED_8(uint8_t, dst1_r, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);

105 LOCAL_ALIGNED_8(uint8_t, dst1_g, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);

106 LOCAL_ALIGNED_8(uint8_t, dst1_b, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);

107 LOCAL_ALIGNED_8(uint8_t, dst1_a, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);

108

109 randomize_buffers((uint8_t*)src_y, LARGEST_FILTER * LARGEST_INPUT_SIZE * sizeof(int32_t));

110 randomize_buffers((uint8_t*)src_u, LARGEST_FILTER * LARGEST_INPUT_SIZE * sizeof(int32_t));

111 randomize_buffers((uint8_t*)src_v, LARGEST_FILTER * LARGEST_INPUT_SIZE * sizeof(int32_t));

112 randomize_buffers((uint8_t*)src_a, LARGEST_FILTER * LARGEST_INPUT_SIZE * sizeof(int32_t));

113 randomize_buffers((uint8_t*)luma_filter, LARGEST_FILTER * sizeof(int16_t));

114 randomize_buffers((uint8_t*)chr_filter, LARGEST_FILTER * sizeof(int16_t));

115

116 dst0[0] = (uint8_t*)dst0_g;

117 dst0[1] = (uint8_t*)dst0_b;

118 dst0[2] = (uint8_t*)dst0_r;

119 dst0[3] = (uint8_t*)dst0_a;

120

121 dst1[0] = (uint8_t*)dst1_g;

122 dst1[1] = (uint8_t*)dst1_b;

123 dst1[2] = (uint8_t*)dst1_r;

124 dst1[3] = (uint8_t*)dst1_a;

125

126 for (i = 0; i < LARGEST_FILTER; i++) {

127 luma[i] = (int16_t *)(src_y + i*LARGEST_INPUT_SIZE);

128 chru[i] = (int16_t *)(src_u + i*LARGEST_INPUT_SIZE);

129 chrv[i] = (int16_t *)(src_v + i*LARGEST_INPUT_SIZE);

130 alpha[i] = (int16_t *)(src_a + i*LARGEST_INPUT_SIZE);

131 }

132

133 sws = sws_alloc_context();

134 if (sws_init_context(sws, NULL, NULL) < 0)

135 fail();

136

137 c = sws_internal(sws);

138 sws->flags |= SWS_FULL_CHR_H_INT;

139

140 for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {

141 for (fsi = 0; fsi < FILTER_SIZES; fsi++) {

142 for (isi = 0; isi < FF_ARRAY_ELEMS(input_sizes); isi++ ) {

143 desc = av_pix_fmt_desc_get(planar_fmts[fmi]);

144 sws->dst_format = planar_fmts[fmi];

145

146 dstW = input_sizes[isi];

147 luma_filter_size = filter_sizes[fsi];

148 chr_filter_size = filter_sizes[fsi];

149

150 if (desc->comp[0].depth > 16) {

151 byte_size = 4;

152 } else if (desc->comp[0].depth > 8) {

153 byte_size = 2;

154 } else {

155 byte_size = 1;

156 }

157

158 ff_sws_init_scale(c);

159 if (check_func(c->yuv2anyX, "yuv2%s_full_X_%d_%d", desc->name, luma_filter_size, dstW)) {

160 for (i = 0; i < 4; i ++) {

161 memset(dst0[i], 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));

162 memset(dst1[i], 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));

163 }

164

165 call_ref(c, luma_filter, luma, luma_filter_size,

166 chr_filter, chru, chrv, chr_filter_size,

167 alpha, dst0, dstW, 0);

168 call_new(c, luma_filter, luma, luma_filter_size,

169 chr_filter, chru, chrv, chr_filter_size,

170 alpha, dst1, dstW, 0);

171

172 if (memcmp(dst0[0], dst1[0], dstW * byte_size) ||

173 memcmp(dst0[1], dst1[1], dstW * byte_size) ||

174 memcmp(dst0[2], dst1[2], dstW * byte_size) ||

175 memcmp(dst0[3], dst1[3], dstW * byte_size) )

176 fail();

177

178 bench_new(c, luma_filter, luma, luma_filter_size,

179 chr_filter, chru, chrv, chr_filter_size,

180 alpha, dst1, dstW, 0);

181 }

182 }

183 }

184 }

185 sws_freeContext(sws);

186 }

187

188 #undef LARGEST_INPUT_SIZE

189

190 static void check_input_planar_rgb_to_y(void)

191 {

192 SwsContext *sws;

193 SwsInternal *c;

194 const AVPixFmtDescriptor *desc;

195 int fmi, isi;

196 int dstW, byte_size;

197 #define LARGEST_INPUT_SIZE 512

198 static const int input_sizes[] = {8, 24, 128, 144, 256, 512};

199 const uint8_t *src[4];

200 int32_t rgb2yuv[9] = {0};

201

202 declare_func(void, uint8_t *dst, const uint8_t *src[4],

203 int w, int32_t *rgb2yuv, void *opaque);

204

205 LOCAL_ALIGNED_8(int32_t, src_r, [LARGEST_INPUT_SIZE]);

206 LOCAL_ALIGNED_8(int32_t, src_g, [LARGEST_INPUT_SIZE]);

207 LOCAL_ALIGNED_8(int32_t, src_b, [LARGEST_INPUT_SIZE]);

208 LOCAL_ALIGNED_8(int32_t, src_a, [LARGEST_INPUT_SIZE]);

209

210 LOCAL_ALIGNED_8(uint8_t, dst0_y, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);

211 LOCAL_ALIGNED_8(uint8_t, dst1_y, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);

212

213 randomize_buffers((uint8_t*)src_r, LARGEST_INPUT_SIZE * sizeof(int32_t));

214 randomize_buffers((uint8_t*)src_g, LARGEST_INPUT_SIZE * sizeof(int32_t));

215 randomize_buffers((uint8_t*)src_b, LARGEST_INPUT_SIZE * sizeof(int32_t));

216 randomize_buffers((uint8_t*)src_a, LARGEST_INPUT_SIZE * sizeof(int32_t));

217 randomize_buffers((uint8_t*)rgb2yuv, 9 * sizeof(int32_t));

218

219 src[0] = (uint8_t*)src_g;

220 src[1] = (uint8_t*)src_b;

221 src[2] = (uint8_t*)src_r;

222 src[3] = (uint8_t*)src_a;

223

224 sws = sws_alloc_context();

225 if (sws_init_context(sws, NULL, NULL) < 0)

226 fail();

227

228 c = sws_internal(sws);

229 for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {

230 for (isi = 0; isi < FF_ARRAY_ELEMS(input_sizes); isi++ ) {

231 desc = av_pix_fmt_desc_get(planar_fmts[fmi]);

232 sws->src_format = planar_fmts[fmi];

233 sws->dst_format = AV_PIX_FMT_YUVA444P16;

234 byte_size = 2;

235 dstW = input_sizes[isi];

236

237 ff_sws_init_scale(c);

238 if(check_func(c->readLumPlanar, "planar_%s_to_y_%d", desc->name, dstW)) {

239 memset(dst0_y, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));

240 memset(dst1_y, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));

241

242 call_ref(dst0_y, src, dstW, rgb2yuv, NULL);

243 call_new(dst1_y, src, dstW, rgb2yuv, NULL);

244

245 if (memcmp(dst0_y, dst1_y, dstW * byte_size))

246 fail();

247

248 bench_new(dst1_y, src, dstW, rgb2yuv, NULL);

249

250 }

251 }

252 }

253 sws_freeContext(sws);

254 }

255

256 #undef LARGEST_INPUT_SIZE

257

258 static void check_input_planar_rgb_to_uv(void)

259 {

260 SwsContext *sws;

261 SwsInternal *c;

262 const AVPixFmtDescriptor *desc;

263 int fmi, isi;

264 int dstW, byte_size;

265 #define LARGEST_INPUT_SIZE 512

266 static const int input_sizes[] = {8, 24, 128, 144, 256, 512};

267 const uint8_t *src[4];

268 int32_t rgb2yuv[9] = {0};

269

270 declare_func(void, uint8_t *dstU, uint8_t *dstV,

271 const uint8_t *src[4], int w, int32_t *rgb2yuv, void *opaque);

272

273 LOCAL_ALIGNED_8(int32_t, src_r, [LARGEST_INPUT_SIZE]);

274 LOCAL_ALIGNED_8(int32_t, src_g, [LARGEST_INPUT_SIZE]);

275 LOCAL_ALIGNED_8(int32_t, src_b, [LARGEST_INPUT_SIZE]);

276 LOCAL_ALIGNED_8(int32_t, src_a, [LARGEST_INPUT_SIZE]);

277

278 LOCAL_ALIGNED_8(uint8_t, dst0_u, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);

279 LOCAL_ALIGNED_8(uint8_t, dst0_v, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);

280

281 LOCAL_ALIGNED_8(uint8_t, dst1_u, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);

282 LOCAL_ALIGNED_8(uint8_t, dst1_v, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);

283

284 randomize_buffers((uint8_t*)src_r, LARGEST_INPUT_SIZE * sizeof(int32_t));

285 randomize_buffers((uint8_t*)src_g, LARGEST_INPUT_SIZE * sizeof(int32_t));

286 randomize_buffers((uint8_t*)src_b, LARGEST_INPUT_SIZE * sizeof(int32_t));

287 randomize_buffers((uint8_t*)src_a, LARGEST_INPUT_SIZE * sizeof(int32_t));

288 randomize_buffers((uint8_t*)rgb2yuv, 9 * sizeof(int32_t));

289

290 src[0] = (uint8_t*)src_g;

291 src[1] = (uint8_t*)src_b;

292 src[2] = (uint8_t*)src_r;

293 src[3] = (uint8_t*)src_a;

294

295 sws = sws_alloc_context();

296 if (sws_init_context(sws, NULL, NULL) < 0)

297 fail();

298

299 c = sws_internal(sws);

300 for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {

301 for (isi = 0; isi < FF_ARRAY_ELEMS(input_sizes); isi++ ) {

302 desc = av_pix_fmt_desc_get(planar_fmts[fmi]);

303 sws->src_format = planar_fmts[fmi];

304 sws->dst_format = AV_PIX_FMT_YUVA444P16;

305 byte_size = 2;

306 dstW = input_sizes[isi];

307

308 ff_sws_init_scale(c);

309 if(check_func(c->readChrPlanar, "planar_%s_to_uv_%d", desc->name, dstW)) {

310 memset(dst0_u, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));

311 memset(dst0_v, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));

312 memset(dst1_u, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));

313 memset(dst1_v, 0xFF, LARGEST_INPUT_SIZE * sizeof(int32_t));

314

315 call_ref(dst0_u, dst0_v, src, dstW, rgb2yuv, NULL);

316 call_new(dst1_u, dst1_v, src, dstW, rgb2yuv, NULL);

317

318 if (memcmp(dst0_u, dst1_u, dstW * byte_size) ||

319 memcmp(dst0_v, dst1_v, dstW * byte_size))

320 fail();

321

322 bench_new(dst1_u, dst1_v, src, dstW, rgb2yuv, NULL);

323 }

324 }

325 }

326 sws_freeContext(sws);

327 }

328

329 #undef LARGEST_INPUT_SIZE

330

331 static void check_input_planar_rgb_to_a(void)

332 {

333 SwsContext *sws;

334 SwsInternal *c;

335 const AVPixFmtDescriptor *desc;

336 int fmi, isi;

337 int dstW, byte_size;

338 #define LARGEST_INPUT_SIZE 512

339 static const int input_sizes[] = {8, 24, 128, 144, 256, 512};

340 const uint8_t *src[4];

341 int32_t rgb2yuv[9] = {0};

342

343 declare_func(void, uint8_t *dst, const uint8_t *src[4],

344 int w, int32_t *rgb2yuv, void *opaque);

345

346 LOCAL_ALIGNED_8(int32_t, src_r, [LARGEST_INPUT_SIZE]);

347 LOCAL_ALIGNED_8(int32_t, src_g, [LARGEST_INPUT_SIZE]);

348 LOCAL_ALIGNED_8(int32_t, src_b, [LARGEST_INPUT_SIZE]);

349 LOCAL_ALIGNED_8(int32_t, src_a, [LARGEST_INPUT_SIZE]);

350

351 LOCAL_ALIGNED_8(uint8_t, dst0_a, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);

352 LOCAL_ALIGNED_8(uint8_t, dst1_a, [LARGEST_INPUT_SIZE * sizeof(int32_t)]);

353

354 randomize_buffers((uint8_t*)src_r, LARGEST_INPUT_SIZE * sizeof(int32_t));

355 randomize_buffers((uint8_t*)src_g, LARGEST_INPUT_SIZE * sizeof(int32_t));

356 randomize_buffers((uint8_t*)src_b, LARGEST_INPUT_SIZE * sizeof(int32_t));

357 randomize_buffers((uint8_t*)src_a, LARGEST_INPUT_SIZE * sizeof(int32_t));

358 randomize_buffers((uint8_t*)rgb2yuv, 9 * sizeof(int32_t));

359

360 src[0] = (uint8_t*)src_g;

361 src[1] = (uint8_t*)src_b;

362 src[2] = (uint8_t*)src_r;

363 src[3] = (uint8_t*)src_a;

364

365 sws = sws_alloc_context();

366 if (sws_init_context(sws, NULL, NULL) < 0)

367 fail();

368

369 c = sws_internal(sws);

370 for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {

371 for (isi = 0; isi < FF_ARRAY_ELEMS(input_sizes); isi++ ) {

372 desc = av_pix_fmt_desc_get(planar_fmts[fmi]);

373 if (!(desc->flags & AV_PIX_FMT_FLAG_ALPHA))

374 continue;

375

376 sws->src_format = planar_fmts[fmi];

377 sws->dst_format = AV_PIX_FMT_YUVA444P16;

378 byte_size = 2;

379 dstW = input_sizes[isi];

380

381 ff_sws_init_scale(c);

382 if(check_func(c->readAlpPlanar, "planar_%s_to_a_%d", desc->name, dstW)) {

383 memset(dst0_a, 0x00, LARGEST_INPUT_SIZE * sizeof(int32_t));

384 memset(dst1_a, 0x00, LARGEST_INPUT_SIZE * sizeof(int32_t));

385

386 call_ref(dst0_a, src, dstW, rgb2yuv, NULL);

387 call_new(dst1_a, src, dstW, rgb2yuv, NULL);

388

389 if (memcmp(dst0_a, dst1_a, dstW * byte_size))

390 fail();

391 bench_new(dst1_a, src, dstW, rgb2yuv, NULL);

392 }

393 }

394 }

395 sws_freeContext(sws);

396 }

397

398 void checkasm_check_sw_gbrp(void)

399 {

400 check_output_yuv2gbrp();

401 report("output_yuv2gbrp");

402

403 check_input_planar_rgb_to_y();

404 report("input_planar_rgb_y");

405

406 check_input_planar_rgb_to_uv();

407 report("input_planar_rgb_uv");

408

409 check_input_planar_rgb_to_a();

410 report("input_planar_rgb_a");

411 }

AV_PIX_FMT_GBRP16BE

@ AV_PIX_FMT_GBRP16BE

planar GBR 4:4:4 48bpp, big-endian

Definition: pixfmt.h:171

AV_PIX_FMT_GBRP10BE

@ AV_PIX_FMT_GBRP10BE

planar GBR 4:4:4 30bpp, big-endian

Definition: pixfmt.h:169

av_pix_fmt_desc_get

const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:3447

sws_freeContext

void sws_freeContext(SwsContext *swsContext)

Free the swscaler context swsContext.

Definition: utils.c:2244

AV_PIX_FMT_GBRAPF32LE

@ AV_PIX_FMT_GBRAPF32LE

IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian.

Definition: pixfmt.h:344

w

uint8_t w

Definition: llviddspenc.c:38

AV_PIX_FMT_GBRPF32BE

@ AV_PIX_FMT_GBRPF32BE

IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian.

Definition: pixfmt.h:341

#define check_func(func,...)

Definition: checkasm.h:197

static const char rgb2yuv[]

Definition: vf_scale_vulkan.c:83

SwsContext::flags

unsigned flags

Bitmask of SWS_*.

Definition: swscale.h:202

AV_PIX_FMT_GBRP14BE

@ AV_PIX_FMT_GBRP14BE

planar GBR 4:4:4 42bpp, big-endian

Definition: pixfmt.h:281

#define LARGEST_FILTER

#define call_ref(...)

Definition: checkasm.h:212

AV_PIX_FMT_GBRAP12LE

@ AV_PIX_FMT_GBRAP12LE

planar GBR 4:4:4:4 48bpp, little-endian

Definition: pixfmt.h:311

static const int planar_fmts[]

Definition: sw_gbrp.c:39

AV_PIX_FMT_GBRAP

@ AV_PIX_FMT_GBRAP

planar GBRA 4:4:4:4 32bpp

Definition: pixfmt.h:212

#define fail()

Definition: checkasm.h:206

AV_PIX_FMT_YUVA444P16

#define AV_PIX_FMT_YUVA444P16

Definition: pixfmt.h:597

sws_init_context

av_warn_unused_result int sws_init_context(SwsContext *sws_context, SwsFilter *srcFilter, SwsFilter *dstFilter)

Initialize the swscaler context sws_context.

Definition: utils.c:1879

check_output_yuv2gbrp

static void check_output_yuv2gbrp(void)

Definition: sw_gbrp.c:64

checkasm_check_sw_gbrp

void checkasm_check_sw_gbrp(void)

Definition: sw_gbrp.c:398

#define FILTER_SIZES

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

randomize_buffers

#define randomize_buffers(buf, size)

Definition: sw_gbrp.c:32

AV_PIX_FMT_GBRAP16BE

@ AV_PIX_FMT_GBRAP16BE

planar GBRA 4:4:4:4 64bpp, big-endian

Definition: pixfmt.h:213

AV_PIX_FMT_GBRP16LE

@ AV_PIX_FMT_GBRP16LE

planar GBR 4:4:4 48bpp, little-endian

Definition: pixfmt.h:172

static const int input_sizes[]

Definition: sw_rgb.c:347

AV_PIX_FMT_GBRP12LE

@ AV_PIX_FMT_GBRP12LE

planar GBR 4:4:4 36bpp, little-endian

Definition: pixfmt.h:280

AV_PIX_FMT_FLAG_ALPHA

#define AV_PIX_FMT_FLAG_ALPHA

The pixel format has an alpha channel.

Definition: pixdesc.h:147

AV_PIX_FMT_GBRP10LE

@ AV_PIX_FMT_GBRP10LE

planar GBR 4:4:4 30bpp, little-endian

Definition: pixfmt.h:170

check_input_planar_rgb_to_y

static void check_input_planar_rgb_to_y(void)

Definition: sw_gbrp.c:190

LOCAL_ALIGNED_8

#define LOCAL_ALIGNED_8(t, v,...)

Definition: mem_internal.h:128

#define call_new(...)

Definition: checkasm.h:315

AV_PIX_FMT_GBRAPF32BE

@ AV_PIX_FMT_GBRAPF32BE

IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian.

Definition: pixfmt.h:343

AV_PIX_FMT_GBRAP12BE

@ AV_PIX_FMT_GBRAP12BE

planar GBR 4:4:4:4 48bpp, big-endian

Definition: pixfmt.h:310

#define NULL

Definition: coverity.c:32

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

check_input_planar_rgb_to_uv

static void check_input_planar_rgb_to_uv(void)

Definition: sw_gbrp.c:258

sws_alloc_context

SwsContext * sws_alloc_context(void)

Allocate an empty SwsContext and set its fields to default values.

Definition: utils.c:1018

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:87

AV_PIX_FMT_GBRP9BE

@ AV_PIX_FMT_GBRP9BE

planar GBR 4:4:4 27bpp, big-endian

Definition: pixfmt.h:167

AV_PIX_FMT_GBRP9LE

@ AV_PIX_FMT_GBRP9LE

planar GBR 4:4:4 27bpp, little-endian

Definition: pixfmt.h:168

LARGEST_INPUT_SIZE

#define LARGEST_INPUT_SIZE

AV_PIX_FMT_GBRAP10LE

@ AV_PIX_FMT_GBRAP10LE

planar GBR 4:4:4:4 40bpp, little-endian

Definition: pixfmt.h:314

SwsContext::dst_format

int dst_format

Destination pixel format.

Definition: swscale.h:238

static SwsContext * sws[3]

Definition: swscale.c:73

#define report

Definition: checkasm.h:209

#define bench_new(...)

Definition: checkasm.h:400

i

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

ff_sws_init_scale

void ff_sws_init_scale(SwsInternal *c)

Definition: swscale.c:691

swscale_internal.h

AV_PIX_FMT_GBRPF32LE

@ AV_PIX_FMT_GBRPF32LE

IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian.

Definition: pixfmt.h:342

AV_PIX_FMT_GBRAP16LE

@ AV_PIX_FMT_GBRAP16LE

planar GBRA 4:4:4:4 64bpp, little-endian

Definition: pixfmt.h:214

Definition: swscale_internal.h:317

SWS_FULL_CHR_H_INT

@ SWS_FULL_CHR_H_INT

Perform full chroma upsampling when upscaling to RGB.

Definition: swscale.h:132

AV_PIX_FMT_GBRP12BE

@ AV_PIX_FMT_GBRP12BE

planar GBR 4:4:4 36bpp, big-endian

Definition: pixfmt.h:279

check_input_planar_rgb_to_a

static void check_input_planar_rgb_to_a(void)

Definition: sw_gbrp.c:331

AV_PIX_FMT_GBRP

@ AV_PIX_FMT_GBRP

planar GBR 4:4:4 24bpp

Definition: pixfmt.h:165

const char * desc

Definition: libsvtav1.c:79

SwsContext::src_format

int src_format

Source pixel format.

Definition: swscale.h:237

AVPixFmtDescriptor

Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...

Definition: pixdesc.h:69

#define declare_func(ret,...)

Definition: checkasm.h:201

static const int16_t alpha[]

Definition: ilbcdata.h:55

AV_PIX_FMT_GBRP14LE

@ AV_PIX_FMT_GBRP14LE

planar GBR 4:4:4 42bpp, little-endian

Definition: pixfmt.h:282

int32_t

Definition: audioconvert.c:56

static SwsInternal * sws_internal(const SwsContext *sws)

Definition: swscale_internal.h:74

AV_PIX_FMT_GBRAP10BE

@ AV_PIX_FMT_GBRAP10BE

planar GBR 4:4:4:4 40bpp, big-endian

Definition: pixfmt.h:313

Main external API structure.

Definition: swscale.h:189

#define src

Definition: vp8dsp.c:248

Generated on Sat Oct 18 2025 19:23:42 for FFmpeg by doxygen 1.8.17