FFmpeg: libswscale/tests/swscale.c Source File

FFmpeg

[フレーム]

swscale.c

Go to the documentation of this file.

1 /*

3 *

4 * This file is part of FFmpeg.

5 *

6 * FFmpeg is free software; you can redistribute it and/or

7 * modify it under the terms of the GNU Lesser General Public

8 * License as published by the Free Software Foundation; either

9 * version 2.1 of the License, or (at your option) any later version.

10 *

11 * FFmpeg is distributed in the hope that it will be useful,

12 * but WITHOUT ANY WARRANTY; without even the implied warranty of

13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

14 * Lesser General Public License for more details.

15 *

16 * You should have received a copy of the GNU Lesser General Public

17 * License along with FFmpeg; if not, write to the Free Software

18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

19 */

21 #include <stdio.h>

22 #include <stdlib.h>

23 #include <string.h>

24 #include <inttypes.h>

25 #include <stdarg.h>

27 #undef HAVE_AV_CONFIG_H

28 #include "libavutil/cpu.h"

29 #include "libavutil/imgutils.h"

30 #include "libavutil/mem.h"

31 #include "libavutil/avutil.h"

32 #include "libavutil/crc.h"

33 #include "libavutil/pixdesc.h"

34 #include "libavutil/lfg.h"

36 #include "libswscale/swscale.h"

38 /* HACK Duplicated from swscale_internal.h.

39 * Should be removed when a cleaner pixel format system exists. */

40 #define isGray(x) \

41 ((x) == AV_PIX_FMT_GRAY8 || \

42 (x) == AV_PIX_FMT_YA8 || \

43 (x) == AV_PIX_FMT_GRAY16BE || \

44 (x) == AV_PIX_FMT_GRAY16LE || \

45 (x) == AV_PIX_FMT_YA16BE || \

46 (x) == AV_PIX_FMT_YA16LE)

47 #define hasChroma(x) \

48 (!(isGray(x) || \

49 (x) == AV_PIX_FMT_MONOBLACK || \

50 (x) == AV_PIX_FMT_MONOWHITE))

51 #define isALPHA(x) \

52 ((x) == AV_PIX_FMT_BGR32 || \

53 (x) == AV_PIX_FMT_BGR32_1 || \

54 (x) == AV_PIX_FMT_RGB32 || \

55 (x) == AV_PIX_FMT_RGB32_1 || \

56 (x) == AV_PIX_FMT_YUVA420P)

58 static uint64_t getSSD(const uint8_t *src1, const uint8_t *src2,

59 int stride1, int stride2, int w, int h)

60 {

61 int x, y;

62 uint64_t ssd = 0;

64 for (y = 0; y < h; y++) {

65 for (x = 0; x < w; x++) {

66 int d = src1[x + y * stride1] - src2[x + y * stride2];

67 ssd += d * d;

68 }

69 }

70 return ssd;

71 }

73 struct Results {

74 uint64_t ssdY;

75 uint64_t ssdU;

76 uint64_t ssdV;

77 uint64_t ssdA;

78 uint32_t crc;

79 };

81 // test by ref -> src -> dst -> out & compare out against ref

82 // ref & out are YV12

83 static int doTest(const uint8_t * const ref[4], int refStride[4], int w, int h,

84 enum AVPixelFormat srcFormat, enum AVPixelFormat dstFormat,

85 int srcW, int srcH, int dstW, int dstH, int flags,

86 struct Results *r)

