FFmpeg
vf_nnedi.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2010-2011 Kevin Stone
3  * Copyright (C) 2016 Paul B Mahol
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (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
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License along
18  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20  */
21 
22 #include <float.h>
23 
24 #include "libavutil/common.h"
25 #include "libavutil/float_dsp.h"
26 #include "libavutil/imgutils.h"
27 #include "libavutil/mem_internal.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/pixdesc.h"
30 #include "avfilter.h"
31 #include "formats.h"
32 #include "internal.h"
33 #include "video.h"
34 
35 static const size_t NNEDI_WEIGHTS_SIZE = 13574928;
36 static const uint8_t NNEDI_XDIM[] = { 8, 16, 32, 48, 8, 16, 32 };
37 static const uint8_t NNEDI_YDIM[] = { 6, 6, 6, 6, 4, 4, 4 };
38 static const uint16_t NNEDI_NNS[] = { 16, 32, 64, 128, 256 };
39 
40 typedef struct PrescreenerCoefficients {
41  DECLARE_ALIGNED(32, float, kernel_l0)[4][16 * 4];
42  DECLARE_ALIGNED(32, float, bias_l0)[4];
43 
44  DECLARE_ALIGNED(32, float, kernel_l1)[4][4];
45  DECLARE_ALIGNED(32, float, bias_l1)[4];
46 
47  DECLARE_ALIGNED(32, float, kernel_l2)[4][8];
48  DECLARE_ALIGNED(32, float, bias_l2)[4];
50 
51 typedef struct PredictorCoefficients {
52  int xdim, ydim, nns, nsize;
53  float *data;
54  float *softmax_q1;
55  float *elliott_q1;
58  float *softmax_q2;
59  float *elliott_q2;
63 
64 typedef struct NNEDIContext {
65  const AVClass *class;
66 
67  char *weights_file;
68 
70  int eof;
71  int64_t pts;
72 
74  int depth;
75  int nb_planes;
77  int linesize[4];
78  int planewidth[4];
79  int planeheight[4];
80  int field_n;
81 
84 
85  float half;
86  float in_scale;
87  float out_scale;
88 
89  // Parameters
90  int deint;
91  int field;
93  int nsize;
94  int nnsparam;
95  int qual;
96  int etype;
97  int pscrn;
98 
100  uint8_t **prescreen_buf;
101  float **input_buf;
102  float **output_buf;
103 
104  void (*read)(const uint8_t *src, float *dst,
105  int src_stride, int dst_stride,
106  int width, int height, float scale);
107  void (*write)(const float *src, uint8_t *dst,
108  int src_stride, int dst_stride,
109  int width, int height, int depth, float scale);
111  const void *src, ptrdiff_t src_stride,
112  uint8_t *prescreen, int N,
113  const PrescreenerCoefficients *const coeffs);
114 } NNEDIContext;
115 
116 #define OFFSET(x) offsetof(NNEDIContext, x)
117 #define RFLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
118 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
119 
120 static const AVOption nnedi_options[] = {
121  {"weights", "set weights file", OFFSET(weights_file), AV_OPT_TYPE_STRING, {.str="nnedi3_weights.bin"}, 0, 0, FLAGS },
122  {"deint", "set which frames to deinterlace", OFFSET(deint), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, RFLAGS, "deint" },
123  {"all", "deinterlace all frames", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, RFLAGS, "deint" },
124  {"interlaced", "only deinterlace frames marked as interlaced", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, RFLAGS, "deint" },
125  {"field", "set mode of operation", OFFSET(field), AV_OPT_TYPE_INT, {.i64=-1}, -2, 3, RFLAGS, "field" },
126  {"af", "use frame flags, both fields", 0, AV_OPT_TYPE_CONST, {.i64=-2}, 0, 0, RFLAGS, "field" },
127  {"a", "use frame flags, single field", 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, RFLAGS, "field" },
128  {"t", "use top field only", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, RFLAGS, "field" },
129  {"b", "use bottom field only", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, RFLAGS, "field" },
130  {"tf", "use both fields, top first", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, RFLAGS, "field" },
131  {"bf", "use both fields, bottom first", 0, AV_OPT_TYPE_CONST, {.i64=3}, 0, 0, RFLAGS, "field" },
132  {"planes", "set which planes to process", OFFSET(process_plane), AV_OPT_TYPE_INT, {.i64=7}, 0, 15, RFLAGS },
133  {"nsize", "set size of local neighborhood around each pixel, used by the predictor neural network", OFFSET(nsize), AV_OPT_TYPE_INT, {.i64=6}, 0, 6, RFLAGS, "nsize" },
134  {"s8x6", NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, RFLAGS, "nsize" },
135  {"s16x6", NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, RFLAGS, "nsize" },
136  {"s32x6", NULL, 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, RFLAGS, "nsize" },
137  {"s48x6", NULL, 0, AV_OPT_TYPE_CONST, {.i64=3}, 0, 0, RFLAGS, "nsize" },
138  {"s8x4", NULL, 0, AV_OPT_TYPE_CONST, {.i64=4}, 0, 0, RFLAGS, "nsize" },
139  {"s16x4", NULL, 0, AV_OPT_TYPE_CONST, {.i64=5}, 0, 0, RFLAGS, "nsize" },
140  {"s32x4", NULL, 0, AV_OPT_TYPE_CONST, {.i64=6}, 0, 0, RFLAGS, "nsize" },
141  {"nns", "set number of neurons in predictor neural network", OFFSET(nnsparam), AV_OPT_TYPE_INT, {.i64=1}, 0, 4, RFLAGS, "nns" },
142  {"n16", NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, RFLAGS, "nns" },
143  {"n32", NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, RFLAGS, "nns" },
144  {"n64", NULL, 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, RFLAGS, "nns" },
145  {"n128", NULL, 0, AV_OPT_TYPE_CONST, {.i64=3}, 0, 0, RFLAGS, "nns" },
146  {"n256", NULL, 0, AV_OPT_TYPE_CONST, {.i64=4}, 0, 0, RFLAGS, "nns" },
147  {"qual", "set quality", OFFSET(qual), AV_OPT_TYPE_INT, {.i64=1}, 1, 2, RFLAGS, "qual" },
148  {"fast", NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, RFLAGS, "qual" },
149  {"slow", NULL, 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, RFLAGS, "qual" },
150  {"etype", "set which set of weights to use in the predictor", OFFSET(etype), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, RFLAGS, "etype" },
151  {"a", "weights trained to minimize absolute error", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, RFLAGS, "etype" },
152  {"abs","weights trained to minimize absolute error", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, RFLAGS, "etype" },
153  {"s", "weights trained to minimize squared error", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, RFLAGS, "etype" },
154  {"mse","weights trained to minimize squared error", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, RFLAGS, "etype" },
155  {"pscrn", "set prescreening", OFFSET(pscrn), AV_OPT_TYPE_INT, {.i64=2}, 0, 4, RFLAGS, "pscrn" },
156  {"none", NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, RFLAGS, "pscrn" },
157  {"original", NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, RFLAGS, "pscrn" },
158  {"new", NULL, 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, RFLAGS, "pscrn" },
159  {"new2", NULL, 0, AV_OPT_TYPE_CONST, {.i64=3}, 0, 0, RFLAGS, "pscrn" },
160  {"new3", NULL, 0, AV_OPT_TYPE_CONST, {.i64=4}, 0, 0, RFLAGS, "pscrn" },
161  { NULL }
162 };
163 
164 AVFILTER_DEFINE_CLASS(nnedi);
165 
166 static int config_output(AVFilterLink *outlink)
167 {
168  AVFilterContext *ctx = outlink->src;
169 
170  outlink->time_base = av_mul_q(ctx->inputs[0]->time_base, (AVRational){1, 2});
171  outlink->w = ctx->inputs[0]->w;
172  outlink->h = ctx->inputs[0]->h;
173 
174  outlink->frame_rate = av_mul_q(ctx->inputs[0]->frame_rate,
175  (AVRational){2, 1});
176 
177  return 0;
178 }
179 
181 {
182  static const enum AVPixelFormat pix_fmts[] = {
206  };
207 
209 }
210 
211 static float dot_dsp(const NNEDIContext *const s, const float *kernel, const float *input,
212  int n, float scale, float bias)
213 {
214  float sum, y;
215 
216  sum = s->fdsp->scalarproduct_float(kernel, input, n);
217 
218  y = sum * scale + bias + 1e-20f;
219 
220  return y;
221 }
222 
223 static float elliott(float x)
224 {
225  return x / (1.0f + fabsf(x));
226 }
227 
228 static void transform_elliott(float *input, int size)
229 {
230  for (int i = 0; i < size; i++)
231  input[i] = elliott(input[i]);
232 }
233 
235  const void *src, ptrdiff_t src_stride,
236  uint8_t *prescreen, int N,
237  const PrescreenerCoefficients *const m_data)
238 {
239  NNEDIContext *s = ctx->priv;
240  const float *src_p = src;
241 
242  // Adjust source pointer to point to top-left of filter window.
243  const float *window = src_p - 2 * src_stride - 5;
244 
245  for (int j = 0; j < N; j++) {
246  LOCAL_ALIGNED_32(float, input, [48]);
247  float state[12];
248 
249  for (int i = 0; i < 4; i++)
250  memcpy(input + i * 12, window + i * src_stride + j, 12 * sizeof(float));
251 
252  // Layer 0.
253  for (int n = 0; n < 4; n++)
254  state[n] = dot_dsp(s, m_data->kernel_l0[n], input, 48, 1.0f, m_data->bias_l0[n]);
255  transform_elliott(state + 1, 3);
256 
257  // Layer 1.
258  for (int n = 0; n < 4; n++)
259  state[n + 4] = dot_dsp(s, m_data->kernel_l1[n], state, 4, 1.0f, m_data->bias_l1[n]);
260  transform_elliott(state + 4, 3);
261 
262  // Layer 2.
263  for (int n = 0; n < 4; n++)
264  state[n + 8] = dot_dsp(s, m_data->kernel_l2[n], state, 8, 1.0f, m_data->bias_l2[n]);
265 
266  prescreen[j] = FFMAX(state[10], state[11]) <= FFMAX(state[8], state[9]) ? 255 : 0;
267  }
268 }
269 
271  const void *src, ptrdiff_t src_stride,
272  uint8_t *prescreen, int N,
273  const PrescreenerCoefficients *const m_data)
274 {
275  NNEDIContext *s = ctx->priv;
276  const float *src_p = src;
277 
278  // Adjust source pointer to point to top-left of filter window.
279  const float *window = src_p - 2 * src_stride - 6;
280 
281  for (int j = 0; j < N; j += 4) {
282  LOCAL_ALIGNED_32(float, input, [64]);
283  float state[8];
284 
285  for (int i = 0; i < 4; i++)
286  memcpy(input + i * 16, window + i * src_stride + j, 16 * sizeof(float));
287 
288  for (int n = 0; n < 4; n++)
289  state[n] = dot_dsp(s, m_data->kernel_l0[n], input, 64, 1.0f, m_data->bias_l0[n]);
291 
292  for (int n = 0; n < 4; n++)
293  state[n + 4] = dot_dsp(s, m_data->kernel_l1[n], state, 4, 1.0f, m_data->bias_l1[n]);
294 
295  for (int n = 0; n < 4; n++)
296  prescreen[j + n] = state[n + 4] > 0.f;
297  }
298 }
299 
300 static int filter_offset(int nn, const PredictorCoefficients *const model)
301 {
302  return nn * model->nsize;
303 }
304 
305 static const float *softmax_q1_filter(int nn,
306  const PredictorCoefficients *const model)
307 {
308  return model->softmax_q1 + filter_offset(nn, model);
309 }
310 
311 static const float *elliott_q1_filter(int nn,
312  const PredictorCoefficients *const model)
313 {
314  return model->elliott_q1 + filter_offset(nn, model);
315 }
316 
317 static const float *softmax_q2_filter(int nn,
318  const PredictorCoefficients *const model)
319 {
320  return model->softmax_q2 + filter_offset(nn, model);
321 }
322 
323 static const float *elliott_q2_filter(int nn,
324  const PredictorCoefficients *const model)
325 {
326  return model->elliott_q2 + filter_offset(nn, model);
327 }
328 
329 static void gather_input(const float *src, ptrdiff_t src_stride,
330  float *buf, float mstd[4],
331  const PredictorCoefficients *const model)
332 {
333  const float scale = 1.f / model->nsize;
334  float sum = 0.f;
335  float sum_sq = 0.f;
336  float tmp;
337 
338  for (int i = 0; i < model->ydim; i++) {
339  memcpy(buf, src, model->xdim * sizeof(float));
340 
341  for (int j = 0; j < model->xdim; j++) {
342  const float val = src[j];
343 
344  sum += val;
345  sum_sq += val * val;
346  }
347 
348  src += src_stride;
349  buf += model->xdim;
350  }
351 
352  mstd[0] = sum * scale;
353  mstd[3] = 0.f;
354 
355  tmp = sum_sq * scale - mstd[0] * mstd[0];
356  if (tmp < FLT_EPSILON) {
357  mstd[1] = 0.0f;
358  mstd[2] = 0.0f;
359  } else {
360  mstd[1] = sqrtf(tmp);
361  mstd[2] = 1.0f / mstd[1];
362  }
363 }
364 
365 static float softmax_exp(float x)
366 {
367  return expf(av_clipf(x, -80.f, 80.f));
368 }
369 
370 static void transform_softmax_exp(float *input, int size)
371 {
372  for (int i = 0; i < size; i++)
373  input[i] = softmax_exp(input[i]);
374 }
375 
376 static void wae5(const float *softmax, const float *el,
377  int n, float mstd[4])
378 {
379  float vsum = 0.0f, wsum = 0.0f;
380 
381  for (int i = 0; i < n; i++) {
382  vsum += softmax[i] * elliott(el[i]);
383  wsum += softmax[i];
384  }
385 
386  if (wsum > 1e-10f)
387  mstd[3] += (5.0f * vsum) / wsum * mstd[1] + mstd[0];
388  else
389  mstd[3] += mstd[0];
390 }
391 
393  const void *src, ptrdiff_t src_stride, void *dst,
394  const uint8_t *prescreen, int N,
395  const PredictorCoefficients *const model, int use_q2)
396 {
397  const NNEDIContext *const s = ctx->priv;
398  const float *src_p = src;
399  float *dst_p = dst;
400 
401  // Adjust source pointer to point to top-left of filter window.
402  const float *window = src_p - (model->ydim / 2) * src_stride - (model->xdim / 2 - 1);
403  const int filter_size = model->nsize;
404  const int nns = model->nns;
405 
406  for (int i = 0; i < N; i++) {
407  LOCAL_ALIGNED_32(float, input, [48 * 6]);
408  float activation[256 * 2];
409  float mstd[4];
410  float scale;
411 
412  if (prescreen[i])
413  continue;
414 
415  gather_input(window + i, src_stride, input, mstd, model);
416  scale = mstd[2];
417 
418  for (int nn = 0; nn < nns; nn++)
419  activation[nn] = dot_dsp(s, softmax_q1_filter(nn, model), input, filter_size, scale, model->softmax_bias_q1[nn]);
420 
421  for (int nn = 0; nn < nns; nn++)
422  activation[nns + nn] = dot_dsp(s, elliott_q1_filter(nn, model), input, filter_size, scale, model->elliott_bias_q1[nn]);
423 
424  transform_softmax_exp(activation, nns);
425  wae5(activation, activation + nns, nns, mstd);
426 
427  if (use_q2) {
428  for (int nn = 0; nn < nns; nn++)
429  activation[nn] = dot_dsp(s, softmax_q2_filter(nn, model), input, filter_size, scale, model->softmax_bias_q2[nn]);
430 
431  for (int nn = 0; nn < nns; nn++)
432  activation[nns + nn] = dot_dsp(s, elliott_q2_filter(nn, model), input, filter_size, scale, model->elliott_bias_q2[nn]);
433 
434  transform_softmax_exp(activation, nns);
435  wae5(activation, activation + nns, nns, mstd);
436  }
437 
438  dst_p[i] = mstd[3] * (use_q2 ? 0.5f : 1.f);
439  }
440 }
441 
442 static void read_bytes(const uint8_t *src, float *dst,
443  int src_stride, int dst_stride,
444  int width, int height, float scale)
445 {
446  for (int y = 0; y < height; y++) {
447  for (int x = 0; x < 32; x++)
448  dst[-x - 1] = src[x];
449 
450  for (int x = 0; x < width; x++)
451  dst[x] = src[x];
452 
453  for (int x = 0; x < 32; x++)
454  dst[width + x] = src[width - x - 1];
455 
456  dst += dst_stride;
457  src += src_stride;
458  }
459 }
460 
461 static void read_words(const uint8_t *srcp, float *dst,
462  int src_stride, int dst_stride,
463  int width, int height, float scale)
464 {
465  const uint16_t *src = (const uint16_t *)srcp;
466 
467  src_stride /= 2;
468 
469  for (int y = 0; y < height; y++) {
470  for (int x = 0; x < 32; x++)
471  dst[-x - 1] = src[x] * scale;
472 
473  for (int x = 0; x < width; x++)
474  dst[x] = src[x] * scale;
475 
476  for (int x = 0; x < 32; x++)
477  dst[width + x] = src[width - x - 1] * scale;
478 
479  dst += dst_stride;
480  src += src_stride;
481  }
482 }
483 
484 static void write_bytes(const float *src, uint8_t *dst,
485  int src_stride, int dst_stride,
486  int width, int height, int depth,
487  float scale)
488 {
489  for (int y = 0; y < height; y++) {
490  for (int x = 0; x < width; x++)
491  dst[x] = av_clip_uint8(src[x]);
492 
493  dst += dst_stride;
494  src += src_stride;
495  }
496 }
497 
498 static void write_words(const float *src, uint8_t *dstp,
499  int src_stride, int dst_stride,
500  int width, int height, int depth,
501  float scale)
502 {
503  uint16_t *dst = (uint16_t *)dstp;
504 
505  dst_stride /= 2;
506 
507  for (int y = 0; y < height; y++) {
508  for (int x = 0; x < width; x++)
509  dst[x] = av_clip_uintp2_c(src[x] * scale, depth);
510 
511  dst += dst_stride;
512  src += src_stride;
513  }
514 }
515 
516 static void interpolation(const void *src, ptrdiff_t src_stride,
517  void *dst, const uint8_t *prescreen, int n)
518 {
519  const float *src_p = src;
520  float *dst_p = dst;
521  const float *window = src_p - 2 * src_stride;
522 
523  for (int i = 0; i < n; i++) {
524  float accum = 0.0f;
525 
526  if (!prescreen[i])
527  continue;
528 
529  accum += (-3.0f / 32.0f) * window[0 * src_stride + i];
530  accum += (19.0f / 32.0f) * window[1 * src_stride + i];
531  accum += (19.0f / 32.0f) * window[2 * src_stride + i];
532  accum += (-3.0f / 32.0f) * window[3 * src_stride + i];
533 
534  dst_p[i] = accum;
535  }
536 }
537 
538 static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
539 {
540  const NNEDIContext *const s = ctx->priv;
541  AVFrame *out = arg;
542  AVFrame *in = s->prev;
543  const float in_scale = s->in_scale;
544  const float out_scale = s->out_scale;
545  const int depth = s->depth;
546  const int interlaced = in->interlaced_frame;
547  const int tff = s->field_n == (s->field < 0 ? interlaced ? in->top_field_first : 1 :
548  (s->field & 1) ^ 1);
549 
550 
551  for (int p = 0; p < s->nb_planes; p++) {
552  const int height = s->planeheight[p];
553  const int width = s->planewidth[p];
554  const int slice_start = 2 * ((height / 2 * jobnr) / nb_jobs);
555  const int slice_end = 2 * ((height / 2 * (jobnr+1)) / nb_jobs);
556  const uint8_t *src_data = in->data[p];
557  uint8_t *dst_data = out->data[p];
558  uint8_t *dst = out->data[p] + slice_start * out->linesize[p];
559  const int src_linesize = in->linesize[p];
560  const int dst_linesize = out->linesize[p];
561  uint8_t *prescreen_buf = s->prescreen_buf[jobnr];
562  float *srcbuf = s->input_buf[jobnr];
563  const int srcbuf_stride = width + 64;
564  float *dstbuf = s->output_buf[jobnr];
565  const int dstbuf_stride = width;
566  const int slice_height = (slice_end - slice_start) / 2;
567  const int last_slice = slice_end == height;
568  const uint8_t *in_line;
569  uint8_t *out_line;
570  int y_out;
571 
572  if (!(s->process_plane & (1 << p))) {
573  av_image_copy_plane(dst, out->linesize[p],
574  in->data[p] + slice_start * in->linesize[p],
575  in->linesize[p],
576  s->linesize[p], slice_end - slice_start);
577  continue;
578  }
579 
580  y_out = slice_start + (tff ^ (slice_start & 1));
581  in_line = src_data + (y_out * src_linesize);
582  out_line = dst_data + (y_out * dst_linesize);
583 
584  while (y_out < slice_end) {
585  memcpy(out_line, in_line, s->linesize[p]);
586  y_out += 2;
587  in_line += src_linesize * 2;
588  out_line += dst_linesize * 2;
589  }
590 
591  y_out = slice_start + ((!tff) ^ (slice_start & 1));
592 
593  s->read(src_data + FFMAX(y_out - 5, tff) * src_linesize,
594  srcbuf + 32,
595  src_linesize * 2, srcbuf_stride,
596  width, 1, in_scale);
597  srcbuf += srcbuf_stride;
598 
599  s->read(src_data + FFMAX(y_out - 3, tff) * src_linesize,
600  srcbuf + 32,
601  src_linesize * 2, srcbuf_stride,
602  width, 1, in_scale);
603  srcbuf += srcbuf_stride;
604 
605  s->read(src_data + FFMAX(y_out - 1, tff) * src_linesize,
606  srcbuf + 32,
607  src_linesize * 2, srcbuf_stride,
608  width, 1, in_scale);
609  srcbuf += srcbuf_stride;
610 
611  in_line = src_data + FFMIN(y_out + 1, height - 1 - !tff) * src_linesize;
612  out_line = dst_data + (y_out * dst_linesize);
613 
614  s->read(in_line, srcbuf + 32, src_linesize * 2, srcbuf_stride,
615  width, slice_height - last_slice, in_scale);
616 
617  y_out += (slice_height - last_slice) * 2;
618 
619  s->read(src_data + FFMIN(y_out + 1, height - 1 - !tff) * src_linesize,
620  srcbuf + 32 + srcbuf_stride * (slice_height - last_slice),
621  src_linesize * 2, srcbuf_stride,
622  width, 1, in_scale);
623 
624  s->read(src_data + FFMIN(y_out + 3, height - 1 - !tff) * src_linesize,
625  srcbuf + 32 + srcbuf_stride * (slice_height + 1 - last_slice),
626  src_linesize * 2, srcbuf_stride,
627  width, 1, in_scale);
628 
629  s->read(src_data + FFMIN(y_out + 5, height - 1 - !tff) * src_linesize,
630  srcbuf + 32 + srcbuf_stride * (slice_height + 2 - last_slice),
631  src_linesize * 2, srcbuf_stride,
632  width, 1, in_scale);
633 
634  for (int y = 0; y < slice_end - slice_start; y += 2) {
635  if (s->pscrn > 0)
636  s->prescreen[s->pscrn > 1](ctx, srcbuf + (y / 2) * srcbuf_stride + 32,
637  srcbuf_stride, prescreen_buf, width,
638  &s->prescreener[s->pscrn - 1]);
639 
640  predictor(ctx,
641  srcbuf + (y / 2) * srcbuf_stride + 32,
642  srcbuf_stride,
643  dstbuf + (y / 2) * dstbuf_stride,
644  prescreen_buf, width,
645  &s->coeffs[s->etype][s->nnsparam][s->nsize], s->qual == 2);
646 
647  if (s->pscrn > 0)
648  interpolation(srcbuf + (y / 2) * srcbuf_stride + 32,
649  srcbuf_stride,
650  dstbuf + (y / 2) * dstbuf_stride,
651  prescreen_buf, width);
652  }
653 
654  s->write(dstbuf, out_line, dstbuf_stride, dst_linesize * 2,
655  width, slice_height, depth, out_scale);
656  }
657 
658  return 0;
659 }
660 
661 static int get_frame(AVFilterContext *ctx, int is_second)
662 {
663  NNEDIContext *s = ctx->priv;
664  AVFilterLink *outlink = ctx->outputs[0];
665  AVFrame *dst;
666 
667  dst = ff_get_video_buffer(outlink, outlink->w, outlink->h);
668  if (!dst)
669  return AVERROR(ENOMEM);
670  av_frame_copy_props(dst, s->prev);
671  dst->interlaced_frame = 0;
672  dst->pts = s->pts;
673 
675  FFMIN(s->planeheight[1] / 2, s->nb_threads));
676 
677  if (s->field == -2 || s->field > 1)
678  s->field_n = !s->field_n;
679 
680  return ff_filter_frame(outlink, dst);
681 }
682 
684 {
685  AVFilterContext *ctx = inlink->dst;
686  NNEDIContext *s = ctx->priv;
687  int ret;
688 
689  if (!s->prev) {
690  s->prev = in;
691  return 0;
692  }
693 
694  if ((s->deint && !s->prev->interlaced_frame) || ctx->is_disabled) {
695  s->prev->pts *= 2;
696  ret = ff_filter_frame(ctx->outputs[0], s->prev);
697  s->prev = in;
698  return ret;
699  }
700 
701  s->pts = s->prev->pts * 2;
702  ret = get_frame(ctx, 0);
703  if (ret < 0 || (s->field > -2 && s->field < 2)) {
704  av_frame_free(&s->prev);
705  s->prev = in;
706  return ret;
707  }
708 
709  s->pts = s->prev->pts + in->pts;
710  ret = get_frame(ctx, 1);
711  av_frame_free(&s->prev);
712  s->prev = in;
713  return ret;
714 }
715 
717 {
718  AVFilterContext *ctx = link->src;
719  NNEDIContext *s = ctx->priv;
720  int ret;
721 
722  if (s->eof)
723  return AVERROR_EOF;
724 
725  ret = ff_request_frame(ctx->inputs[0]);
726 
727  if (ret == AVERROR_EOF && s->prev) {
728  AVFrame *next = av_frame_clone(s->prev);
729 
730  if (!next)
731  return AVERROR(ENOMEM);
732 
733  next->pts = s->prev->pts + av_rescale_q(1, av_inv_q(ctx->outputs[0]->frame_rate),
734  ctx->outputs[0]->time_base);
735  s->eof = 1;
736 
737  ret = filter_frame(ctx->inputs[0], next);
738  } else if (ret < 0) {
739  return ret;
740  }
741 
742  return ret;
743 }
744 
745 static void copy_weights(float *dst, int n, const float **data)
746 {
747  memcpy(dst, *data, n * sizeof(float));
748  *data += n;
749 }
750 
751 static float *allocate(float **ptr, int size)
752 {
753  float *ret = *ptr;
754 
755  *ptr += size;
756 
757  return ret;
758 }
759 
760 static int allocate_model(PredictorCoefficients *coeffs, int xdim, int ydim, int nns)
761 {
762  int filter_size = nns * xdim * ydim;
763  int bias_size = nns;
764  float *data;
765 
766  data = av_calloc(filter_size + bias_size, 4 * sizeof(float));
767  if (!data)
768  return AVERROR(ENOMEM);
769 
770  coeffs->data = data;
771  coeffs->xdim = xdim;
772  coeffs->ydim = ydim;
773  coeffs->nsize = xdim * ydim;
774  coeffs->nns = nns;
775 
776  coeffs->softmax_q1 = allocate(&data, filter_size);
777  coeffs->elliott_q1 = allocate(&data, filter_size);
778  coeffs->softmax_bias_q1 = allocate(&data, bias_size);
779  coeffs->elliott_bias_q1 = allocate(&data, bias_size);
780 
781  coeffs->softmax_q2 = allocate(&data, filter_size);
782  coeffs->elliott_q2 = allocate(&data, filter_size);
783  coeffs->softmax_bias_q2 = allocate(&data, bias_size);
784  coeffs->elliott_bias_q2 = allocate(&data, bias_size);
785 
786  return 0;
787 }
788 
789 static int read_weights(AVFilterContext *ctx, const float *bdata)
790 {
791  NNEDIContext *s = ctx->priv;
792  int ret;
793 
794  copy_weights(&s->prescreener[0].kernel_l0[0][0], 4 * 48, &bdata);
795  copy_weights(s->prescreener[0].bias_l0, 4, &bdata);
796 
797  copy_weights(&s->prescreener[0].kernel_l1[0][0], 4 * 4, &bdata);
798  copy_weights(s->prescreener[0].bias_l1, 4, &bdata);
799 
800  copy_weights(&s->prescreener[0].kernel_l2[0][0], 4 * 8, &bdata);
801  copy_weights(s->prescreener[0].bias_l2, 4, &bdata);
802 
803  for (int i = 0; i < 3; i++) {
804  PrescreenerCoefficients *data = &s->prescreener[i + 1];
805  float kernel_l0_shuffled[4 * 64];
806  float kernel_l1_shuffled[4 * 4];
807 
808  copy_weights(kernel_l0_shuffled, 4 * 64, &bdata);
809  copy_weights(data->bias_l0, 4, &bdata);
810 
811  copy_weights(kernel_l1_shuffled, 4 * 4, &bdata);
812  copy_weights(data->bias_l1, 4, &bdata);
813 
814  for (int n = 0; n < 4; n++) {
815  for (int k = 0; k < 64; k++)
816  data->kernel_l0[n][k] = kernel_l0_shuffled[(k / 8) * 32 + n * 8 + k % 8];
817  for (int k = 0; k < 4; k++)
818  data->kernel_l1[n][k] = kernel_l1_shuffled[k * 4 + n];
819  }
820  }
821 
822  for (int m = 0; m < 2; m++) {
823  // Grouping by neuron count.
824  for (int i = 0; i < 5; i++) {
825  const int nns = NNEDI_NNS[i];
826 
827  // Grouping by window size.
828  for (int j = 0; j < 7; j++) {
829  PredictorCoefficients *model = &s->coeffs[m][i][j];
830  const int xdim = NNEDI_XDIM[j];
831  const int ydim = NNEDI_YDIM[j];
832  const int filter_size = xdim * ydim;
833 
834  ret = allocate_model(model, xdim, ydim, nns);
835  if (ret < 0)
836  return ret;
837 
838  // Quality 1 model. NNS[i] * (XDIM[j] * YDIM[j]) * 2 coefficients.
839  copy_weights(model->softmax_q1, nns * filter_size, &bdata);
840  copy_weights(model->elliott_q1, nns * filter_size, &bdata);
841 
842  // Quality 1 model bias. NNS[i] * 2 coefficients.
843  copy_weights(model->softmax_bias_q1, nns, &bdata);
844  copy_weights(model->elliott_bias_q1, nns, &bdata);
845 
846  // Quality 2 model. NNS[i] * (XDIM[j] * YDIM[j]) * 2 coefficients.
847  copy_weights(model->softmax_q2, nns * filter_size, &bdata);
848  copy_weights(model->elliott_q2, nns * filter_size, &bdata);
849 
850  // Quality 2 model bias. NNS[i] * 2 coefficients.
851  copy_weights(model->softmax_bias_q2, nns, &bdata);
852  copy_weights(model->elliott_bias_q2, nns, &bdata);
853  }
854  }
855  }
856 
857  return 0;
858 }
859 
860 static float mean(const float *input, int size)
861 {
862  float sum = 0.f;
863 
864  for (int i = 0; i < size; i++)
865  sum += input[i];
866 
867  return sum / size;
868 }
869 
870 static void transform(float *input, int size, float mean, float half)
871 {
872  for (int i = 0; i < size; i++)
873  input[i] = (input[i] - mean) / half;
874 }
875 
876 static void subtract_mean_old(PrescreenerCoefficients *coeffs, float half)
877 {
878  for (int n = 0; n < 4; n++) {
879  float m = mean(coeffs->kernel_l0[n], 48);
880 
881  transform(coeffs->kernel_l0[n], 48, m, half);
882  }
883 }
884 
885 static void subtract_mean_new(PrescreenerCoefficients *coeffs, float half)
886 {
887  for (int n = 0; n < 4; n++) {
888  float m = mean(coeffs->kernel_l0[n], 64);
889 
890  transform(coeffs->kernel_l0[n], 64, m, half);
891  }
892 }
893 
895 {
896  const int filter_size = model->nsize;
897  const int nns = model->nns;
898  const float scale = 1.f / nns;
899 
900  double softmax_means[256]; // Average of individual softmax filters.
901  double elliott_means[256]; // Average of individual elliott filters.
902  double mean_filter[48 * 6] = { 0 }; // Pointwise average of all softmax filters.
903  double mean_bias;
904 
905  // Quality 1.
906  for (int nn = 0; nn < nns; nn++) {
907  softmax_means[nn] = mean(model->softmax_q1 + nn * filter_size, filter_size);
908  elliott_means[nn] = mean(model->elliott_q1 + nn * filter_size, filter_size);
909 
910  for (int k = 0; k < filter_size; k++)
911  mean_filter[k] += model->softmax_q1[nn * filter_size + k] - softmax_means[nn];
912  }
913 
914  for (int k = 0; k < filter_size; k++)
915  mean_filter[k] *= scale;
916 
917  mean_bias = mean(model->softmax_bias_q1, nns);
918 
919  for (int nn = 0; nn < nns; nn++) {
920  for (int k = 0; k < filter_size; k++) {
921  model->softmax_q1[nn * filter_size + k] -= softmax_means[nn] + mean_filter[k];
922  model->elliott_q1[nn * filter_size + k] -= elliott_means[nn];
923  }
924  model->softmax_bias_q1[nn] -= mean_bias;
925  }
926 
927  // Quality 2.
928  memset(mean_filter, 0, sizeof(mean_filter));
929 
930  for (int nn = 0; nn < nns; nn++) {
931  softmax_means[nn] = mean(model->softmax_q2 + nn * filter_size, filter_size);
932  elliott_means[nn] = mean(model->elliott_q2 + nn * filter_size, filter_size);
933 
934  for (int k = 0; k < filter_size; k++) {
935  mean_filter[k] += model->softmax_q2[nn * filter_size + k] - softmax_means[nn];
936  }
937  }
938 
939  for (int k = 0; k < filter_size; k++)
940  mean_filter[k] *= scale;
941 
942  mean_bias = mean(model->softmax_bias_q2, nns);
943 
944  for (int nn = 0; nn < nns; nn++) {
945  for (int k = 0; k < filter_size; k++) {
946  model->softmax_q2[nn * filter_size + k] -= softmax_means[nn] + mean_filter[k];
947  model->elliott_q2[nn * filter_size + k] -= elliott_means[nn];
948  }
949 
950  model->softmax_bias_q2[nn] -= mean_bias;
951  }
952 }
953 
955 {
956  NNEDIContext *s = ctx->priv;
957  FILE *weights_file = NULL;
958  int64_t weights_size;
959  float *bdata;
960  size_t bytes_read;
961  int ret = 0;
962 
963  weights_file = av_fopen_utf8(s->weights_file, "rb");
964  if (!weights_file) {
965  av_log(ctx, AV_LOG_ERROR, "No weights file provided, aborting!\n");
966  return AVERROR(EINVAL);
967  }
968 
969  if (fseek(weights_file, 0, SEEK_END)) {
970  av_log(ctx, AV_LOG_ERROR, "Couldn't seek to the end of weights file.\n");
971  fclose(weights_file);
972  return AVERROR(EINVAL);
973  }
974 
975  weights_size = ftell(weights_file);
976 
977  if (weights_size == -1) {
978  fclose(weights_file);
979  av_log(ctx, AV_LOG_ERROR, "Couldn't get size of weights file.\n");
980  return AVERROR(EINVAL);
981  } else if (weights_size != NNEDI_WEIGHTS_SIZE) {
982  fclose(weights_file);
983  av_log(ctx, AV_LOG_ERROR, "Unexpected weights file size.\n");
984  return AVERROR(EINVAL);
985  }
986 
987  if (fseek(weights_file, 0, SEEK_SET)) {
988  fclose(weights_file);
989  av_log(ctx, AV_LOG_ERROR, "Couldn't seek to the start of weights file.\n");
990  return AVERROR(EINVAL);
991  }
992 
993  bdata = av_malloc(NNEDI_WEIGHTS_SIZE);
994  if (!bdata) {
995  fclose(weights_file);
996  return AVERROR(ENOMEM);
997  }
998 
999  bytes_read = fread(bdata, 1, NNEDI_WEIGHTS_SIZE, weights_file);
1000  if (bytes_read != NNEDI_WEIGHTS_SIZE) {
1001  fclose(weights_file);
1003  av_log(ctx, AV_LOG_ERROR, "Couldn't read weights file.\n");
1004  goto fail;
1005  }
1006 
1007  fclose(weights_file);
1008 
1009  s->fdsp = avpriv_float_dsp_alloc(0);
1010  if (!s->fdsp) {
1011  ret = AVERROR(ENOMEM);
1012  goto fail;
1013  }
1014 
1015  ret = read_weights(ctx, bdata);
1016  if (ret < 0)
1017  goto fail;
1018 
1019 fail:
1020  av_free(bdata);
1021  return ret;
1022 }
1023 
1025 {
1026  AVFilterContext *ctx = inlink->dst;
1027  NNEDIContext *s = ctx->priv;
1029  int ret;
1030 
1031  s->depth = desc->comp[0].depth;
1032  s->nb_threads = ff_filter_get_nb_threads(ctx);
1033  s->nb_planes = av_pix_fmt_count_planes(inlink->format);
1034  if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
1035  return ret;
1036 
1037  s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
1038  s->planewidth[0] = s->planewidth[3] = inlink->w;
1039  s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
1040  s->planeheight[0] = s->planeheight[3] = inlink->h;
1041 
1042  s->half = ((1 << 8) - 1) / 2.f;
1043  s->out_scale = 1 << (s->depth - 8);
1044  s->in_scale = 1.f / s->out_scale;
1045 
1046  switch (s->depth) {
1047  case 8:
1048  s->read = read_bytes;
1049  s->write = write_bytes;
1050  break;
1051  default:
1052  s->read = read_words;
1053  s->write = write_words;
1054  break;
1055  }
1056 
1057  subtract_mean_old(&s->prescreener[0], s->half);
1058  subtract_mean_new(&s->prescreener[1], s->half);
1059  subtract_mean_new(&s->prescreener[2], s->half);
1060  subtract_mean_new(&s->prescreener[3], s->half);
1061 
1062  s->prescreen[0] = process_old;
1063  s->prescreen[1] = process_new;
1064 
1065  for (int i = 0; i < 2; i++) {
1066  for (int j = 0; j < 5; j++) {
1067  for (int k = 0; k < 7; k++)
1068  subtract_mean_predictor(&s->coeffs[i][j][k]);
1069  }
1070  }
1071 
1072  s->input_size = (s->planewidth[0] + 64) * (s->planeheight[0] + 6);
1073  s->input_buf = av_calloc(s->nb_threads, sizeof(*s->input_buf));
1074  if (!s->input_buf)
1075  return AVERROR(ENOMEM);
1076 
1077  for (int i = 0; i < s->nb_threads; i++) {
1078  s->input_buf[i] = av_calloc(s->input_size, sizeof(**s->input_buf));
1079  if (!s->input_buf[i])
1080  return AVERROR(ENOMEM);
1081  }
1082 
1083  s->output_buf = av_calloc(s->nb_threads, sizeof(*s->output_buf));
1084  if (!s->output_buf)
1085  return AVERROR(ENOMEM);
1086 
1087  for (int i = 0; i < s->nb_threads; i++) {
1088  s->output_buf[i] = av_calloc(s->input_size, sizeof(**s->output_buf));
1089  if (!s->output_buf[i])
1090  return AVERROR(ENOMEM);
1091  }
1092 
1093  s->prescreen_buf = av_calloc(s->nb_threads, sizeof(*s->prescreen_buf));
1094  if (!s->prescreen_buf)
1095  return AVERROR(ENOMEM);
1096 
1097  for (int i = 0; i < s->nb_threads; i++) {
1098  s->prescreen_buf[i] = av_calloc(s->planewidth[0], sizeof(**s->prescreen_buf));
1099  if (!s->prescreen_buf[i])
1100  return AVERROR(ENOMEM);
1101  }
1102 
1103  return 0;
1104 }
1105 
1107 {
1108  NNEDIContext *s = ctx->priv;
1109 
1110  for (int i = 0; i < s->nb_threads && s->prescreen_buf; i++)
1111  av_freep(&s->prescreen_buf[i]);
1112 
1113  av_freep(&s->prescreen_buf);
1114 
1115  for (int i = 0; i < s->nb_threads && s->input_buf; i++)
1116  av_freep(&s->input_buf[i]);
1117 
1118  av_freep(&s->input_buf);
1119 
1120  for (int i = 0; i < s->nb_threads && s->output_buf; i++)
1121  av_freep(&s->output_buf[i]);
1122 
1123  av_freep(&s->output_buf);
1124  av_freep(&s->fdsp);
1125 
1126  for (int i = 0; i < 2; i++) {
1127  for (int j = 0; j < 5; j++) {
1128  for (int k = 0; k < 7; k++) {
1129  av_freep(&s->coeffs[i][j][k].data);
1130  }
1131  }
1132  }
1133 
1134  av_frame_free(&s->prev);
1135 }
1136 
1137 static const AVFilterPad inputs[] = {
1138  {
1139  .name = "default",
1140  .type = AVMEDIA_TYPE_VIDEO,
1141  .filter_frame = filter_frame,
1142  .config_props = config_input,
1143  },
1144 };
1145 
1146 static const AVFilterPad outputs[] = {
1147  {
1148  .name = "default",
1149  .type = AVMEDIA_TYPE_VIDEO,
1150  .config_props = config_output,
1151  .request_frame = request_frame,
1152  },
1153 };
1154 
1156  .name = "nnedi",
1157  .description = NULL_IF_CONFIG_SMALL("Apply neural network edge directed interpolation intra-only deinterlacer."),
1158  .priv_size = sizeof(NNEDIContext),
1159  .priv_class = &nnedi_class,
1160  .init = init,
1161  .uninit = uninit,
1166  .process_command = ff_filter_process_command,
1167 };
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:98
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:432
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:411
dot_dsp
static float dot_dsp(const NNEDIContext *const s, const float *kernel, const float *input, int n, float scale, float bias)
Definition: vf_nnedi.c:211
NNEDIContext::prescreen_buf
uint8_t ** prescreen_buf
Definition: vf_nnedi.c:100
NNEDIContext::fdsp
AVFloatDSPContext * fdsp
Definition: vf_nnedi.c:73
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
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
get_frame
static int get_frame(AVFilterContext *ctx, int is_second)
Definition: vf_nnedi.c:661
mem_internal.h
NNEDIContext::pscrn
int pscrn
Definition: vf_nnedi.c:97
subtract_mean_predictor
static void subtract_mean_predictor(PredictorCoefficients *model)
Definition: vf_nnedi.c:894
out
FILE * out
Definition: movenc.c:54
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1017
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2540
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
PredictorCoefficients::softmax_bias_q2
float * softmax_bias_q2
Definition: vf_nnedi.c:60
NNEDIContext::field
int field
Definition: vf_nnedi.c:91
NNEDIContext::weights_file
char * weights_file
Definition: vf_nnedi.c:67
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
softmax_q2_filter
static const float * softmax_q2_filter(int nn, const PredictorCoefficients *const model)
Definition: vf_nnedi.c:317
PrescreenerCoefficients::kernel_l2
float kernel_l2[4][8]
Definition: vf_nnedi.c:47
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
NNEDIContext::qual
int qual
Definition: vf_nnedi.c:95
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:424
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
pixdesc.h
av_clip_uintp2_c
static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p)
Clip a signed integer to an unsigned power of two range.
Definition: common.h:276
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:396
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:431
NNEDIContext
Definition: vf_nnedi.c:64
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:426
AVFrame::top_field_first
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:438
read_bytes
static void read_bytes(const uint8_t *src, float *dst, int src_stride, int dst_stride, int width, int height, float scale)
Definition: vf_nnedi.c:442
AVOption
AVOption.
Definition: opt.h:247
data
const char data[16]
Definition: mxf.c:143
expf
#define expf(x)
Definition: libm.h:283
half
static uint8_t half(int a, int b)
Definition: mobiclip.c:541
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:389
ff_request_frame
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:421
process_old
static void process_old(AVFilterContext *ctx, const void *src, ptrdiff_t src_stride, uint8_t *prescreen, int N, const PrescreenerCoefficients *const m_data)
Definition: vf_nnedi.c:234
NNEDIContext::prescreen
void(* prescreen[2])(AVFilterContext *ctx, const void *src, ptrdiff_t src_stride, uint8_t *prescreen, int N, const PrescreenerCoefficients *const coeffs)
Definition: vf_nnedi.c:110
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(nnedi)
OFFSET
#define OFFSET(x)
Definition: vf_nnedi.c:116
float.h
NNEDIContext::nsize
int nsize
Definition: vf_nnedi.c:93
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_nnedi.c:1106
NNEDIContext::depth
int depth
Definition: vf_nnedi.c:74
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:153
video.h
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:427
PrescreenerCoefficients::bias_l2
float bias_l2[4]
Definition: vf_nnedi.c:48
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:369
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
av_image_copy_plane
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition: imgutils.c:374
formats.h
elliott
static float elliott(float x)
Definition: vf_nnedi.c:223
NNEDIContext::pts
int64_t pts
Definition: vf_nnedi.c:71
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2580
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:423
window
static SDL_Window * window
Definition: ffplay.c:364
elliott_q2_filter
static const float * elliott_q2_filter(int nn, const PredictorCoefficients *const model)
Definition: vf_nnedi.c:323
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:407
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:205
fail
#define fail()
Definition: checkasm.h:127
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:405
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:433
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:387
PredictorCoefficients::softmax_q1
float * softmax_q1
Definition: vf_nnedi.c:54
ff_vf_nnedi
const AVFilter ff_vf_nnedi
Definition: vf_nnedi.c:1155
NNEDIContext::nnsparam
int nnsparam
Definition: vf_nnedi.c:94
val
static double val(void *priv, double ch)
Definition: aeval.c:76
PredictorCoefficients::data
float * data
Definition: vf_nnedi.c:53
NNEDI_XDIM
static const uint8_t NNEDI_XDIM[]
Definition: vf_nnedi.c:36
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:373
fabsf
static __device__ float fabsf(float a)
Definition: cuda_runtime.h:181
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:50
write_words
static void write_words(const float *src, uint8_t *dstp, int src_stride, int dst_stride, int width, int height, int depth, float scale)
Definition: vf_nnedi.c:498
softmax_exp
static float softmax_exp(float x)
Definition: vf_nnedi.c:365
NNEDIContext::eof
int eof
Definition: vf_nnedi.c:70
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:392
AV_PIX_FMT_YUVJ411P
@ AV_PIX_FMT_YUVJ411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
Definition: pixfmt.h:248
filter_slice
static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_nnedi.c:538
inputs
static const AVFilterPad inputs[]
Definition: vf_nnedi.c:1137
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
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:401
av_fopen_utf8
FILE * av_fopen_utf8(const char *path, const char *mode)
Open a file using a UTF-8 filename.
Definition: file_open.c:158
RFLAGS
#define RFLAGS
Definition: vf_nnedi.c:117
allocate
static float * allocate(float **ptr, int size)
Definition: vf_nnedi.c:751
AV_PIX_FMT_YUVJ422P
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:79
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:409
NNEDI_NNS
static const uint16_t NNEDI_NNS[]
Definition: vf_nnedi.c:38
width
#define width
av_image_fill_linesizes
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.
Definition: imgutils.c:89
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:410
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:402
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:51
NNEDIContext::planewidth
int planewidth[4]
Definition: vf_nnedi.c:78
slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2037
PredictorCoefficients::softmax_bias_q1
float * softmax_bias_q1
Definition: vf_nnedi.c:56
ff_set_common_formats_from_list
int ff_set_common_formats_from_list(AVFilterContext *ctx, const int *fmts)
Equivalent to ff_set_common_formats(ctx, ff_make_format_list(fmts))
Definition: formats.c:703
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
PrescreenerCoefficients::kernel_l0
float kernel_l0[4][16 *4]
Definition: vf_nnedi.c:41
request_frame
static int request_frame(AVFilterLink *link)
Definition: vf_nnedi.c:716
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:430
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:386
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:400
ctx
AVFormatContext * ctx
Definition: movenc.c:48
AV_PIX_FMT_GRAY14
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:372
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:424
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:141
FLAGS
#define FLAGS
Definition: vf_nnedi.c:118
PredictorCoefficients::nns
int nns
Definition: vf_nnedi.c:52
field
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 field
Definition: writing_filters.txt:78
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
PredictorCoefficients::ydim
int ydim
Definition: vf_nnedi.c:52
f
#define f(width, name)
Definition: cbs_vp9.c:255
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:152
link
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 link
Definition: filter_design.txt:23
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
arg
const char * arg
Definition: jacosubdec.c:67
NNEDIContext::planeheight
int planeheight[4]
Definition: vf_nnedi.c:79
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:370
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:408
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
softmax_q1_filter
static const float * softmax_q1_filter(int nn, const PredictorCoefficients *const model)
Definition: vf_nnedi.c:305
interpolation
static void interpolation(const void *src, ptrdiff_t src_stride, void *dst, const uint8_t *prescreen, int n)
Definition: vf_nnedi.c:516
NULL
#define NULL
Definition: coverity.c:32
PrescreenerCoefficients::bias_l0
float bias_l0[4]
Definition: vf_nnedi.c:42
LOCAL_ALIGNED_32
#define LOCAL_ALIGNED_32(t, v,...)
Definition: mem_internal.h:136
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:537
NNEDIContext::coeffs
PredictorCoefficients coeffs[2][5][7]
Definition: vf_nnedi.c:83
PrescreenerCoefficients::bias_l1
float bias_l1[4]
Definition: vf_nnedi.c:45
subtract_mean_old
static void subtract_mean_old(PrescreenerCoefficients *coeffs, float half)
Definition: vf_nnedi.c:876
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_nnedi.c:180
state
static struct @317 state
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
transform_elliott
static void transform_elliott(float *input, int size)
Definition: vf_nnedi.c:228
av_clipf
#define av_clipf
Definition: common.h:144
src
#define src
Definition: vp8dsp.c:255
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:391
NNEDIContext::write
void(* write)(const float *src, uint8_t *dst, int src_stride, int dst_stride, int width, int height, int depth, float scale)
Definition: vf_nnedi.c:107
NNEDI_YDIM
static const uint8_t NNEDI_YDIM[]
Definition: vf_nnedi.c:37
nnedi_options
static const AVOption nnedi_options[]
Definition: vf_nnedi.c:120
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:390
PrescreenerCoefficients::kernel_l1
float kernel_l1[4][4]
Definition: vf_nnedi.c:44
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:404
NNEDIContext::etype
int etype
Definition: vf_nnedi.c:96
float_dsp.h
NNEDIContext::half
float half
Definition: vf_nnedi.c:85
NNEDIContext::nb_threads
int nb_threads
Definition: vf_nnedi.c:76
NNEDIContext::process_plane
int process_plane
Definition: vf_nnedi.c:92
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
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:394
wae5
static void wae5(const float *softmax, const float *el, int n, float mstd[4])
Definition: vf_nnedi.c:376
size
int size
Definition: twinvq_data.h:10344
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:396
NNEDIContext::nb_planes
int nb_planes
Definition: vf_nnedi.c:75
elliott_q1_filter
static const float * elliott_q1_filter(int nn, const PredictorCoefficients *const model)
Definition: vf_nnedi.c:311
AVFloatDSPContext
Definition: float_dsp.h:24
PrescreenerCoefficients
Definition: vf_nnedi.c:40
ff_filter_process_command
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
Definition: avfilter.c:883
PredictorCoefficients
Definition: vf_nnedi.c:51
predictor
static void predictor(AVFilterContext *ctx, const void *src, ptrdiff_t src_stride, void *dst, const uint8_t *prescreen, int N, const PredictorCoefficients *const model, int use_q2)
Definition: vf_nnedi.c:392
height
#define height
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:167
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:428
NNEDIContext::linesize
int linesize[4]
Definition: vf_nnedi.c:77
transform_softmax_exp
static void transform_softmax_exp(float *input, int size)
Definition: vf_nnedi.c:370
PredictorCoefficients::xdim
int xdim
Definition: vf_nnedi.c:52
N
#define N
Definition: af_mcompand.c:53
input
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
Definition: filter_design.txt:172
internal.h
outputs
static const AVFilterPad outputs[]
Definition: vf_nnedi.c:1146
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_nnedi.c:954
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:433
interlaced
uint8_t interlaced
Definition: mxfenc.c:2209
i
int i
Definition: input.c:406
filter_offset
static int filter_offset(int nn, const PredictorCoefficients *const model)
Definition: vf_nnedi.c:300
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:406
common.h
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:804
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_PIX_FMT_YUVJ440P
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
Definition: pixfmt.h:100
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:56
PredictorCoefficients::softmax_q2
float * softmax_q2
Definition: vf_nnedi.c:58
write_bytes
static void write_bytes(const float *src, uint8_t *dst, int src_stride, int dst_stride, int width, int height, int depth, float scale)
Definition: vf_nnedi.c:484
NNEDIContext::read
void(* read)(const uint8_t *src, float *dst, int src_stride, int dst_stride, int width, int height, float scale)
Definition: vf_nnedi.c:104
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:388
NNEDIContext::input_size
int input_size
Definition: vf_nnedi.c:99
AVFilter
Filter definition.
Definition: avfilter.h:149
PredictorCoefficients::nsize
int nsize
Definition: vf_nnedi.c:52
ret
ret
Definition: filter_design.txt:187
PredictorCoefficients::elliott_bias_q2
float * elliott_bias_q2
Definition: vf_nnedi.c:61
subtract_mean_new
static void subtract_mean_new(PrescreenerCoefficients *coeffs, float half)
Definition: vf_nnedi.c:885
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:425
gather_input
static void gather_input(const float *src, ptrdiff_t src_stride, float *buf, float mstd[4], const PredictorCoefficients *const model)
Definition: vf_nnedi.c:329
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:393
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:398
PredictorCoefficients::elliott_q2
float * elliott_q2
Definition: vf_nnedi.c:59
allocate_model
static int allocate_model(PredictorCoefficients *coeffs, int xdim, int ydim, int nns)
Definition: vf_nnedi.c:760
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Equivalent of av_mallocz_array().
Definition: mem.c:269
NNEDIContext::deint
int deint
Definition: vf_nnedi.c:90
NNEDIContext::in_scale
float in_scale
Definition: vf_nnedi.c:86
NNEDI_WEIGHTS_SIZE
static const size_t NNEDI_WEIGHTS_SIZE
Definition: vf_nnedi.c:35
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:429
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
avfilter.h
PredictorCoefficients::elliott_bias_q1
float * elliott_bias_q1
Definition: vf_nnedi.c:57
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_nnedi.c:683
process_new
static void process_new(AVFilterContext *ctx, const void *src, ptrdiff_t src_stride, uint8_t *prescreen, int N, const PrescreenerCoefficients *const m_data)
Definition: vf_nnedi.c:270
mean
static float mean(const float *input, int size)
Definition: vf_nnedi.c:860
NNEDIContext::input_buf
float ** input_buf
Definition: vf_nnedi.c:101
read_words
static void read_words(const uint8_t *srcp, float *dst, int src_stride, int dst_stride, int width, int height, float scale)
Definition: vf_nnedi.c:461
transform
static void transform(float *input, int size, float mean, float half)
Definition: vf_nnedi.c:870
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
av_clip_uint8
#define av_clip_uint8
Definition: common.h:102
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
AVFilterContext
An instance of a filter.
Definition: avfilter.h:346
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:121
desc
const char * desc
Definition: libsvtav1.c:79
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
PredictorCoefficients::elliott_q1
float * elliott_q1
Definition: vf_nnedi.c:55
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
NNEDIContext::out_scale
float out_scale
Definition: vf_nnedi.c:87
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:153
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
read_weights
static int read_weights(AVFilterContext *ctx, const float *bdata)
Definition: vf_nnedi.c:789
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
config_input
static int config_input(AVFilterLink *inlink)
Definition: vf_nnedi.c:1024
AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
Definition: avfilter.h:138
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
copy_weights
static void copy_weights(float *dst, int n, const float **data)
Definition: vf_nnedi.c:745
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:395
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:399
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:228
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:371
ff_filter_execute
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: internal.h:143
NNEDIContext::field_n
int field_n
Definition: vf_nnedi.c:80
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
NNEDIContext::prev
AVFrame * prev
Definition: vf_nnedi.c:69
NNEDIContext::output_buf
float ** output_buf
Definition: vf_nnedi.c:102
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:166
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:397
NNEDIContext::prescreener
PrescreenerCoefficients prescreener[4]
Definition: vf_nnedi.c:82
config_output
static int config_output(AVFilterLink *outlink)
Definition: vf_nnedi.c:166