libswscale/tests/floatimg_cmp.c - manifest_repos/ffmpeg - Git at Google

 /*
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * FFmpeg is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
 #include <inttypes.h>
 #include <float.h>

 #include "libavutil/avutil.h"
 #include "libavutil/imgutils.h"
 #include "libavutil/intfloat.h"
 #include "libavutil/intreadwrite.h"
 #include "libavutil/lfg.h"
 #include "libavutil/mem.h"
 #include "libavutil/parseutils.h"
 #include "libavutil/pixdesc.h"

 #include "libswscale/swscale.h"

 #define DEFAULT_W 96
 #define DEFAULT_H 96

 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV444P16LE,
     AV_PIX_FMT_YUV444P,
     AV_PIX_FMT_YUV444P9LE, AV_PIX_FMT_YUV444P10LE,
     AV_PIX_FMT_YUV444P12LE, AV_PIX_FMT_YUV444P14LE,
     AV_PIX_FMT_RGB24,  AV_PIX_FMT_BGR24,
     AV_PIX_FMT_RGBA,   AV_PIX_FMT_BGRA,
     AV_PIX_FMT_ARGB,   AV_PIX_FMT_ABGR,
     AV_PIX_FMT_0RGB,   AV_PIX_FMT_0BGR,
     AV_PIX_FMT_RGB0,   AV_PIX_FMT_BGR0,
     AV_PIX_FMT_RGB48LE,  AV_PIX_FMT_BGR48LE,
     AV_PIX_FMT_RGBA64LE, AV_PIX_FMT_BGRA64LE,
     AV_PIX_FMT_GBRP,   AV_PIX_FMT_GBRAP,
     AV_PIX_FMT_GBRP9LE,
     AV_PIX_FMT_GBRP10LE, AV_PIX_FMT_GBRAP10LE,
     AV_PIX_FMT_GBRP12LE, AV_PIX_FMT_GBRAP12LE,
     AV_PIX_FMT_GBRP14LE,
     AV_PIX_FMT_GBRP16LE,  AV_PIX_FMT_GBRAP16LE
 };

 const char *usage =  "floatimg_cmp -pixel_format <pix_fmt> -size <image_size> -ref <testfile>\n";

 int main(int argc, char **argv)
 {
     enum AVPixelFormat inFormat = AV_PIX_FMT_NONE;
     enum AVPixelFormat dstFormat = AV_PIX_FMT_NONE;
     const AVPixFmtDescriptor *desc;
     uint8_t *ptr;
     uint32_t *in, *out;

     uint8_t *rgbIn[4]  = {NULL, NULL, NULL, NULL};
     uint8_t *rgbOut[4] = {NULL, NULL, NULL, NULL};
     int rgbStride[4];

     uint8_t *dst[4] = {NULL, NULL, NULL, NULL};
     int dstStride[4];

     int i, x, y, p, size, count;
     int res = -1;
     int w = -1;
     int h = -1;
     union av_intfloat32 v0, v1;

     double sum;
     float minimum, maximum, diff;

     struct SwsContext *sws = NULL;
     AVLFG rand;
     FILE *fp = NULL;

     for (i = 1; i < argc; i += 2) {
         if (argv[i][0] != '-' || i + 1 == argc)
             goto bad_option;
         if (!strcmp(argv[i], "-ref")) {
             fp = fopen(argv[i + 1], "rb");
             if (!fp) {
                 fprintf(stderr, "could not open '%s'\n", argv[i + 1]);
                 goto end;
             }
         } else if (!strcmp(argv[i], "-size")) {
             res = av_parse_video_size(&w, &h, argv[i + 1]);
             if (res < 0) {
                 fprintf(stderr, "invalid video size %s\n",  argv[i + 1]);
                 goto end;
             }
         } else if (!strcmp(argv[i], "-pixel_format")) {
             inFormat = av_get_pix_fmt(argv[i + 1]);
             if (inFormat == AV_PIX_FMT_NONE) {
                 fprintf(stderr, "invalid pixel format %s\n", argv[i + 1]);
                 goto end;
             }
         } else {
 bad_option:
             fprintf(stderr, "%s", usage);
             fprintf(stderr, "bad option or argument missing (%s)\n", argv[i]);
             goto end;
         };
     }

     if (!fp) {
         inFormat = AV_PIX_FMT_GBRPF32LE;
         w = DEFAULT_W;
         h = DEFAULT_H;
     }

     if (w <= 0 || h <= 0) {
         fprintf(stderr, "%s", usage);
         fprintf(stderr, "invalid -video_size\n");
         goto end;
     }

     if (inFormat == AV_PIX_FMT_NONE) {
         fprintf(stderr, "%s", usage);
         fprintf(stderr, "invalid input pixel format\n");
         goto end;
     }

     desc = av_pix_fmt_desc_get(inFormat);
     if (!(desc->flags & AV_PIX_FMT_FLAG_FLOAT)) {
         fprintf(stderr, "input pixel format not floating point.\n");
         goto end;
     }

     res = av_image_fill_linesizes(rgbStride, inFormat, w);
     if (res < 0) {
         fprintf(stderr, "av_image_fill_linesizes failed\n");
         goto end;
     }
     for (p = 0; p < 4; p++) {
         rgbStride[p] = FFALIGN(rgbStride[p], 16);
         if (rgbStride[p]) {
             rgbIn[p] = av_mallocz(rgbStride[p] * h + 16);
             rgbOut[p] = av_mallocz(rgbStride[p] * h + 16);
         }
         if (rgbStride[p] && (!rgbIn[p] || !rgbOut[p])) {
             goto end;
         }
     }

     for (i = 0; i < FF_ARRAY_ELEMS(pix_fmts); i++) {
         dstFormat = pix_fmts[i];
         if (fp) {
             fseek(fp, 0, SEEK_SET);
             for (p = 0; p < 4; p++) {
                 if (!rgbStride[p])
                     continue;

                 ptr = rgbIn[p];
                 for (y = 0; y < h; y++) {
                     size = fread(ptr, 1, w*4, fp);
                     if (size != w*4) {
                         fprintf(stderr, "read error: %d\n", size);
                         goto end;
                     }
                     ptr += rgbStride[p];
                 }
             }
         } else {
             // fill src with random values between 0.0 - 1.0
             av_lfg_init(&rand, 1);
             for (p = 0; p < 4; p++) {
                 if (!rgbStride[p])
                     continue;

                 for (y = 0; y < h; y++) {
                     in = (uint32_t*)(rgbIn[p] + y * rgbStride[p]);
                     for (x = 0; x < w; x++) {
                         v0.f =  (float)av_lfg_get(&rand)/(float)(UINT32_MAX);
                         *in++ = AV_RL32(&v0.i);
                     }
                 }
             }
         }

         // setup intermediate image
         for (p = 0; p < 4; p++) {
             av_freep(&dst[p]);
         }

         res = av_image_fill_linesizes(dstStride, dstFormat, w);
         if (res < 0) {
             fprintf(stderr, "av_image_fill_linesizes failed\n");
             goto end;
         }
         for (p = 0; p < 4; p++) {
             dstStride[p] = FFALIGN(dstStride[p], 16);
             if (dstStride[p]) {
                 dst[p] = av_mallocz(dstStride[p] * h + 16);
             }
             if (dstStride[p] && !dst[p]) {
                 goto end;
             }
         }

         // srcFormat -> dstFormat
         sws = sws_getContext(w, h, inFormat, w, h,
                             dstFormat, SWS_BILINEAR, NULL, NULL, NULL);
         if (!sws) {
             fprintf(stderr, "Failed to get %s -> %s\n", av_get_pix_fmt_name(inFormat), av_get_pix_fmt_name(dstFormat) );
             goto end;
         }

         res = sws_scale(sws, (const uint8_t *const *)rgbIn, rgbStride, 0, h, dst, dstStride);
         if (res < 0 || res != h) {
             fprintf(stderr, "sws_scale failed\n");
             res = -1;
             goto end;
         }
         sws_freeContext(sws);

         // dstFormat -> srcFormat
         sws = sws_getContext(w, h, dstFormat, w, h,
                             inFormat, SWS_BILINEAR, NULL, NULL, NULL);
         if(!sws) {
             fprintf(stderr, "Failed to get %s -> %s\n", av_get_pix_fmt_name(dstFormat), av_get_pix_fmt_name(inFormat) );
             goto end;
         }

         res = sws_scale(sws, (const uint8_t *const *)dst, dstStride, 0, h, rgbOut, rgbStride);
         if (res < 0 || res != h) {
             fprintf(stderr, "sws_scale failed\n");
             res = -1;
             goto end;
         }
         sws_freeContext(sws);
         sws = NULL;

         minimum = FLT_MAX;
         maximum = -FLT_MAX;
         count = 0;
         sum = 0.0;

         for (p = 0; p < 4; p++) {
             if (!rgbStride[p])
                 continue;

             for (y = 0; y < h; y++) {
                 in = (uint32_t*)(rgbIn[p] + y * rgbStride[p]);
                 out = (uint32_t*)(rgbOut[p] + y * rgbStride[p]);
                 for (x = 0; x < w; x++) {
                     if (desc->flags & AV_PIX_FMT_FLAG_BE) {
                         v0.i = AV_RB32(in);
                         v1.i = AV_RB32(out);
                     } else {
                         v0.i = AV_RL32(in);
                         v1.i = AV_RL32(out);
                     }

                     diff = fabsf(v0.f - v1.f);
                     sum += diff;
                     minimum = FFMIN(minimum, diff);
                     maximum = FFMAX(maximum, diff);

                     count++;
                     in++;
                     out++;
                 }
             }
         }

         fprintf(stdout, "%s -> %s -> %s\n", av_get_pix_fmt_name(inFormat), av_get_pix_fmt_name(dstFormat), av_get_pix_fmt_name(inFormat) );
         fprintf(stdout, "avg diff: %f\nmin diff: %f\nmax diff: %f\n", sum / count, minimum, maximum);
         res = 0;
     }

 end:
     sws_freeContext(sws);
     for (p = 0; p < 4; p++) {
         av_freep(&rgbIn[p]);
         av_freep(&rgbOut[p]);
         av_freep(&dst[p]);
     }
     if (fp)
         fclose(fp);

     return res;
 }
	/*
	* This file is part of FFmpeg.
	*
	* FFmpeg is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* FFmpeg is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with FFmpeg; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <math.h>
	#include <inttypes.h>
	#include <float.h>

	#include "libavutil/avutil.h"
	#include "libavutil/imgutils.h"
	#include "libavutil/intfloat.h"
	#include "libavutil/intreadwrite.h"
	#include "libavutil/lfg.h"
	#include "libavutil/mem.h"
	#include "libavutil/parseutils.h"
	#include "libavutil/pixdesc.h"

	#include "libswscale/swscale.h"

	#define DEFAULT_W 96
	#define DEFAULT_H 96

	static const enum AVPixelFormat pix_fmts[] = {
	AV_PIX_FMT_YUV444P16LE,
	AV_PIX_FMT_YUV444P,
	AV_PIX_FMT_YUV444P9LE, AV_PIX_FMT_YUV444P10LE,
	AV_PIX_FMT_YUV444P12LE, AV_PIX_FMT_YUV444P14LE,
	AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
	AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA,
	AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR,
	AV_PIX_FMT_0RGB, AV_PIX_FMT_0BGR,
	AV_PIX_FMT_RGB0, AV_PIX_FMT_BGR0,
	AV_PIX_FMT_RGB48LE, AV_PIX_FMT_BGR48LE,
	AV_PIX_FMT_RGBA64LE, AV_PIX_FMT_BGRA64LE,
	AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
	AV_PIX_FMT_GBRP9LE,
	AV_PIX_FMT_GBRP10LE, AV_PIX_FMT_GBRAP10LE,
	AV_PIX_FMT_GBRP12LE, AV_PIX_FMT_GBRAP12LE,
	AV_PIX_FMT_GBRP14LE,
	AV_PIX_FMT_GBRP16LE, AV_PIX_FMT_GBRAP16LE
	};

	const char *usage = "floatimg_cmp -pixel_format <pix_fmt> -size <image_size> -ref <testfile>\n";

	int main(int argc, char **argv)
	{
	enum AVPixelFormat inFormat = AV_PIX_FMT_NONE;
	enum AVPixelFormat dstFormat = AV_PIX_FMT_NONE;
	const AVPixFmtDescriptor *desc;
	uint8_t *ptr;
	uint32_t in, out;

	uint8_t *rgbIn[4] = {NULL, NULL, NULL, NULL};
	uint8_t *rgbOut[4] = {NULL, NULL, NULL, NULL};
	int rgbStride[4];

	uint8_t *dst[4] = {NULL, NULL, NULL, NULL};
	int dstStride[4];

	int i, x, y, p, size, count;
	int res = -1;
	int w = -1;
	int h = -1;
	union av_intfloat32 v0, v1;

	double sum;
	float minimum, maximum, diff;

	struct SwsContext *sws = NULL;
	AVLFG rand;
	FILE *fp = NULL;

	for (i = 1; i < argc; i += 2) {
	if (argv[i][0] != '-' \|\| i + 1 == argc)
	goto bad_option;
	if (!strcmp(argv[i], "-ref")) {
	fp = fopen(argv[i + 1], "rb");
	if (!fp) {
	fprintf(stderr, "could not open '%s'\n", argv[i + 1]);
	goto end;
	}
	} else if (!strcmp(argv[i], "-size")) {
	res = av_parse_video_size(&w, &h, argv[i + 1]);
	if (res < 0) {
	fprintf(stderr, "invalid video size %s\n", argv[i + 1]);
	goto end;
	}
	} else if (!strcmp(argv[i], "-pixel_format")) {
	inFormat = av_get_pix_fmt(argv[i + 1]);
	if (inFormat == AV_PIX_FMT_NONE) {
	fprintf(stderr, "invalid pixel format %s\n", argv[i + 1]);
	goto end;
	}
	} else {
	bad_option:
	fprintf(stderr, "%s", usage);
	fprintf(stderr, "bad option or argument missing (%s)\n", argv[i]);
	goto end;
	};
	}

	if (!fp) {
	inFormat = AV_PIX_FMT_GBRPF32LE;
	w = DEFAULT_W;
	h = DEFAULT_H;
	}

	if (w <= 0 \|\| h <= 0) {
	fprintf(stderr, "%s", usage);
	fprintf(stderr, "invalid -video_size\n");
	goto end;
	}

	if (inFormat == AV_PIX_FMT_NONE) {
	fprintf(stderr, "%s", usage);
	fprintf(stderr, "invalid input pixel format\n");
	goto end;
	}

	desc = av_pix_fmt_desc_get(inFormat);
	if (!(desc->flags & AV_PIX_FMT_FLAG_FLOAT)) {
	fprintf(stderr, "input pixel format not floating point.\n");
	goto end;
	}

	res = av_image_fill_linesizes(rgbStride, inFormat, w);
	if (res < 0) {
	fprintf(stderr, "av_image_fill_linesizes failed\n");
	goto end;
	}
	for (p = 0; p < 4; p++) {
	rgbStride[p] = FFALIGN(rgbStride[p], 16);
	if (rgbStride[p]) {
	rgbIn[p] = av_mallocz(rgbStride[p] * h + 16);
	rgbOut[p] = av_mallocz(rgbStride[p] * h + 16);
	}
	if (rgbStride[p] && (!rgbIn[p] \|\| !rgbOut[p])) {
	goto end;
	}
	}

	for (i = 0; i < FF_ARRAY_ELEMS(pix_fmts); i++) {
	dstFormat = pix_fmts[i];
	if (fp) {
	fseek(fp, 0, SEEK_SET);
	for (p = 0; p < 4; p++) {
	if (!rgbStride[p])
	continue;

	ptr = rgbIn[p];
	for (y = 0; y < h; y++) {
	size = fread(ptr, 1, w*4, fp);
	if (size != w*4) {
	fprintf(stderr, "read error: %d\n", size);
	goto end;
	}
	ptr += rgbStride[p];
	}
	}
	} else {
	// fill src with random values between 0.0 - 1.0
	av_lfg_init(&rand, 1);
	for (p = 0; p < 4; p++) {
	if (!rgbStride[p])
	continue;

	for (y = 0; y < h; y++) {
	in = (uint32_t)(rgbIn[p] + y rgbStride[p]);
	for (x = 0; x < w; x++) {
	v0.f = (float)av_lfg_get(&rand)/(float)(UINT32_MAX);
	*in++ = AV_RL32(&v0.i);
	}
	}
	}
	}

	// setup intermediate image
	for (p = 0; p < 4; p++) {
	av_freep(&dst[p]);
	}

	res = av_image_fill_linesizes(dstStride, dstFormat, w);
	if (res < 0) {
	fprintf(stderr, "av_image_fill_linesizes failed\n");
	goto end;
	}
	for (p = 0; p < 4; p++) {
	dstStride[p] = FFALIGN(dstStride[p], 16);
	if (dstStride[p]) {
	dst[p] = av_mallocz(dstStride[p] * h + 16);
	}
	if (dstStride[p] && !dst[p]) {
	goto end;
	}
	}

	// srcFormat -> dstFormat
	sws = sws_getContext(w, h, inFormat, w, h,
	dstFormat, SWS_BILINEAR, NULL, NULL, NULL);
	if (!sws) {
	fprintf(stderr, "Failed to get %s -> %s\n", av_get_pix_fmt_name(inFormat), av_get_pix_fmt_name(dstFormat) );
	goto end;
	}

	res = sws_scale(sws, (const uint8_t const )rgbIn, rgbStride, 0, h, dst, dstStride);
	if (res < 0 \|\| res != h) {
	fprintf(stderr, "sws_scale failed\n");
	res = -1;
	goto end;
	}
	sws_freeContext(sws);

	// dstFormat -> srcFormat
	sws = sws_getContext(w, h, dstFormat, w, h,
	inFormat, SWS_BILINEAR, NULL, NULL, NULL);
	if(!sws) {
	fprintf(stderr, "Failed to get %s -> %s\n", av_get_pix_fmt_name(dstFormat), av_get_pix_fmt_name(inFormat) );
	goto end;
	}

	res = sws_scale(sws, (const uint8_t const )dst, dstStride, 0, h, rgbOut, rgbStride);
	if (res < 0 \|\| res != h) {
	fprintf(stderr, "sws_scale failed\n");
	res = -1;
	goto end;
	}
	sws_freeContext(sws);
	sws = NULL;

	minimum = FLT_MAX;
	maximum = -FLT_MAX;
	count = 0;
	sum = 0.0;

	for (p = 0; p < 4; p++) {
	if (!rgbStride[p])
	continue;

	for (y = 0; y < h; y++) {
	in = (uint32_t)(rgbIn[p] + y rgbStride[p]);
	out = (uint32_t)(rgbOut[p] + y rgbStride[p]);
	for (x = 0; x < w; x++) {
	if (desc->flags & AV_PIX_FMT_FLAG_BE) {
	v0.i = AV_RB32(in);
	v1.i = AV_RB32(out);
	} else {
	v0.i = AV_RL32(in);
	v1.i = AV_RL32(out);
	}

	diff = fabsf(v0.f - v1.f);
	sum += diff;
	minimum = FFMIN(minimum, diff);
	maximum = FFMAX(maximum, diff);

	count++;
	in++;
	out++;
	}
	}
	}

	fprintf(stdout, "%s -> %s -> %s\n", av_get_pix_fmt_name(inFormat), av_get_pix_fmt_name(dstFormat), av_get_pix_fmt_name(inFormat) );
	fprintf(stdout, "avg diff: %f\nmin diff: %f\nmax diff: %f\n", sum / count, minimum, maximum);
	res = 0;
	}

	end:
	sws_freeContext(sws);
	for (p = 0; p < 4; p++) {
	av_freep(&rgbIn[p]);
	av_freep(&rgbOut[p]);
	av_freep(&dst[p]);
	}
	if (fp)
	fclose(fp);

	return res;
	}