87 {

88 const AVPixFmtDescriptor *desc_yuva420p = av_pix_fmt_desc_get(AV_PIX_FMT_YUVA420P);

89 const AVPixFmtDescriptor *desc_src = av_pix_fmt_desc_get(srcFormat);

90 const AVPixFmtDescriptor *desc_dst = av_pix_fmt_desc_get(dstFormat);

91 static enum AVPixelFormat cur_srcFormat;

92 static int cur_srcW, cur_srcH;

93 static const uint8_t *src[4];

94 static int srcStride[4];

95 uint8_t *dst[4] = { 0 };

96 uint8_t *out[4] = { 0 };

97 int dstStride[4] = {0};

98 int i;

99 uint64_t ssdY, ssdU = 0, ssdV = 0, ssdA = 0;

100 struct SwsContext *dstContext = NULL, *outContext = NULL;

101 uint32_t crc = 0;

102 int res = 0;

103

104 if (cur_srcFormat != srcFormat || cur_srcW != srcW || cur_srcH != srcH) {

105 struct SwsContext *srcContext = NULL;

106 int p;

107

108 for (p = 0; p < 4; p++)

109 av_freep(&src[p]);

110

111 res = av_image_fill_linesizes(srcStride, srcFormat, srcW);

112 if (res < 0) {

113 fprintf(stderr, "av_image_fill_linesizes failed\n");

114 goto end;

115 }

116 for (p = 0; p < 4; p++) {

117 srcStride[p] = FFALIGN(srcStride[p], 16);

118 if (srcStride[p])

119 src[p] = av_mallocz(srcStride[p] * srcH + 16);

120 if (srcStride[p] && !src[p]) {

121 perror("Malloc");

122 res = -1;

123 goto end;

124 }

125 }

126 srcContext = sws_getContext(w, h, AV_PIX_FMT_YUVA420P, srcW, srcH,

127 srcFormat, SWS_BILINEAR, NULL, NULL, NULL);

128 if (!srcContext) {

129 fprintf(stderr, "Failed to get %s ---> %s\n",

130 desc_yuva420p->name,

131 desc_src->name);

132 res = -1;

133 goto end;

134 }

135 sws_scale(srcContext, ref, refStride, 0, h,

136 (uint8_t * const *) src, srcStride);

137 sws_freeContext(srcContext);

138

139 cur_srcFormat = srcFormat;

140 cur_srcW = srcW;

141 cur_srcH = srcH;

142 }

143

144 res = av_image_fill_linesizes(dstStride, dstFormat, dstW);

145 if (res < 0) {

146 fprintf(stderr, "av_image_fill_linesizes failed\n");

147 goto end;

148 }

149

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

151 /* Image buffers passed into libswscale can be allocated any way you

152 * prefer, as long as they're aligned enough for the architecture, and

153 * they're freed appropriately (such as using av_free for buffers

154 * allocated with av_malloc). */

155 /* An extra 16 bytes is being allocated because some scalers may write

156 * out of bounds. */

157 dstStride[i] = FFALIGN(dstStride[i], 16);

158 if (dstStride[i])

159 dst[i] = av_mallocz(dstStride[i] * dstH + 16);

160 if (dstStride[i] && !dst[i]) {

161 perror("Malloc");

162 res = -1;

163

164 goto end;

165 }

166 }

167

168 dstContext = sws_getContext(srcW, srcH, srcFormat, dstW, dstH, dstFormat,

169 flags, NULL, NULL, NULL);

170 if (!dstContext) {

171 fprintf(stderr, "Failed to get %s ---> %s\n",

172 desc_src->name, desc_dst->name);

173 res = -1;

174 goto end;

175 }

176

177 printf(" %s %dx%d -> %s %3dx%3d flags=%2d",

178 desc_src->name, srcW, srcH,

179 desc_dst->name, dstW, dstH,

180 flags);

181 fflush(stdout);

182

183 sws_scale(dstContext, (const uint8_t * const*)src, srcStride, 0, srcH, dst, dstStride);

184

185 for (i = 0; i < 4 && dstStride[i]; i++)

186 crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), crc, dst[i],

187 dstStride[i] * dstH);

188

189 if (r && crc == r->crc) {

190 ssdY = r->ssdY;

191 ssdU = r->ssdU;

192 ssdV = r->ssdV;

193 ssdA = r->ssdA;

194 } else {

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

196 refStride[i] = FFALIGN(refStride[i], 16);

197 if (refStride[i])

198 out[i] = av_mallocz(refStride[i] * h);

199 if (refStride[i] && !out[i]) {

200 perror("Malloc");

201 res = -1;

202 goto end;

203 }

204 }

205 outContext = sws_getContext(dstW, dstH, dstFormat, w, h,

206 AV_PIX_FMT_YUVA420P, SWS_BILINEAR,

207 NULL, NULL, NULL);

