Go to the documentation of this file.
61 #define OFFSET(x) offsetof(PSNRContext, x)
62 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
67 {
"stats_version",
"Set the format version for the stats file.",
OFFSET(stats_version),
AV_OPT_TYPE_INT, {.i64=1}, 1, 2,
FLAGS },
79 static inline double get_psnr(
double mse, uint64_t nb_frames,
int max)
81 return 10.0 * log10(
pow_2(
max) / (mse / nb_frames));
84 static uint64_t
sse_line_8bit(
const uint8_t *main_line,
const uint8_t *ref_line,
int outw)
89 for (j = 0; j < outw; j++)
90 m2 +=
pow_2(main_line[j] - ref_line[j]);
95 static uint64_t
sse_line_16bit(
const uint8_t *_main_line,
const uint8_t *_ref_line,
int outw)
99 const uint16_t *main_line = (
const uint16_t *) _main_line;
100 const uint16_t *ref_line = (
const uint16_t *) _ref_line;
102 for (j = 0; j < outw; j++)
103 m2 +=
pow_2(main_line[j] - ref_line[j]);
122 int jobnr,
int nb_jobs)
125 uint64_t *score =
td->score[jobnr];
127 for (
int c = 0;
c <
td->nb_components;
c++) {
128 const int outw =
td->planewidth[
c];
129 const int outh =
td->planeheight[
c];
130 const int slice_start = (outh * jobnr) / nb_jobs;
131 const int slice_end = (outh * (jobnr+1)) / nb_jobs;
132 const int ref_linesize =
td->ref_linesize[
c];
133 const int main_linesize =
td->main_linesize[
c];
134 const uint8_t *main_line =
td->main_data[
c] + main_linesize * slice_start;
135 const uint8_t *ref_line =
td->ref_data[
c] + ref_linesize * slice_start;
138 m +=
td->dsp->sse_line(main_line, ref_line, outw);
139 ref_line += ref_linesize;
140 main_line += main_linesize;
166 double comp_mse[4], mse = 0.;
167 uint64_t comp_sum[4] = { 0 };
175 if (
ctx->is_disabled || !
ref)
177 metadata = &
master->metadata;
179 td.nb_components =
s->nb_components;
182 for (
int c = 0;
c <
s->nb_components;
c++) {
186 td.ref_linesize[
c] =
ref->linesize[
c];
187 td.planewidth[
c] =
s->planewidth[
c];
188 td.planeheight[
c] =
s->planeheight[
c];
191 if (
master->color_range !=
ref->color_range) {
193 "frames use different color ranges (%s != %s)\n",
199 FFMIN(
s->planeheight[1],
s->nb_threads));
201 for (
int j = 0; j <
s->nb_threads; j++) {
202 for (
int c = 0;
c <
s->nb_components;
c++)
203 comp_sum[
c] +=
s->score[j][
c];
206 for (
int c = 0;
c <
s->nb_components;
c++)
207 comp_mse[
c] = comp_sum[
c] / ((
double)
s->planewidth[
c] *
s->planeheight[
c]);
209 for (
int c = 0;
c <
s->nb_components;
c++)
210 mse += comp_mse[
c] *
s->planeweight[
c];
212 s->min_mse =
FFMIN(
s->min_mse, mse);
213 s->max_mse =
FFMAX(
s->max_mse, mse);
217 for (
int j = 0; j <
s->nb_components; j++)
218 s->mse_comp[j] += comp_mse[j];
221 for (
int j = 0; j <
s->nb_components; j++) {
222 int c =
s->is_rgb ?
s->rgba_map[j] : j;
223 set_meta(metadata,
"lavfi.psnr.mse.",
s->comps[j], comp_mse[
c]);
226 set_meta(metadata,
"lavfi.psnr.mse_avg", 0, mse);
230 if (
s->stats_version == 2 && !
s->stats_header_written) {
231 fprintf(
s->stats_file,
"psnr_log_version:2 fields:n");
232 fprintf(
s->stats_file,
",mse_avg");
233 for (
int j = 0; j <
s->nb_components; j++) {
234 fprintf(
s->stats_file,
",mse_%c",
s->comps[j]);
236 fprintf(
s->stats_file,
",psnr_avg");
237 for (
int j = 0; j <
s->nb_components; j++) {
238 fprintf(
s->stats_file,
",psnr_%c",
s->comps[j]);
240 if (
s->stats_add_max) {
241 fprintf(
s->stats_file,
",max_avg");
242 for (
int j = 0; j <
s->nb_components; j++) {
243 fprintf(
s->stats_file,
",max_%c",
s->comps[j]);
246 fprintf(
s->stats_file,
"\n");
247 s->stats_header_written = 1;
249 fprintf(
s->stats_file,
"n:%"PRId64
" mse_avg:%0.2f ",
s->nb_frames, mse);
250 for (
int j = 0; j <
s->nb_components; j++) {
251 int c =
s->is_rgb ?
s->rgba_map[j] : j;
252 fprintf(
s->stats_file,
"mse_%c:%0.2f ",
s->comps[j], comp_mse[
c]);
254 fprintf(
s->stats_file,
"psnr_avg:%0.2f ",
get_psnr(mse, 1,
s->average_max));
255 for (
int j = 0; j <
s->nb_components; j++) {
256 int c =
s->is_rgb ?
s->rgba_map[j] : j;
257 fprintf(
s->stats_file,
"psnr_%c:%0.2f ",
s->comps[j],
260 if (
s->stats_version == 2 &&
s->stats_add_max) {
261 fprintf(
s->stats_file,
"max_avg:%d ",
s->average_max);
262 for (
int j = 0; j <
s->nb_components; j++) {
263 int c =
s->is_rgb ?
s->rgba_map[j] : j;
264 fprintf(
s->stats_file,
"max_%c:%d ",
s->comps[j],
s->max[
c]);
267 fprintf(
s->stats_file,
"\n");
280 if (
s->stats_file_str) {
281 if (
s->stats_version < 2 &&
s->stats_add_max) {
283 "stats_add_max was specified but stats_version < 2.\n" );
286 if (!strcmp(
s->stats_file_str,
"-")) {
287 s->stats_file = stdout;
290 if (!
s->stats_file) {
295 s->stats_file_str, buf);
307 #define PF_NOALPHA(suf) AV_PIX_FMT_YUV420##suf, AV_PIX_FMT_YUV422##suf, AV_PIX_FMT_YUV444##suf
308 #define PF_ALPHA(suf) AV_PIX_FMT_YUVA420##suf, AV_PIX_FMT_YUVA422##suf, AV_PIX_FMT_YUVA444##suf
309 #define PF(suf) PF_NOALPHA(suf), PF_ALPHA(suf)
330 s->nb_components =
desc->nb_components;
331 if (
ctx->inputs[0]->w !=
ctx->inputs[1]->w ||
332 ctx->inputs[0]->h !=
ctx->inputs[1]->h) {
337 s->max[0] = (1 <<
desc->comp[0].depth) - 1;
338 s->max[1] = (1 <<
desc->comp[1].depth) - 1;
339 s->max[2] = (1 <<
desc->comp[2].depth) - 1;
340 s->max[3] = (1 <<
desc->comp[3].depth) - 1;
343 s->comps[0] =
s->is_rgb ?
'r' :
'y' ;
344 s->comps[1] =
s->is_rgb ?
'g' :
'u' ;
345 s->comps[2] =
s->is_rgb ?
'b' :
'v' ;
349 s->planeheight[0] =
s->planeheight[3] =
inlink->h;
351 s->planewidth[0] =
s->planewidth[3] =
inlink->w;
353 for (j = 0; j <
s->nb_components; j++)
354 sum +=
s->planeheight[j] *
s->planewidth[j];
356 for (j = 0; j <
s->nb_components; j++) {
357 s->planeweight[j] = (
double)
s->planeheight[j] *
s->planewidth[j] / sum;
358 average_max +=
s->max[j] *
s->planeweight[j];
360 s->average_max =
lrint(average_max);
371 for (
int t = 0; t <
s->nb_threads; t++) {
372 s->score[t] =
av_calloc(
s->nb_components,
sizeof(*
s->score[0]));
390 outlink->
w = mainlink->
w;
391 outlink->
h = mainlink->
h;
402 av_log(
ctx,
AV_LOG_WARNING,
"not matching timebases found between first input: %d/%d and second input %d/%d, results may be incorrect!\n",
404 ctx->inputs[1]->time_base.num,
ctx->inputs[1]->time_base.den);
419 if (
s->nb_frames > 0) {
424 for (j = 0; j <
s->nb_components; j++) {
425 int c =
s->is_rgb ?
s->rgba_map[j] : j;
437 for (
int t = 0; t <
s->nb_threads &&
s->score; t++)
441 if (
s->stats_file &&
s->stats_file != stdout)
442 fclose(
s->stats_file);
467 .preinit = psnr_framesync_preinit,
472 .priv_class = &psnr_class,
#define AV_PIX_FMT_GBRAP16
int ff_framesync_configure(FFFrameSync *fs)
Configure a frame sync structure.
#define AV_LOG_WARNING
Something somehow does not look correct.
static int config_input_ref(AVFilterLink *inlink)
AVPixelFormat
Pixel format.
static int do_psnr(FFFrameSync *fs)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
static void set_meta(AVDictionary **metadata, const char *key, char comp, float d)
void ff_framesync_uninit(FFFrameSync *fs)
Free all memory currently allocated.
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
#define FILTER_PIXFMTS_ARRAY(array)
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
This structure describes decoded (raw) audio or video data.
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
const char * name
Filter name.
static av_cold int init(AVFilterContext *ctx)
static double psnr(double d)
A link between two filters.
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
void ff_psnr_init_x86(PSNRDSPContext *dsp, int bpp)
static const AVFilterPad psnr_inputs[]
#define AV_PIX_FMT_GBRP14
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
#define AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GRAY16
A filter pad used for either input or output.
@ AV_PIX_FMT_YUVJ411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
#define AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP12
#define AV_CEIL_RSHIFT(a, b)
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
FRAMESYNC_DEFINE_CLASS(psnr, PSNRContext, fs)
AVRational sample_aspect_ratio
agreed upon sample aspect ratio
AVRational frame_rate
Frame rate of the stream on the link, or 1/0 if unknown or variable; if left to 0/0,...
#define AV_PIX_FMT_GRAY14
#define FILTER_INPUTS(array)
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
#define AV_PIX_FMT_GRAY10
const char * av_color_range_name(enum AVColorRange range)
#define AV_PIX_FMT_GBRP16
Describe the class of an AVClass context structure.
#define fs(width, name, subs,...)
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
static const AVOption psnr_options[]
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
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
static uint64_t sse_line_8bit(const uint8_t *main_line, const uint8_t *ref_line, int outw)
static uint64_t sse_line_16bit(const uint8_t *_main_line, const uint8_t *_ref_line, int outw)
static const AVFilterPad psnr_outputs[]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
int ff_framesync_init_dualinput(FFFrameSync *fs, AVFilterContext *parent)
Initialize a frame sync structure for dualinput.
static unsigned pow_2(unsigned base)
static av_cold void uninit(AVFilterContext *ctx)
AVFilterContext * src
source filter
static enum AVPixelFormat pix_fmts[]
#define AV_LOG_INFO
Standard information.
#define i(width, name, range_min, range_max)
int w
agreed upon image width
#define AV_PIX_FMT_GBRP12
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Used for passing data between threads.
static int config_output(AVFilterLink *outlink)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
const char * name
Pad name.
FILE * avpriv_fopen_utf8(const char *path, const char *mode)
Open a file using a UTF-8 filename.
void * av_calloc(size_t nmemb, size_t size)
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
static double get_psnr(double mse, uint64_t nb_frames, int max)
int h
agreed upon image height
#define AVFILTER_FLAG_METADATA_ONLY
The filter is a "metadata" filter - it does not modify the frame data in any way.
static int ref[MAX_W *MAX_W]
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link.
static int activate(AVFilterContext *ctx)
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
#define FILTER_OUTPUTS(array)
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
static int compute_images_mse(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
int ff_fill_rgba_map(uint8_t *rgba_map, enum AVPixelFormat pix_fmt)
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
int ff_framesync_activate(FFFrameSync *fs)
Examine the frames in the filter's input and try to produce output.
int ff_framesync_dualinput_get(FFFrameSync *fs, AVFrame **f0, AVFrame **f1)
#define AV_PIX_FMT_GRAY12
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
const uint8_t * ref_data[4]
const AVFilter ff_vf_psnr
const uint8_t * main_data[4]