FFmpeg
vf_libvmaf.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017 Ronald S. Bultje <rsbultje@gmail.com>
3  * Copyright (c) 2017 Ashish Pratap Singh <ashk43712@gmail.com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * Calculate the VMAF between two input videos.
25  */
26 
27 #include <pthread.h>
28 #include <libvmaf.h>
29 #include "libavutil/avstring.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/pixdesc.h"
32 #include "avfilter.h"
33 #include "drawutils.h"
34 #include "formats.h"
35 #include "framesync.h"
36 #include "internal.h"
37 #include "video.h"
38 
39 typedef struct LIBVMAFContext {
40  const AVClass *class;
43  int width;
44  int height;
45  double vmaf_score;
50  int eof;
53  int frame_set;
54  char *model_path;
55  char *log_path;
56  char *log_fmt;
61  int psnr;
62  int ssim;
63  int ms_ssim;
64  char *pool;
65  int n_threads;
68  int error;
70 
71 #define OFFSET(x) offsetof(LIBVMAFContext, x)
72 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
73 
74 static const AVOption libvmaf_options[] = {
75  {"model_path", "Set the model to be used for computing vmaf.", OFFSET(model_path), AV_OPT_TYPE_STRING, {.str="/usr/local/share/model/vmaf_v0.6.1.pkl"}, 0, 1, FLAGS},
76  {"log_path", "Set the file path to be used to store logs.", OFFSET(log_path), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 1, FLAGS},
77  {"log_fmt", "Set the format of the log (csv, json or xml).", OFFSET(log_fmt), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 1, FLAGS},
78  {"enable_transform", "Enables transform for computing vmaf.", OFFSET(enable_transform), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
79  {"phone_model", "Invokes the phone model that will generate higher VMAF scores.", OFFSET(phone_model), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
80  {"psnr", "Enables computing psnr along with vmaf.", OFFSET(psnr), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
81  {"ssim", "Enables computing ssim along with vmaf.", OFFSET(ssim), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
82  {"ms_ssim", "Enables computing ms-ssim along with vmaf.", OFFSET(ms_ssim), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
83  {"pool", "Set the pool method to be used for computing vmaf.", OFFSET(pool), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 1, FLAGS},
84  {"n_threads", "Set number of threads to be used when computing vmaf.", OFFSET(n_threads), AV_OPT_TYPE_INT, {.i64=0}, 0, UINT_MAX, FLAGS},
85  {"n_subsample", "Set interval for frame subsampling used when computing vmaf.", OFFSET(n_subsample), AV_OPT_TYPE_INT, {.i64=1}, 1, UINT_MAX, FLAGS},
86  {"enable_conf_interval", "Enables confidence interval.", OFFSET(enable_conf_interval), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
87  { NULL }
88 };
89 
91 
92 #define read_frame_fn(type, bits) \
93  static int read_frame_##bits##bit(float *ref_data, float *main_data, \
94  float *temp_data, int stride, void *ctx) \
95 { \
96  LIBVMAFContext *s = (LIBVMAFContext *) ctx; \
97  int ret; \
98  \
99  pthread_mutex_lock(&s->lock); \
100  \
101  while (!s->frame_set && !s->eof) { \
102  pthread_cond_wait(&s->cond, &s->lock); \
103  } \
104  \
105  if (s->frame_set) { \
106  int ref_stride = s->gref->linesize[0]; \
107  int main_stride = s->gmain->linesize[0]; \
108  \
109  const type *ref_ptr = (const type *) s->gref->data[0]; \
110  const type *main_ptr = (const type *) s->gmain->data[0]; \
111  \
112  float *ptr = ref_data; \
113  float factor = 1.f / (1 << (bits - 8)); \
114  \
115  int h = s->height; \
116  int w = s->width; \
117  \
118  int i,j; \
119  \
120  for (i = 0; i < h; i++) { \
121  for ( j = 0; j < w; j++) { \
122  ptr[j] = ref_ptr[j] * factor; \
123  } \
124  ref_ptr += ref_stride / sizeof(*ref_ptr); \
125  ptr += stride / sizeof(*ptr); \
126  } \
127  \
128  ptr = main_data; \
129  \
130  for (i = 0; i < h; i++) { \
131  for (j = 0; j < w; j++) { \
132  ptr[j] = main_ptr[j] * factor; \
133  } \
134  main_ptr += main_stride / sizeof(*main_ptr); \
135  ptr += stride / sizeof(*ptr); \
136  } \
137  } \
138  \
139  ret = !s->frame_set; \
140  \
141  av_frame_unref(s->gref); \
142  av_frame_unref(s->gmain); \
143  s->frame_set = 0; \
144  \
145  pthread_cond_signal(&s->cond); \
146  pthread_mutex_unlock(&s->lock); \
147  \
148  if (ret) { \
149  return 2; \
150  } \
151  \
152  return 0; \
153 }
154 
155 read_frame_fn(uint8_t, 8);
156 read_frame_fn(uint16_t, 10);
157 
159 {
160  int (*read_frame)(float *ref_data, float *main_data, float *temp_data,
161  int stride, void *ctx);
162  char *format;
163 
164  if (s->desc->comp[0].depth <= 8) {
165  read_frame = read_frame_8bit;
166  } else {
167  read_frame = read_frame_10bit;
168  }
169 
170  format = (char *) s->desc->name;
171 
172  s->error = compute_vmaf(&s->vmaf_score, format, s->width, s->height,
173  read_frame, s, s->model_path, s->log_path,
174  s->log_fmt, 0, 0, s->enable_transform,
175  s->phone_model, s->psnr, s->ssim,
176  s->ms_ssim, s->pool,
177  s->n_threads, s->n_subsample, s->enable_conf_interval);
178 }
179 
180 static void *call_vmaf(void *ctx)
181 {
184  if (!s->error) {
185  av_log(ctx, AV_LOG_INFO, "VMAF score: %f\n",s->vmaf_score);
186  } else {
187  pthread_mutex_lock(&s->lock);
188  pthread_cond_signal(&s->cond);
189  pthread_mutex_unlock(&s->lock);
190  }
191  pthread_exit(NULL);
192  return NULL;
193 }
194 
195 static int do_vmaf(FFFrameSync *fs)
196 {
197  AVFilterContext *ctx = fs->parent;
198  LIBVMAFContext *s = ctx->priv;
199  AVFrame *master, *ref;
200  int ret;
201 
203  if (ret < 0)
204  return ret;
205  if (!ref)
206  return ff_filter_frame(ctx->outputs[0], master);
207 
208  pthread_mutex_lock(&s->lock);
209 
210  while (s->frame_set && !s->error) {
211  pthread_cond_wait(&s->cond, &s->lock);
212  }
213 
214  if (s->error) {
216  "libvmaf encountered an error, check log for details\n");
217  pthread_mutex_unlock(&s->lock);
218  return AVERROR(EINVAL);
219  }
220 
221  av_frame_ref(s->gref, ref);
222  av_frame_ref(s->gmain, master);
223 
224  s->frame_set = 1;
225 
226  pthread_cond_signal(&s->cond);
227  pthread_mutex_unlock(&s->lock);
228 
229  return ff_filter_frame(ctx->outputs[0], master);
230 }
231 
233 {
234  LIBVMAFContext *s = ctx->priv;
235 
236  s->gref = av_frame_alloc();
237  s->gmain = av_frame_alloc();
238  if (!s->gref || !s->gmain)
239  return AVERROR(ENOMEM);
240 
241  s->error = 0;
242 
243  s->vmaf_thread_created = 0;
244  pthread_mutex_init(&s->lock, NULL);
245  pthread_cond_init (&s->cond, NULL);
246 
247  s->fs.on_event = do_vmaf;
248  return 0;
249 }
250 
251 static const enum AVPixelFormat pix_fmts[] = {
255 };
256 
258 {
259  AVFilterContext *ctx = inlink->dst;
260  LIBVMAFContext *s = ctx->priv;
261  int th;
262 
263  if (ctx->inputs[0]->w != ctx->inputs[1]->w ||
264  ctx->inputs[0]->h != ctx->inputs[1]->h) {
265  av_log(ctx, AV_LOG_ERROR, "Width and height of input videos must be same.\n");
266  return AVERROR(EINVAL);
267  }
268 
269  s->desc = av_pix_fmt_desc_get(inlink->format);
270  s->width = ctx->inputs[0]->w;
271  s->height = ctx->inputs[0]->h;
272 
273  th = pthread_create(&s->vmaf_thread, NULL, call_vmaf, (void *) s);
274  if (th) {
275  av_log(ctx, AV_LOG_ERROR, "Thread creation failed.\n");
276  return AVERROR(EINVAL);
277  }
278  s->vmaf_thread_created = 1;
279 
280  return 0;
281 }
282 
283 static int config_output(AVFilterLink *outlink)
284 {
285  AVFilterContext *ctx = outlink->src;
286  LIBVMAFContext *s = ctx->priv;
287  AVFilterLink *mainlink = ctx->inputs[0];
288  int ret;
289 
291  if (ret < 0)
292  return ret;
293  outlink->w = mainlink->w;
294  outlink->h = mainlink->h;
295  outlink->time_base = mainlink->time_base;
296  outlink->sample_aspect_ratio = mainlink->sample_aspect_ratio;
297  outlink->frame_rate = mainlink->frame_rate;
298  if ((ret = ff_framesync_configure(&s->fs)) < 0)
299  return ret;
300 
301  return 0;
302 }
303 
305 {
306  LIBVMAFContext *s = ctx->priv;
307  return ff_framesync_activate(&s->fs);
308 }
309 
311 {
312  LIBVMAFContext *s = ctx->priv;
313 
314  ff_framesync_uninit(&s->fs);
315 
316  pthread_mutex_lock(&s->lock);
317  s->eof = 1;
318  pthread_cond_signal(&s->cond);
319  pthread_mutex_unlock(&s->lock);
320 
321  if (s->vmaf_thread_created)
322  {
323  pthread_join(s->vmaf_thread, NULL);
324  s->vmaf_thread_created = 0;
325  }
326 
327  av_frame_free(&s->gref);
328  av_frame_free(&s->gmain);
329 
330  pthread_mutex_destroy(&s->lock);
331  pthread_cond_destroy(&s->cond);
332 }
333 
334 static const AVFilterPad libvmaf_inputs[] = {
335  {
336  .name = "main",
337  .type = AVMEDIA_TYPE_VIDEO,
338  },{
339  .name = "reference",
340  .type = AVMEDIA_TYPE_VIDEO,
341  .config_props = config_input_ref,
342  },
343 };
344 
345 static const AVFilterPad libvmaf_outputs[] = {
346  {
347  .name = "default",
348  .type = AVMEDIA_TYPE_VIDEO,
349  .config_props = config_output,
350  },
351 };
352 
354  .name = "libvmaf",
355  .description = NULL_IF_CONFIG_SMALL("Calculate the VMAF between two video streams."),
356  .preinit = libvmaf_framesync_preinit,
357  .init = init,
358  .uninit = uninit,
359  .activate = activate,
360  .priv_size = sizeof(LIBVMAFContext),
361  .priv_class = &libvmaf_class,
365 };
pthread_mutex_t
_fmutex pthread_mutex_t
Definition: os2threads.h:53
pthread_join
static av_always_inline int pthread_join(pthread_t thread, void **value_ptr)
Definition: os2threads.h:94
stride
int stride
Definition: mace.c:144
ff_framesync_configure
int ff_framesync_configure(FFFrameSync *fs)
Configure a frame sync structure.
Definition: framesync.c:119
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
psnr
static double psnr(double d)
Definition: ffmpeg.c:1440
AVERROR
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
opt.h
LIBVMAFContext::desc
const AVPixFmtDescriptor * desc
Definition: vf_libvmaf.c:42
libvmaf_inputs
static const AVFilterPad libvmaf_inputs[]
Definition: vf_libvmaf.c:334
ff_framesync_uninit
void ff_framesync_uninit(FFFrameSync *fs)
Free all memory currently allocated.
Definition: framesync.c:285
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1018
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2564
pthread_mutex_init
static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
Definition: os2threads.h:104
FILTER_PIXFMTS_ARRAY
#define FILTER_PIXFMTS_ARRAY(array)
Definition: internal.h:171
inlink
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
Definition: filter_design.txt:212
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:112
LIBVMAFContext
Definition: vf_libvmaf.c:39
LIBVMAFContext::enable_conf_interval
int enable_conf_interval
Definition: vf_libvmaf.c:67
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
pixdesc.h
AVOption
AVOption.
Definition: opt.h:247
LIBVMAFContext::vmaf_thread_created
int vmaf_thread_created
Definition: vf_libvmaf.c:46
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:153
FFFrameSync
Frame sync structure.
Definition: framesync.h:146
video.h
formats.h
LIBVMAFContext::fs
FFFrameSync fs
Definition: vf_libvmaf.c:41
LIBVMAFContext::n_subsample
int n_subsample
Definition: vf_libvmaf.c:66
LIBVMAFContext::disable_clip
int disable_clip
Definition: vf_libvmaf.c:57
LIBVMAFContext::gmain
AVFrame * gmain
Definition: vf_libvmaf.c:51
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:50
AV_PIX_FMT_YUV420P10LE
@ AV_PIX_FMT_YUV420P10LE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:149
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:99
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
LIBVMAFContext::cond
pthread_cond_t cond
Definition: vf_libvmaf.c:49
s
#define s(width, name)
Definition: cbs_vp9.c:257
LIBVMAFContext::frame_set
int frame_set
Definition: vf_libvmaf.c:53
ff_vf_libvmaf
const AVFilter ff_vf_libvmaf
Definition: vf_libvmaf.c:353
config_input_ref
static int config_input_ref(AVFilterLink *inlink)
Definition: vf_libvmaf.c:257
LIBVMAFContext::ssim
int ssim
Definition: vf_libvmaf.c:62
ctx
AVFormatContext * ctx
Definition: movenc.c:48
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
FRAMESYNC_DEFINE_CLASS
FRAMESYNC_DEFINE_CLASS(libvmaf, LIBVMAFContext, fs)
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:191
AV_PIX_FMT_YUV444P10LE
@ AV_PIX_FMT_YUV444P10LE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:155
pthread_create
static av_always_inline int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)
Definition: os2threads.h:80
activate
static int activate(AVFilterContext *ctx)
Definition: vf_libvmaf.c:304
LIBVMAFContext::enable_transform
int enable_transform
Definition: vf_libvmaf.c:59
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
do_vmaf
static int do_vmaf(FFFrameSync *fs)
Definition: vf_libvmaf.c:195
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:259
LIBVMAFContext::log_fmt
char * log_fmt
Definition: vf_libvmaf.c:56
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_libvmaf.c:310
LIBVMAFContext::width
int width
Definition: vf_libvmaf.c:43
LIBVMAFContext::lock
pthread_mutex_t lock
Definition: vf_libvmaf.c:48
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: vf_libvmaf.c:251
compute_vmaf_score
static void compute_vmaf_score(LIBVMAFContext *s)
Definition: vf_libvmaf.c:158
pthread_mutex_unlock
#define pthread_mutex_unlock(a)
Definition: ffprobe.c:68
LIBVMAFContext::height
int height
Definition: vf_libvmaf.c:44
read_frame
static int read_frame(AVFilterContext *ctx, FPSContext *s, AVFilterLink *inlink, AVFilterLink *outlink)
Definition: vf_fps.c:219
config_output
static int config_output(AVFilterLink *outlink)
Definition: vf_libvmaf.c:283
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
ff_framesync_init_dualinput
int ff_framesync_init_dualinput(FFFrameSync *fs, AVFilterContext *parent)
Initialize a frame sync structure for dualinput.
Definition: framesync.c:353
master
const char * master
Definition: vf_curves.c:119
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:327
AV_PIX_FMT_YUV422P10LE
@ AV_PIX_FMT_YUV422P10LE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:151
LIBVMAFContext::error
int error
Definition: vf_libvmaf.c:68
LIBVMAFContext::n_threads
int n_threads
Definition: vf_libvmaf.c:65
LIBVMAFContext::log_path
char * log_path
Definition: vf_libvmaf.c:55
pthread_t
Definition: os2threads.h:44
pthread_cond_destroy
static av_always_inline int pthread_cond_destroy(pthread_cond_t *cond)
Definition: os2threads.h:144
th
#define th
Definition: regdef.h:75
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
LIBVMAFContext::gref
AVFrame * gref
Definition: vf_libvmaf.c:52
LIBVMAFContext::ms_ssim
int ms_ssim
Definition: vf_libvmaf.c:63
internal.h
pthread_mutex_destroy
static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
Definition: os2threads.h:112
read_frame_fn
#define read_frame_fn(type, bits)
Definition: vf_libvmaf.c:92
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:56
pthread_cond_t
Definition: os2threads.h:58
LIBVMAFContext::psnr
int psnr
Definition: vf_libvmaf.c:61
LIBVMAFContext::vmaf_thread
pthread_t vmaf_thread
Definition: vf_libvmaf.c:47
AVFilter
Filter definition.
Definition: avfilter.h:149
ret
ret
Definition: filter_design.txt:187
pthread_cond_signal
static av_always_inline int pthread_cond_signal(pthread_cond_t *cond)
Definition: os2threads.h:152
LIBVMAFContext::model_path
char * model_path
Definition: vf_libvmaf.c:54
libvmaf_outputs
static const AVFilterPad libvmaf_outputs[]
Definition: vf_libvmaf.c:345
framesync.h
libvmaf_options
static const AVOption libvmaf_options[]
Definition: vf_libvmaf.c:74
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
avfilter.h
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
LIBVMAFContext::pool
char * pool
Definition: vf_libvmaf.c:64
OFFSET
#define OFFSET(x)
Definition: vf_libvmaf.c:71
FLAGS
#define FLAGS
Definition: vf_libvmaf.c:72
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
pthread_cond_wait
static av_always_inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
Definition: os2threads.h:192
AVFilterContext
An instance of a filter.
Definition: avfilter.h:386
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_libvmaf.c:232
LIBVMAFContext::eof
int eof
Definition: vf_libvmaf.c:50
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:192
format
fg outputs[0] format
Definition: ffmpeg_filter.c:175
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
LIBVMAFContext::disable_avx
int disable_avx
Definition: vf_libvmaf.c:58
pthread_cond_init
static av_always_inline int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
Definition: os2threads.h:133
ff_framesync_activate
int ff_framesync_activate(FFFrameSync *fs)
Examine the frames in the filter's input and try to produce output.
Definition: framesync.c:336
LIBVMAFContext::phone_model
int phone_model
Definition: vf_libvmaf.c:60
avstring.h
ff_framesync_dualinput_get
int ff_framesync_dualinput_get(FFFrameSync *fs, AVFrame **f0, AVFrame **f1)
Definition: framesync.c:371
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:228
drawutils.h
call_vmaf
static void * call_vmaf(void *ctx)
Definition: vf_libvmaf.c:180
int
int
Definition: ffmpeg_filter.c:156
LIBVMAFContext::vmaf_score
double vmaf_score
Definition: vf_libvmaf.c:45
pthread_mutex_lock
#define pthread_mutex_lock(a)
Definition: ffprobe.c:64