208 if (!outContext) {

209 fprintf(stderr, "Failed to get %s ---> %s\n",

210 desc_dst->name,

211 desc_yuva420p->name);

212 res = -1;

213 goto end;

214 }

215 sws_scale(outContext, (const uint8_t * const *) dst, dstStride, 0, dstH,

216 out, refStride);

217

218 ssdY = getSSD(ref[0], out[0], refStride[0], refStride[0], w, h);

219 if (hasChroma(srcFormat) && hasChroma(dstFormat)) {

220 //FIXME check that output is really gray

221 ssdU = getSSD(ref[1], out[1], refStride[1], refStride[1],

222 (w + 1) >> 1, (h + 1) >> 1);

223 ssdV = getSSD(ref[2], out[2], refStride[2], refStride[2],

224 (w + 1) >> 1, (h + 1) >> 1);

225 }

226 if (isALPHA(srcFormat) && isALPHA(dstFormat))

227 ssdA = getSSD(ref[3], out[3], refStride[3], refStride[3], w, h);

228

229 ssdY /= w * h;

230 ssdU /= w * h / 4;

231 ssdV /= w * h / 4;

232 ssdA /= w * h;

233

234 sws_freeContext(outContext);

235

236 for (i = 0; i < 4; i++)

237 if (refStride[i])

238 av_free(out[i]);

239 }

240

241 printf(" CRC=%08x SSD=%5"PRId64 ",%5"PRId64 ",%5"PRId64 ",%5"PRId64 "\n",

242 crc, ssdY, ssdU, ssdV, ssdA);

243

244 end:

245 sws_freeContext(dstContext);

246

247 for (i = 0; i < 4; i++)

248 if (dstStride[i])

249 av_free(dst[i]);

250

251 return res;

252 }

253

254 static void selfTest(const uint8_t * const ref[4], int refStride[4],

255 int w, int h,

256 enum AVPixelFormat srcFormat_in,

257 enum AVPixelFormat dstFormat_in)

258 {

259 const int flags[] = { SWS_FAST_BILINEAR, SWS_BILINEAR, SWS_BICUBIC,

260 SWS_X, SWS_POINT, SWS_AREA, 0 };

261 const int srcW = w;

262 const int srcH = h;

263 const int dstW[] = { srcW - srcW / 3, srcW, srcW + srcW / 3, 0 };

264 const int dstH[] = { srcH - srcH / 3, srcH, srcH + srcH / 3, 0 };

265 enum AVPixelFormat srcFormat, dstFormat;

266 const AVPixFmtDescriptor *desc_src, *desc_dst;

267

268 for (srcFormat = srcFormat_in != AV_PIX_FMT_NONE ? srcFormat_in : 0;

269 srcFormat < AV_PIX_FMT_NB; srcFormat++) {

270 if (!sws_isSupportedInput(srcFormat) ||

271 !sws_isSupportedOutput(srcFormat))

272 continue;

273

274 desc_src = av_pix_fmt_desc_get(srcFormat);

275

276 for (dstFormat = dstFormat_in != AV_PIX_FMT_NONE ? dstFormat_in : 0;

277 dstFormat < AV_PIX_FMT_NB; dstFormat++) {

278 int i, j, k;

279 int res = 0;

280

281 if (!sws_isSupportedInput(dstFormat) ||

282 !sws_isSupportedOutput(dstFormat))

283 continue;

284

285 desc_dst = av_pix_fmt_desc_get(dstFormat);

286

287 printf("%s -> %s\n", desc_src->name, desc_dst->name);

288 fflush(stdout);

289

290 for (k = 0; flags[k] && !res; k++)

291 for (i = 0; dstW[i] && !res; i++)

292 for (j = 0; dstH[j] && !res; j++)

293 res = doTest(ref, refStride, w, h,

294 srcFormat, dstFormat,

295 srcW, srcH, dstW[i], dstH[j], flags[k],

296 NULL);

297 if (dstFormat_in != AV_PIX_FMT_NONE)

298 break;

299 }

300 if (srcFormat_in != AV_PIX_FMT_NONE)

301 break;

302 }

303 }

304

