51 #define OFFSET(x) offsetof(VMAFMotionContext, x)
52 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
62 int h, ptrdiff_t _img1_stride, ptrdiff_t _img2_stride)
64 ptrdiff_t img1_stride = _img1_stride /
sizeof(*img1);
65 ptrdiff_t img2_stride = _img2_stride /
sizeof(*img2);
69 for (
i = 0;
i <
h;
i++) {
70 for (j = 0; j <
w; j++) {
81 uint16_t *dst,
int w,
int h, ptrdiff_t _src_stride,
82 ptrdiff_t _dst_stride)
84 ptrdiff_t src_stride = _src_stride /
sizeof(*src);
85 ptrdiff_t dst_stride = _dst_stride /
sizeof(*dst);
86 int radius = filt_w / 2;
87 int borders_left = radius;
88 int borders_right =
w - (filt_w - radius);
92 for (
i = 0;
i <
h;
i++) {
93 for (j = 0; j < borders_left; j++) {
95 for (k = 0; k < filt_w; k++) {
96 int j_tap =
FFABS(j - radius + k);
98 j_tap =
w - (j_tap -
w + 1);
100 sum +=
filter[k] *
src[
i * src_stride + j_tap];
105 for (j = borders_left; j < borders_right; j++) {
107 for (k = 0; k < filt_w; k++) {
108 sum +=
filter[k] *
src[
i * src_stride + j - radius + k];
113 for (j = borders_right; j <
w; j++) {
115 for (k = 0; k < filt_w; k++) {
116 int j_tap =
FFABS(j - radius + k);
118 j_tap =
w - (j_tap -
w + 1);
120 sum +=
filter[k] *
src[
i * src_stride + j_tap];
127 #define conv_y_fn(type, bits) \
128 static void convolution_y_##bits##bit(const uint16_t *filter, int filt_w, \
129 const uint8_t *_src, uint16_t *dst, \
130 int w, int h, ptrdiff_t _src_stride, \
131 ptrdiff_t _dst_stride) \
133 const type *src = (const type *) _src; \
134 ptrdiff_t src_stride = _src_stride / sizeof(*src); \
135 ptrdiff_t dst_stride = _dst_stride / sizeof(*dst); \
136 int radius = filt_w / 2; \
137 int borders_top = radius; \
138 int borders_bottom = h - (filt_w - radius); \
142 for (i = 0; i < borders_top; i++) { \
143 for (j = 0; j < w; j++) { \
145 for (k = 0; k < filt_w; k++) { \
146 int i_tap = FFABS(i - radius + k); \
148 i_tap = h - (i_tap - h + 1); \
150 sum += filter[k] * src[i_tap * src_stride + j]; \
152 dst[i * dst_stride + j] = sum >> bits; \
155 for (i = borders_top; i < borders_bottom; i++) { \
156 for (j = 0; j < w; j++) { \
158 for (k = 0; k < filt_w; k++) { \
159 sum += filter[k] * src[(i - radius + k) * src_stride + j]; \
161 dst[i * dst_stride + j] = sum >> bits; \
164 for (i = borders_bottom; i < h; i++) { \
165 for (j = 0; j < w; j++) { \
167 for (k = 0; k < filt_w; k++) { \
168 int i_tap = FFABS(i - radius + k); \
170 i_tap = h - (i_tap - h + 1); \
172 sum += filter[k] * src[i_tap * src_stride + j]; \
174 dst[i * dst_stride + j] = sum >> bits; \
184 dsp->convolution_y = bpp == 10 ? convolution_y_10bit : convolution_y_8bit;
192 s->vmafdsp.convolution_y(
s->filter, 5,
ref->data[0],
s->temp_data,
193 s->width,
s->height,
ref->linesize[0],
s->stride);
194 s->vmafdsp.convolution_x(
s->filter, 5,
s->temp_data,
s->blur_data[0],
195 s->width,
s->height,
s->stride,
s->stride);
200 uint64_t sad =
s->vmafdsp.sad(
s->blur_data[1],
s->blur_data[0],
201 s->width,
s->height,
s->stride,
s->stride);
203 score = (double) (sad * 1.0 / (
s->width *
s->height << (
BIT_SHIFT - 8)));
206 FFSWAP(uint16_t *,
s->blur_data[0],
s->blur_data[1]);
208 s->motion_sum += score;
226 set_meta(&
ref->metadata,
"lavfi.vmafmotion.score", score);
228 fprintf(
s->stats_file,
229 "n:%"PRId64
" motion:%0.2lf\n",
s->data.nb_frames, score);
246 s->stride =
FFALIGN(
w *
sizeof(uint16_t), 32);
248 data_sz = (size_t)
s->stride *
h;
255 for (
i = 0;
i < 5;
i++) {
259 vmafmotiondsp_init(&
s->vmafdsp,
desc->comp[0].depth);
274 (
desc->comp[0].depth == 8 ||
desc->comp[0].depth == 10) &&
288 ctx->inputs[0]->h,
ctx->inputs[0]->format);
297 return s->nb_frames > 0 ?
s->motion_sum /
s->nb_frames : 0.0;
311 if (
s->stats_file_str) {
312 if (!strcmp(
s->stats_file_str,
"-")) {
313 s->stats_file = stdout;
315 s->stats_file = fopen(
s->stats_file_str,
"w");
316 if (!
s->stats_file) {
321 s->stats_file_str, buf);
335 if (
s->data.nb_frames > 0) {
339 if (
s->stats_file &&
s->stats_file != stdout)
340 fclose(
s->stats_file);
362 .
name =
"vmafmotion",
368 .priv_class = &vmafmotion_class,
static const AVFilterPad inputs[]
static const AVFilterPad outputs[]
static const char *const format[]
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Main libavfilter public API header.
static av_always_inline void filter(int16_t *output, ptrdiff_t out_stride, const int16_t *low, ptrdiff_t low_stride, const int16_t *high, ptrdiff_t high_stride, int len, int clip)
#define FFSWAP(type, a, b)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
#define AV_LOG_INFO
Standard information.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static uint8_t img2[WIDTH *HEIGHT]
static uint8_t img1[WIDTH *HEIGHT]
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
#define AV_PIX_FMT_FLAG_BITSTREAM
All values of a component are bit-wise packed end to end.
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
AVPixelFormat
Pixel format.
Describe the class of an AVClass context structure.
A link between two filters.
AVFilterContext * dst
dest filter
A filter pad used for either input or output.
const char * name
Pad name.
const char * name
Filter name.
This structure describes decoded (raw) audio or video data.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
static int ref[MAX_W *MAX_W]
double ff_vmafmotion_uninit(VMAFMotionData *s)
static void do_vmafmotion(AVFilterContext *ctx, AVFrame *ref)
double ff_vmafmotion_process(VMAFMotionData *s, AVFrame *ref)
static void convolution_x(const uint16_t *filter, int filt_w, const uint16_t *src, uint16_t *dst, int w, int h, ptrdiff_t _src_stride, ptrdiff_t _dst_stride)
AVFilter ff_vf_vmafmotion
static uint64_t image_sad(const uint16_t *img1, const uint16_t *img2, int w, int h, ptrdiff_t _img1_stride, ptrdiff_t _img2_stride)
#define conv_y_fn(type, bits)
AVFILTER_DEFINE_CLASS(vmafmotion)
static int query_formats(AVFilterContext *ctx)
int ff_vmafmotion_init(VMAFMotionData *s, int w, int h, enum AVPixelFormat fmt)
static int filter_frame(AVFilterLink *inlink, AVFrame *ref)
static const AVFilterPad vmafmotion_inputs[]
static void set_meta(AVDictionary **metadata, const char *key, float d)
static const AVFilterPad vmafmotion_outputs[]
static int config_input_ref(AVFilterLink *inlink)
static const AVOption vmafmotion_options[]
static av_cold int init(AVFilterContext *ctx)
static av_cold void uninit(AVFilterContext *ctx)
static const float FILTER_5[5]