27 #undef HAVE_AV_CONFIG_H 39 ((x) == AV_PIX_FMT_GRAY8 || \ 40 (x) == AV_PIX_FMT_YA8 || \ 41 (x) == AV_PIX_FMT_GRAY16BE || \ 42 (x) == AV_PIX_FMT_GRAY16LE || \ 43 (x) == AV_PIX_FMT_YA16BE || \ 44 (x) == AV_PIX_FMT_YA16LE) 45 #define hasChroma(x) \ 47 (x) == AV_PIX_FMT_MONOBLACK || \ 48 (x) == AV_PIX_FMT_MONOWHITE)) 50 ((x) == AV_PIX_FMT_BGR32 || \ 51 (x) == AV_PIX_FMT_BGR32_1 || \ 52 (x) == AV_PIX_FMT_RGB32 || \ 53 (x) == AV_PIX_FMT_RGB32_1 || \ 54 (x) == AV_PIX_FMT_YUVA420P) 57 int stride2,
int w,
int h)
62 for (y = 0; y < h; y++) {
63 for (x = 0; x < w; x++) {
64 int d = src1[x + y * stride1] - src2[x + y * stride2];
83 int srcW,
int srcH,
int dstW,
int dstH,
int flags,
90 static int cur_srcW, cur_srcH;
92 static int srcStride[4];
102 if (cur_srcFormat != srcFormat || cur_srcW != srcW || cur_srcH != srcH) {
106 for (p = 0; p < 4; p++)
110 for (p = 0; p < 4; p++) {
112 src[p] =
av_mallocz(srcStride[p] * srcH + 16);
113 if (srcStride[p] && !src[p]) {
122 fprintf(stderr,
"Failed to get %s ---> %s\n",
128 sws_scale(srcContext, ref, refStride, 0, h, src, srcStride);
137 for (i = 0; i < 4; i++) {
145 dst[i] =
av_mallocz(dstStride[i] * dstH + 16);
146 if (dstStride[i] && !dst[i]) {
154 dstContext =
sws_getContext(srcW, srcH, srcFormat, dstW, dstH, dstFormat,
157 fprintf(stderr,
"Failed to get %s ---> %s\n",
163 printf(
" %s %dx%d -> %s %3dx%3d flags=%2d",
164 desc_src->
name, srcW, srcH,
165 desc_dst->
name, dstW, dstH,
169 sws_scale(dstContext, src, srcStride, 0, srcH, dst, dstStride);
171 for (i = 0; i < 4 && dstStride[i]; i++)
173 dstStride[i] * dstH);
175 if (r && crc == r->
crc) {
181 for (i = 0; i < 4; i++) {
184 if (refStride[i] && !out[i]) {
194 fprintf(stderr,
"Failed to get %s ---> %s\n",
196 desc_yuva420p->
name);
200 sws_scale(outContext, dst, dstStride, 0, dstH, out, refStride);
202 ssdY =
getSSD(ref[0], out[0], refStride[0], refStride[0], w, h);
205 ssdU =
getSSD(ref[1], out[1], refStride[1], refStride[1],
206 (w + 1) >> 1, (h + 1) >> 1);
207 ssdV =
getSSD(ref[2], out[2], refStride[2], refStride[2],
208 (w + 1) >> 1, (h + 1) >> 1);
211 ssdA =
getSSD(ref[3], out[3], refStride[3], refStride[3], w, h);
220 for (i = 0; i < 4; i++)
225 printf(
" CRC=%08x SSD=%5"PRId64
",%5"PRId64
",%5"PRId64
",%5"PRId64
"\n",
231 for (i = 0; i < 4; i++)
246 const int dstW[] = { srcW - srcW / 3,
srcW, srcW + srcW / 3, 0 };
247 const int dstH[] = { srcH - srcH / 3,
srcH, srcH + srcH / 3, 0 };
270 printf(
"%s -> %s\n", desc_src->
name, desc_dst->
name);
273 for (k = 0; flags[k] && !res; k++)
274 for (i = 0; dstW[i] && !res; i++)
275 for (j = 0; dstH[j] && !res; j++)
276 res =
doTest(ref, refStride, w, h,
277 srcFormat, dstFormat,
278 srcW, srcH, dstW[i], dstH[j], flags[k],
294 while (fgets(buf,
sizeof(buf), fp)) {
306 " %12s %dx%d -> %12s %dx%d flags=%d CRC=%x" 307 " SSD=%"PRId64
", %"PRId64
", %"PRId64
", %"PRId64
"\n",
308 srcStr, &srcW, &srcH, dstStr, &dstW, &dstH,
311 srcStr[0] = dstStr[0] = 0;
312 ret = sscanf(buf,
"%12s -> %12s\n", srcStr, dstStr);
319 fprintf(stderr,
"malformed input file\n");
330 doTest(ref, refStride, w, h,
331 srcFormat, dstFormat,
332 srcW, srcH, dstW, dstH, flags,
342 int main(
int argc,
char **argv)
348 int rgb_stride[4] = { 4 *
W, 0, 0, 0 };
350 uint8_t *src[4] = {
data, data +
W *
H, data +
W * H * 2, data +
W * H * 3 };
358 if (!rgb_data || !data)
366 for (y = 0; y <
H; y++)
367 for (x = 0; x < W * 4; x++)
369 sws_scale(sws, rgb_src, rgb_stride, 0, H, src, stride);
373 for (i = 1; i < argc; i += 2) {
374 if (argv[i][0] !=
'-' || i + 1 == argc)
376 if (!strcmp(argv[i],
"-ref")) {
377 FILE *fp = fopen(argv[i + 1],
"r");
379 fprintf(stderr,
"could not open '%s'\n", argv[i + 1]);
382 res =
fileTest(src, stride, W, H, fp, srcFormat, dstFormat);
385 }
else if (!strcmp(argv[i],
"-src")) {
388 fprintf(stderr,
"invalid pixel format %s\n", argv[i + 1]);
391 }
else if (!strcmp(argv[i],
"-dst")) {
394 fprintf(stderr,
"invalid pixel format %s\n", argv[i + 1]);
399 fprintf(stderr,
"bad option or argument missing (%s)\n", argv[i]);
404 selfTest(src, stride, W, H, srcFormat, dstFormat);
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
static int fileTest(uint8_t *ref[4], int refStride[4], int w, int h, FILE *fp, enum AVPixelFormat srcFormat_in, enum AVPixelFormat dstFormat_in)
memory handling functions
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_dlog(ac->avr, "%d samples - audio_convert: %s to %s (dithered)\", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> out
int main(int argc, char **argv)
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
int srcH
Height of source luma/alpha planes.
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
#define SWS_FAST_BILINEAR
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.
external api for the swscale stuff
enum AVPixelFormat dstFormat
Destination pixel format.
int dstH
Height of destination luma/alpha planes.
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
#define sws_isSupportedOutput(x)
void sws_freeContext(struct SwsContext *swsContext)
Free the swscaler context swsContext.
#define sws_isSupportedInput(x)
int dstW
Width of destination luma/alpha planes.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
int sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Scale the image slice in srcSlice and put the resulting scaled slice in the image in dst...
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
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.
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
enum AVPixelFormat srcFormat
Source pixel format.
static uint64_t getSSD(uint8_t *src1, uint8_t *src2, int stride1, int stride2, int w, int h)
static int doTest(uint8_t *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)
number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of...
static void selfTest(uint8_t *ref[4], int refStride[4], int w, int h, enum AVPixelFormat srcFormat_in, enum AVPixelFormat dstFormat_in)
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
int srcW
Width of source luma/alpha planes.
AVPixelFormat
Pixel format.
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...