305 static int fileTest(const uint8_t * const ref[4], int refStride[4],

306 int w, int h, FILE *fp,

307 enum AVPixelFormat srcFormat_in,

308 enum AVPixelFormat dstFormat_in)

309 {

310 char buf[256];

311

312 while (fgets(buf, sizeof(buf), fp)) {

313 struct Results r;

314 enum AVPixelFormat srcFormat;

315 char srcStr[12];

316 int srcW = 0, srcH = 0;

317 enum AVPixelFormat dstFormat;

318 char dstStr[12];

319 int dstW = 0, dstH = 0;

320 int flags;

321 int ret;

322

323 ret = sscanf(buf,

324 " %12s %dx%d -> %12s %dx%d flags=%d CRC=%x"

325 " SSD=%"SCNu64 ", %"SCNu64 ", %"SCNu64 ", %"SCNu64 "\n",

326 srcStr, &srcW, &srcH, dstStr, &dstW, &dstH,

327 &flags, &r.crc, &r.ssdY, &r.ssdU, &r.ssdV, &r.ssdA);

328 if (ret != 12) {

329 srcStr[0] = dstStr[0] = 0;

330 ret = sscanf(buf, "%12s -> %12s\n", srcStr, dstStr);

331 }

332

333 srcFormat = av_get_pix_fmt(srcStr);

334 dstFormat = av_get_pix_fmt(dstStr);

335

336 if (srcFormat == AV_PIX_FMT_NONE || dstFormat == AV_PIX_FMT_NONE ||

337 srcW > 8192U || srcH > 8192U || dstW > 8192U || dstH > 8192U) {

338 fprintf(stderr, "malformed input file\n");

339 return -1;

340 }

341 if ((srcFormat_in != AV_PIX_FMT_NONE && srcFormat_in != srcFormat) ||

342 (dstFormat_in != AV_PIX_FMT_NONE && dstFormat_in != dstFormat))

343 continue;

344 if (ret != 12) {

345 printf("%s", buf);

346 continue;

347 }

348

349 doTest(ref, refStride, w, h,

350 srcFormat, dstFormat,

351 srcW, srcH, dstW, dstH, flags,

352 &r);

353 }

354

355 return 0;

356 }

357

358 #define W 96

359 #define H 96

360

361 int main(int argc, char **argv)

362 {

363 enum AVPixelFormat srcFormat = AV_PIX_FMT_NONE;

364 enum AVPixelFormat dstFormat = AV_PIX_FMT_NONE;

365 uint8_t *rgb_data = av_malloc(W * H * 4);

366 const uint8_t * const rgb_src[4] = { rgb_data, NULL, NULL, NULL };

367 int rgb_stride[4] = { 4 * W, 0, 0, 0 };

368 uint8_t *data = av_malloc(4 * W * H);

369 const uint8_t * const src[4] = { data, data + W * H, data + W * H * 2, data + W * H * 3 };

370 int stride[4] = { W, W, W, W };

371 int x, y;

372 struct SwsContext *sws;

373 AVLFG rand;

374 int res = -1;

375 int i;

376 FILE *fp = NULL;

377

378 if (!rgb_data || !data)

379 return -1;

380

381 for (i = 1; i < argc; i += 2) {

382 if (argv[i][0] != '-' || i + 1 == argc)

383 goto bad_option;

384 if (!strcmp(argv[i], "-ref")) {

385 fp = fopen(argv[i + 1], "r");

386 if (!fp) {

387 fprintf(stderr, "could not open '%s'\n", argv[i + 1]);

388 goto error;

389 }

390 } else if (!strcmp(argv[i], "-cpuflags")) {

391 unsigned flags = av_get_cpu_flags();

392 int ret = av_parse_cpu_caps(&flags, argv[i + 1]);

393 if (ret < 0) {

394 fprintf(stderr, "invalid cpu flags %s\n", argv[i + 1]);

395 return ret;

396 }

397 av_force_cpu_flags(flags);

398 } else if (!strcmp(argv[i], "-src")) {

399 srcFormat = av_get_pix_fmt(argv[i + 1]);

400 if (srcFormat == AV_PIX_FMT_NONE) {

401 fprintf(stderr, "invalid pixel format %s\n", argv[i + 1]);

402 return -1;

403 }

404 } else if (!strcmp(argv[i], "-dst")) {

405 dstFormat = av_get_pix_fmt(argv[i + 1]);

406 if (dstFormat == AV_PIX_FMT_NONE) {

407 fprintf(stderr, "invalid pixel format %s\n", argv[i + 1]);

408 return -1;

409 }

410 } else {

411 bad_option:

412 fprintf(stderr, "bad option or argument missing (%s)\n", argv[i]);

413 goto error;

414 }

415 }

416

417 sws = sws_getContext(W / 12, H / 12, AV_PIX_FMT_RGB32, W, H,

418 AV_PIX_FMT_YUVA420P, SWS_BILINEAR, NULL, NULL, NULL);

419

420 av_lfg_init(&rand, 1);

421

422 for (y = 0; y < H; y++)

423 for (x = 0; x < W * 4; x++)

424 rgb_data[ x + y * 4 * W] = av_lfg_get(&rand);

425 sws_scale(sws, rgb_src, rgb_stride, 0, H / 12, (uint8_t * const *) src, stride);

426 sws_freeContext(sws);

427 av_free(rgb_data);

428

429 if(fp) {

430 res = fileTest(src, stride, W, H, fp, srcFormat, dstFormat);

431 fclose(fp);

432 } else {

433 selfTest(src, stride, W, H, srcFormat, dstFormat);

434 res = 0;

435 }

436 error:

437 av_free(data);

438

439 return res;

440 }

AVLFG

Definition: lfg.h:27

NULL

#define NULL

Definition: coverity.c:32

av_pix_fmt_desc_get

const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:2363

SWS_X

#define SWS_X

Definition: swscale.h:61

AV_PIX_FMT_NONE

Definition: pixfmt.h:61

fileTest

static int fileTest(const uint8_t *const ref[4], int refStride[4], int w, int h, FILE *fp, enum AVPixelFormat srcFormat_in, enum AVPixelFormat dstFormat_in)

Definition: swscale.c:305

Definition: vp9dsp_template.c:2038

SWS_BICUBIC

#define SWS_BICUBIC

Definition: swscale.h:60

data

ptrdiff_t const GLvoid * data

Definition: opengl_enc.c:101

imgutils.h

misc image utilities

mem.h

Memory handling functions.

hasChroma

#define hasChroma(x)

Definition: swscale.c:47

avutil.h

Convenience header that includes libavutil's core.

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:236

Results::ssdY

uint64_t ssdY

Definition: swscale.c:74

getSSD

static uint64_t getSSD(const uint8_t *src1, const uint8_t *src2, int stride1, int stride2, int w, int h)

Definition: swscale.c:58

src

#define src

Definition: vp8dsp.c:254

main

int main(int argc, char **argv)

Definition: swscale.c:361

SwsContext::srcH

int srcH

Height of source luma/alpha planes.

Definition: swscale_internal.h:292

SWS_BILINEAR

#define SWS_BILINEAR

Definition: swscale.h:59

AV_PIX_FMT_YUVA420P

planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)

Definition: pixfmt.h:97

uint8_t

Definition: audio_convert.c:194

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

end

static av_cold int end(AVCodecContext *avctx)

Definition: avrndec.c:90

#define H

Definition: swscale.c:359

crc.h

Public header for CRC hash function implementation.

SWS_FAST_BILINEAR

#define SWS_FAST_BILINEAR

Definition: swscale.h:58

flags

static int flags

Definition: log.c:55

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:1864

swscale.h

external API header

SwsContext::dstFormat

enum AVPixelFormat dstFormat

Destination pixel format.

Definition: swscale_internal.h:300

isALPHA

#define isALPHA(x)

Definition: swscale.c:51

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:48

AVPixFmtDescriptor::name

const char * name

Definition: pixdesc.h:82

SwsContext::dstH

int dstH

Height of destination luma/alpha planes.

Definition: swscale_internal.h:293

#define U(x)

Definition: vp56_arith.h:37

sws_isSupportedOutput

#define sws_isSupportedOutput(x)

AV_CRC_32_IEEE

Definition: crc.h:53

const char * r

Definition: vf_curves.c:111

av_parse_cpu_caps

int av_parse_cpu_caps(unsigned *flags, const char *s)

Parse CPU caps from a string and update the given AV_CPU_* flags based on that.

Definition: cpu.c:191

pixdesc.h

uint8_t w

Definition: llviddspenc.c:38

Results::ssdA

uint64_t ssdA

Definition: swscale.c:77

av_crc

uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)

Calculate the CRC of a block.

Definition: crc.c:392

sws_freeContext

void sws_freeContext(struct SwsContext *swsContext)

Free the swscaler context swsContext.

Definition: utils.c:2284

sws_isSupportedInput

#define sws_isSupportedInput(x)

lfg.h

SwsContext::dstW

int dstW

Width of destination luma/alpha planes.

Definition: swscale_internal.h:478

error

static void error(const char *err)

Definition: target_dec_fuzzer.c:59

Results::crc

uint32_t crc

Definition: swscale.c:78

src1

#define src1

Definition: h264pred.c:139

cpu.h

AVPixFmtDescriptor

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

Definition: pixdesc.h:81

AV_PIX_FMT_RGB32

#define AV_PIX_FMT_RGB32

Definition: pixfmt.h:342

#define fp

Definition: regdef.h:44

sws_scale

int attribute_align_arg sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])

swscale wrapper, so we don't need to export the SwsContext.

Definition: swscale.c:753

av_lfg_get

static unsigned int av_lfg_get(AVLFG *c)

Get the next random unsigned 32-bit number using an ALFG.

Definition: lfg.h:47

buf

void * buf

Definition: avisynth_c.h:690

Results::ssdU

uint64_t ssdU

Definition: swscale.c:75

SWS_AREA

#define SWS_AREA

Definition: swscale.h:63

selfTest

static void selfTest(const uint8_t *const ref[4], int refStride[4], int w, int h, enum AVPixelFormat srcFormat_in, enum AVPixelFormat dstFormat_in)

Definition: swscale.c:254

av_image_fill_linesizes

int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width)

Fill plane linesizes for an image with pixel format pix_fmt and width width.

Definition: imgutils.c:89

Results

Definition: swscale.c:73

Results::ssdV

uint64_t ssdV

Definition: swscale.c:76

av_lfg_init

av_cold void av_lfg_init(AVLFG *c, unsigned int seed)

Definition: lfg.c:32

av_get_cpu_flags

int av_get_cpu_flags(void)

Return the flags which specify extensions supported by the CPU.

Definition: cpu.c:93

SWS_POINT

#define SWS_POINT

Definition: swscale.h:62

av_crc_get_table

const AVCRC * av_crc_get_table(AVCRCId crc_id)

Get an initialized standard CRC table.

Definition: crc.c:374

#define W

Definition: swscale.c:358

stride

GLint GLenum GLboolean GLsizei stride

Definition: opengl_enc.c:105

ref

static int ref[MAX_W *MAX_W]

Definition: jpeg2000dwt.c:107

SwsContext::srcFormat

enum AVPixelFormat srcFormat

Source pixel format.

Definition: swscale_internal.h:301

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

AV_PIX_FMT_NB

number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of...

Definition: pixfmt.h:333

out

FILE * out

Definition: movenc.c:54

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

av_get_pix_fmt

enum AVPixelFormat av_get_pix_fmt(const char *name)

Return the pixel format corresponding to name.

Definition: pixdesc.c:2291

av_force_cpu_flags

void av_force_cpu_flags(int arg)

Disables cpu detection and forces the specified flags.

Definition: cpu.c:65

SwsContext

Definition: swscale_internal.h:280

SwsContext::srcW

int srcW

Width of source luma/alpha planes.

Definition: swscale_internal.h:291

AVPixelFormat

Pixel format.

Definition: pixfmt.h:60

doTest

static int doTest(const uint8_t *const ref[4], int refStride[4], int w, int h, enum AVPixelFormat srcFormat, enum AVPixelFormat dstFormat, int srcW, int srcH, int dstW, int dstH, int flags, struct Results *r)

Definition: swscale.c:83

Generated on Sun May 13 2018 02:04:09 for FFmpeg by doxygen 1.8.6