FFmpeg
vf_decimate.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2012 Fredrik Mellbin
3  * Copyright (c) 2013 Clément Bœsch
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 #include "libavutil/mem.h"
23 #include "libavutil/opt.h"
24 #include "libavutil/pixdesc.h"
25 #include "avfilter.h"
26 #include "filters.h"
27 
28 #define INPUT_MAIN 0
29 #define INPUT_CLEANSRC 1
30 
31 struct qitem {
32  AVFrame *frame;
33  int64_t maxbdiff;
34  int64_t totdiff;
35 };
36 
37 typedef struct DecimateContext {
38  const AVClass *class;
39  struct qitem *queue; ///< window of cycle frames and the associated data diff
40  int fid; ///< current frame id in the queue
41  int filled; ///< 1 if the queue is filled, 0 otherwise
42  AVFrame *last; ///< last frame from the previous queue
43  AVFrame **clean_src; ///< frame queue for the clean source
44  int got_frame[2]; ///< frame request flag for each input stream
45  int64_t last_pts; ///< last output timestamp
46  int64_t last_duration; ///< last output duration
47  int64_t start_pts; ///< base for output timestamps
48  uint32_t eof; ///< bitmask for end of stream
49  int hsub, vsub; ///< chroma subsampling values
50  int depth;
51  int nxblocks, nyblocks;
52  int bdiffsize;
53  int64_t *bdiffs;
54  AVRational in_tb; // input time-base
55  AVRational nondec_tb; // non-decimated time-base
56  AVRational dec_tb; // decimated time-base
57 
58  /* options */
59  int cycle;
60  double dupthresh_flt;
61  double scthresh_flt;
62  int64_t dupthresh;
63  int64_t scthresh;
64  int blockx, blocky;
65  int ppsrc;
66  int chroma;
67  int mixed;
68 } DecimateContext;
69 
70 #define OFFSET(x) offsetof(DecimateContext, x)
71 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
72 
73 static const AVOption decimate_options[] = {
74  { "cycle", "set the number of frame from which one will be dropped", OFFSET(cycle), AV_OPT_TYPE_INT, {.i64 = 5}, 2, 25, FLAGS },
75  { "dupthresh", "set duplicate threshold", OFFSET(dupthresh_flt), AV_OPT_TYPE_DOUBLE, {.dbl = 1.1}, 0, 100, FLAGS },
76  { "scthresh", "set scene change threshold", OFFSET(scthresh_flt), AV_OPT_TYPE_DOUBLE, {.dbl = 15.0}, 0, 100, FLAGS },
77  { "blockx", "set the size of the x-axis blocks used during metric calculations", OFFSET(blockx), AV_OPT_TYPE_INT, {.i64 = 32}, 4, 1<<9, FLAGS },
78  { "blocky", "set the size of the y-axis blocks used during metric calculations", OFFSET(blocky), AV_OPT_TYPE_INT, {.i64 = 32}, 4, 1<<9, FLAGS },
79  { "ppsrc", "mark main input as a pre-processed input and activate clean source input stream", OFFSET(ppsrc), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
80  { "chroma", "set whether or not chroma is considered in the metric calculations", OFFSET(chroma), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
81  { "mixed", "set whether or not the input only partially contains content to be decimated", OFFSET(mixed), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
82  { NULL }
83 };
84 
85 AVFILTER_DEFINE_CLASS(decimate);
86 
87 static void calc_diffs(const DecimateContext *dm, struct qitem *q,
88  const AVFrame *f1, const AVFrame *f2)
89 {
90  int64_t maxdiff = -1;
91  int64_t *bdiffs = dm->bdiffs;
92  int plane, i, j;
93 
94  memset(bdiffs, 0, dm->bdiffsize * sizeof(*bdiffs));
95 
96  for (plane = 0; plane < (dm->chroma && f1->data[2] ? 3 : 1); plane++) {
97  int x, y, xl;
98  const int linesize1 = f1->linesize[plane];
99  const int linesize2 = f2->linesize[plane];
100  const uint8_t *f1p = f1->data[plane];
101  const uint8_t *f2p = f2->data[plane];
102  int width = plane ? AV_CEIL_RSHIFT(f1->width, dm->hsub) : f1->width;
103  int height = plane ? AV_CEIL_RSHIFT(f1->height, dm->vsub) : f1->height;
104  int hblockx = dm->blockx / 2;
105  int hblocky = dm->blocky / 2;
106 
107  if (plane) {
108  hblockx >>= dm->hsub;
109  hblocky >>= dm->vsub;
110  }
111 
112  for (y = 0; y < height; y++) {
113  int ydest = y / hblocky;
114  int xdest = 0;
115 
116 #define CALC_DIFF(nbits) do { \
117  for (x = 0; x < width; x += hblockx) { \
118  int64_t acc = 0; \
119  int m = FFMIN(width, x + hblockx); \
120  for (xl = x; xl < m; xl++) \
121  acc += abs(((const uint##nbits##_t *)f1p)[xl] - \
122  ((const uint##nbits##_t *)f2p)[xl]); \
123  bdiffs[ydest * dm->nxblocks + xdest] += acc; \
124  xdest++; \
125  } \
126 } while (0)
127  if (dm->depth == 8) CALC_DIFF(8);
128  else CALC_DIFF(16);
129 
130  f1p += linesize1;
131  f2p += linesize2;
132  }
133  }
134 
135  for (i = 0; i < dm->nyblocks - 1; i++) {
136  for (j = 0; j < dm->nxblocks - 1; j++) {
137  int64_t tmp = bdiffs[ i * dm->nxblocks + j ]
138  + bdiffs[ i * dm->nxblocks + j + 1]
139  + bdiffs[(i + 1) * dm->nxblocks + j ]
140  + bdiffs[(i + 1) * dm->nxblocks + j + 1];
141  if (tmp > maxdiff)
142  maxdiff = tmp;
143  }
144  }
145 
146  q->totdiff = 0;
147  for (i = 0; i < dm->bdiffsize; i++)
148  q->totdiff += bdiffs[i];
149  q->maxbdiff = maxdiff;
150 }
151 
152 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
153 {
154  int scpos = -1, duppos = -1;
155  int drop = INT_MIN, i, lowest = 0, ret;
156  AVFilterContext *ctx = inlink->dst;
157  AVFilterLink *outlink = ctx->outputs[0];
158  DecimateContext *dm = ctx->priv;
159  AVFrame *prv;
160 
161  /* update frames queue(s) */
162  if (FF_INLINK_IDX(inlink) == INPUT_MAIN) {
163  dm->queue[dm->fid].frame = in;
164  dm->got_frame[INPUT_MAIN] = 1;
165  } else {
166  dm->clean_src[dm->fid] = in;
167  dm->got_frame[INPUT_CLEANSRC] = 1;
168  }
169  if (!dm->got_frame[INPUT_MAIN] || (dm->ppsrc && !dm->got_frame[INPUT_CLEANSRC]))
170  return 0;
171  dm->got_frame[INPUT_MAIN] = dm->got_frame[INPUT_CLEANSRC] = 0;
172 
173  if (dm->ppsrc)
174  in = dm->queue[dm->fid].frame;
175 
176  if (in) {
177  /* update frame metrics */
178  prv = dm->fid ? dm->queue[dm->fid - 1].frame : dm->last;
179  if (!prv) {
180  dm->queue[dm->fid].maxbdiff = INT64_MAX;
181  dm->queue[dm->fid].totdiff = INT64_MAX;
182  } else {
183  calc_diffs(dm, &dm->queue[dm->fid], prv, in);
184  }
185  if (++dm->fid != dm->cycle)
186  return 0;
187  av_frame_free(&dm->last);
188  dm->last = av_frame_clone(in);
189  dm->fid = 0;
190 
191  /* we have a complete cycle, select the frame to drop */
192  lowest = 0;
193  for (i = 0; i < dm->cycle; i++) {
194  if (dm->queue[i].totdiff > dm->scthresh)
195  scpos = i;
196  if (dm->queue[i].maxbdiff < dm->queue[lowest].maxbdiff)
197  lowest = i;
198  }
199  if (dm->queue[lowest].maxbdiff < dm->dupthresh)
200  duppos = lowest;
201 
202  if (dm->mixed && duppos < 0) {
203  drop = -1; // no drop if mixed content + no frame in cycle below threshold
204  } else {
205  drop = scpos >= 0 && duppos < 0 ? scpos : lowest;
206  }
207  }
208 
209  /* metrics debug */
210  if (av_log_get_level() >= AV_LOG_DEBUG) {
211  av_log(ctx, AV_LOG_DEBUG, "1/%d frame drop:\n", dm->cycle);
212  for (i = 0; i < dm->cycle && dm->queue[i].frame; i++) {
213  av_log(ctx, AV_LOG_DEBUG," #%d: totdiff=%08"PRIx64" maxbdiff=%08"PRIx64"%s%s%s%s\n",
214  i + 1, dm->queue[i].totdiff, dm->queue[i].maxbdiff,
215  i == scpos ? " sc" : "",
216  i == duppos ? " dup" : "",
217  i == lowest ? " lowest" : "",
218  i == drop ? " [DROP]" : "");
219  }
220  }
221 
222  /* push all frames except the drop */
223  ret = 0;
224  for (i = 0; i < dm->cycle && dm->queue[i].frame; i++) {
225  if (i == drop) {
226  if (dm->ppsrc)
227  av_frame_free(&dm->clean_src[i]);
228  av_frame_free(&dm->queue[i].frame);
229  } else {
230  AVFrame *frame = dm->queue[i].frame;
231  dm->queue[i].frame = NULL;
232  if (frame->pts != AV_NOPTS_VALUE && dm->start_pts == AV_NOPTS_VALUE)
233  dm->start_pts = av_rescale_q(frame->pts, dm->in_tb, outlink->time_base);
234 
235  if (dm->ppsrc) {
236  av_frame_free(&frame);
237  frame = dm->clean_src[i];
238  if (!frame)
239  continue;
240  dm->clean_src[i] = NULL;
241  }
242 
243  frame->pts = dm->last_duration ? dm->last_pts + dm->last_duration :
244  (dm->start_pts == AV_NOPTS_VALUE ? 0 : dm->start_pts);
245  frame->duration = dm->mixed ? av_div_q(drop < 0 ? dm->nondec_tb : dm->dec_tb, outlink->time_base).num : 1;
246  dm->last_duration = frame->duration;
247  dm->last_pts = frame->pts;
248  ret = ff_filter_frame(outlink, frame);
249  if (ret < 0)
250  break;
251  }
252  }
253 
254  return ret;
255 }
256 
257 static int activate(AVFilterContext *ctx)
258 {
259  DecimateContext *dm = ctx->priv;
260  AVFrame *frame = NULL;
261  int ret = 0, status;
262  int64_t pts;
263 
264  FF_FILTER_FORWARD_STATUS_BACK_ALL(ctx->outputs[0], ctx);
265 
266  if ((dm->got_frame[INPUT_MAIN] == 0) && !(dm->eof & (1 << INPUT_MAIN)) &&
267  (ret = ff_inlink_consume_frame(ctx->inputs[INPUT_MAIN], &frame)) > 0) {
268  ret = filter_frame(ctx->inputs[INPUT_MAIN], frame);
269  if (ret < 0)
270  return ret;
271  }
272  if (ret < 0)
273  return ret;
274  if (dm->ppsrc &&
275  (dm->got_frame[INPUT_CLEANSRC] == 0) && !(dm->eof & (1 << INPUT_CLEANSRC)) &&
276  (ret = ff_inlink_consume_frame(ctx->inputs[INPUT_CLEANSRC], &frame)) > 0) {
277  ret = filter_frame(ctx->inputs[INPUT_CLEANSRC], frame);
278  if (ret < 0)
279  return ret;
280  }
281  if (ret < 0) {
282  return ret;
283  } else if (dm->eof == ((1 << INPUT_MAIN) | (dm->ppsrc << INPUT_CLEANSRC))) {
284  ff_outlink_set_status(ctx->outputs[0], AVERROR_EOF, dm->last_pts);
285  return 0;
286  } else if (!(dm->eof & (1 << INPUT_MAIN)) && ff_inlink_acknowledge_status(ctx->inputs[INPUT_MAIN], &status, &pts)) {
287  if (status == AVERROR_EOF) { // flushing
288  dm->eof |= 1 << INPUT_MAIN;
289  if (dm->ppsrc)
290  filter_frame(ctx->inputs[INPUT_CLEANSRC], NULL);
291  filter_frame(ctx->inputs[INPUT_MAIN], NULL);
292  ff_outlink_set_status(ctx->outputs[0], AVERROR_EOF, dm->last_pts);
293  return 0;
294  }
295  } else if (dm->ppsrc && !(dm->eof & (1 << INPUT_CLEANSRC)) && ff_inlink_acknowledge_status(ctx->inputs[INPUT_CLEANSRC], &status, &pts)) {
296  if (status == AVERROR_EOF) { // flushing
297  dm->eof |= 1 << INPUT_CLEANSRC;
298  filter_frame(ctx->inputs[INPUT_MAIN], NULL);
299  filter_frame(ctx->inputs[INPUT_CLEANSRC], NULL);
300  ff_outlink_set_status(ctx->outputs[0], AVERROR_EOF, dm->last_pts);
301  return 0;
302  }
303  }
304 
305  if (ff_inlink_queued_frames(ctx->inputs[INPUT_MAIN]) > 0 && (!dm->ppsrc ||
306  (dm->ppsrc && ff_inlink_queued_frames(ctx->inputs[INPUT_CLEANSRC]) > 0))) {
307  ff_filter_set_ready(ctx, 100);
308  } else if (ff_outlink_frame_wanted(ctx->outputs[0])) {
309  if (dm->got_frame[INPUT_MAIN] == 0)
310  ff_inlink_request_frame(ctx->inputs[INPUT_MAIN]);
311  if (dm->ppsrc && (dm->got_frame[INPUT_CLEANSRC] == 0))
312  ff_inlink_request_frame(ctx->inputs[INPUT_CLEANSRC]);
313  }
314  return 0;
315 }
316 
317 static av_cold int decimate_init(AVFilterContext *ctx)
318 {
319  DecimateContext *dm = ctx->priv;
320  AVFilterPad pad = {
321  .name = "main",
322  .type = AVMEDIA_TYPE_VIDEO,
323  };
324  int ret;
325 
326  if ((ret = ff_append_inpad(ctx, &pad)) < 0)
327  return ret;
328 
329  if (dm->ppsrc) {
330  pad.name = "clean_src";
331  pad.config_props = NULL;
332  if ((ret = ff_append_inpad(ctx, &pad)) < 0)
333  return ret;
334  }
335 
336  if ((dm->blockx & (dm->blockx - 1)) ||
337  (dm->blocky & (dm->blocky - 1))) {
338  av_log(ctx, AV_LOG_ERROR, "blockx and blocky settings must be power of two\n");
339  return AVERROR(EINVAL);
340  }
341 
342  dm->start_pts = AV_NOPTS_VALUE;
343  dm->last_duration = 0;
344 
345  return 0;
346 }
347 
348 static av_cold void decimate_uninit(AVFilterContext *ctx)
349 {
350  int i;
351  DecimateContext *dm = ctx->priv;
352 
353  av_frame_free(&dm->last);
354  av_freep(&dm->bdiffs);
355  if (dm->queue) {
356  for (i = 0; i < dm->cycle; i++)
357  av_frame_free(&dm->queue[i].frame);
358  }
359  av_freep(&dm->queue);
360  if (dm->clean_src) {
361  for (i = 0; i < dm->cycle; i++)
362  av_frame_free(&dm->clean_src[i]);
363  }
364  av_freep(&dm->clean_src);
365 }
366 
367 static const enum AVPixelFormat pix_fmts[] = {
368 #define PF_NOALPHA(suf) AV_PIX_FMT_YUV420##suf, AV_PIX_FMT_YUV422##suf, AV_PIX_FMT_YUV444##suf
369 #define PF_ALPHA(suf) AV_PIX_FMT_YUVA420##suf, AV_PIX_FMT_YUVA422##suf, AV_PIX_FMT_YUVA444##suf
370 #define PF(suf) PF_NOALPHA(suf), PF_ALPHA(suf)
371  PF(P), PF(P9), PF(P10), PF_NOALPHA(P12), PF_NOALPHA(P14), PF(P16),
372  AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
373  AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
374  AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
375  AV_PIX_FMT_YUVJ411P,
376  AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14,
377  AV_PIX_FMT_GRAY16,
378  AV_PIX_FMT_NONE
379 };
380 
381 static int config_output(AVFilterLink *outlink)
382 {
383  FilterLink *outl = ff_filter_link(outlink);
384  AVFilterContext *ctx = outlink->src;
385  DecimateContext *dm = ctx->priv;
386  const AVFilterLink *inlink = ctx->inputs[INPUT_MAIN];
387  FilterLink *inl = ff_filter_link(ctx->inputs[INPUT_MAIN]);
388  AVRational fps = inl->frame_rate;
389  int max_value;
390  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(inlink->format);
391  const int w = inlink->w;
392  const int h = inlink->h;
393 
394  dm->hsub = pix_desc->log2_chroma_w;
395  dm->vsub = pix_desc->log2_chroma_h;
396  dm->depth = pix_desc->comp[0].depth;
397  max_value = (1 << dm->depth) - 1;
398  dm->scthresh = (int64_t)(((int64_t)max_value * w * h * dm->scthresh_flt) / 100);
399  dm->dupthresh = (int64_t)(((int64_t)max_value * dm->blockx * dm->blocky * dm->dupthresh_flt) / 100);
400  dm->nxblocks = (w + dm->blockx/2 - 1) / (dm->blockx/2);
401  dm->nyblocks = (h + dm->blocky/2 - 1) / (dm->blocky/2);
402  dm->bdiffsize = dm->nxblocks * dm->nyblocks;
403  dm->bdiffs = av_malloc_array(dm->bdiffsize, sizeof(*dm->bdiffs));
404  dm->queue = av_calloc(dm->cycle, sizeof(*dm->queue));
405  dm->in_tb = inlink->time_base;
406  dm->nondec_tb = av_inv_q(fps);
407  dm->dec_tb = av_mul_q(dm->nondec_tb, (AVRational){dm->cycle, dm->cycle - 1});
408 
409  if (!dm->bdiffs || !dm->queue)
410  return AVERROR(ENOMEM);
411 
412  if (dm->ppsrc) {
413  dm->clean_src = av_calloc(dm->cycle, sizeof(*dm->clean_src));
414  if (!dm->clean_src)
415  return AVERROR(ENOMEM);
416  }
417 
418  if (!fps.num || !fps.den) {
419  av_log(ctx, AV_LOG_ERROR, "The input needs a constant frame rate; "
420  "current rate of %d/%d is invalid\n", fps.num, fps.den);
421  return AVERROR(EINVAL);
422  }
423 
424  if (dm->mixed) {
425  outlink->time_base = av_gcd_q(dm->nondec_tb, dm->dec_tb, AV_TIME_BASE / 2, AV_TIME_BASE_Q);
426  av_log(ctx, AV_LOG_VERBOSE, "FPS: %d/%d -> VFR (use %d/%d if CFR required)\n",
427  fps.num, fps.den, outlink->time_base.den, outlink->time_base.num);
428  } else {
429  outlink->time_base = dm->dec_tb;
430  outl->frame_rate = av_inv_q(outlink->time_base);
431  av_log(ctx, AV_LOG_VERBOSE, "FPS: %d/%d -> %d/%d\n",
432  fps.num, fps.den, outl->frame_rate.num, outl->frame_rate.den);
433  }
434  outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
435  if (dm->ppsrc) {
436  outlink->w = ctx->inputs[INPUT_CLEANSRC]->w;
437  outlink->h = ctx->inputs[INPUT_CLEANSRC]->h;
438  } else {
439  outlink->w = inlink->w;
440  outlink->h = inlink->h;
441  }
442  return 0;
443 }
444 
445 static const AVFilterPad decimate_outputs[] = {
446  {
447  .name = "default",
448  .type = AVMEDIA_TYPE_VIDEO,
449  .config_props = config_output,
450  },
451 };
452 
453 const AVFilter ff_vf_decimate = {
454  .name = "decimate",
455  .description = NULL_IF_CONFIG_SMALL("Decimate frames (post field matching filter)."),
456  .init = decimate_init,
457  .activate = activate,
458  .uninit = decimate_uninit,
459  .priv_size = sizeof(DecimateContext),
460  FILTER_OUTPUTS(decimate_outputs),
461  FILTER_PIXFMTS_ARRAY(pix_fmts),
462  .priv_class = &decimate_class,
463  .flags = AVFILTER_FLAG_DYNAMIC_INPUTS,
464 };
PF
#define PF(suf)
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
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
DecimateContext::start_pts
int64_t start_pts
base for output timestamps
Definition: vf_decimate.c:47
DecimateContext::in_tb
AVRational in_tb
Definition: vf_decimate.c:54
FILTER_PIXFMTS_ARRAY
#define FILTER_PIXFMTS_ARRAY(array)
Definition: filters.h:242
DecimateContext::depth
int depth
Definition: vf_decimate.c:50
DecimateContext::queue
struct qitem * queue
window of cycle frames and the associated data diff
Definition: vf_decimate.c:39
qitem
Definition: vf_decimate.c:31
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1061
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3170
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
av_div_q
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: vf_decimate.c:367
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
int64_t
long long int64_t
Definition: coverity.c:34
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:162
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
pixdesc.h
AVFrame::width
int width
Definition: frame.h:461
w
uint8_t w
Definition: llviddspenc.c:38
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
AVOption
AVOption.
Definition: opt.h:429
chroma
static av_always_inline void chroma(WaveformContext *s, AVFrame *in, AVFrame *out, int component, int intensity, int offset_y, int offset_x, int column, int mirror, int jobnr, int nb_jobs)
Definition: vf_waveform.c:1639
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
DecimateContext::vsub
int vsub
chroma subsampling values
Definition: vf_decimate.c:49
DecimateContext::scthresh_flt
double scthresh_flt
Definition: vf_decimate.c:61
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:106
DecimateContext::got_frame
int got_frame[2]
frame request flag for each input stream
Definition: vf_decimate.c:44
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:205
PF_NOALPHA
#define PF_NOALPHA(suf)
DecimateContext::hsub
int hsub
Definition: vf_decimate.c:49
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:482
DecimateContext::blocky
int blocky
Definition: vf_decimate.c:64
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:410
qitem::frame
AVFrame * frame
Definition: vf_decimate.c:32
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_decimate.c:152
ff_inlink_consume_frame
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link's FIFO and update the link's stats.
Definition: avfilter.c:1490
FF_FILTER_FORWARD_STATUS_BACK_ALL
#define FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, filter)
Forward the status on an output link to all input links.
Definition: filters.h:447
ff_append_inpad
int ff_append_inpad(AVFilterContext *f, AVFilterPad *p)
Append a new input/output pad to the filter's list of such pads.
Definition: avfilter.c:127
pts
static int64_t pts
Definition: transcode_aac.c:644
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:486
AVFILTER_FLAG_DYNAMIC_INPUTS
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
Definition: avfilter.h:141
activate
static int activate(AVFilterContext *ctx)
Definition: vf_decimate.c:257
AVRational::num
int num
Numerator.
Definition: rational.h:59
calc_diffs
static void calc_diffs(const DecimateContext *dm, struct qitem *q, const AVFrame *f1, const AVFrame *f2)
Definition: vf_decimate.c:87
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:38
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:283
DecimateContext::bdiffsize
int bdiffsize
Definition: vf_decimate.c:52
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
av_cold
#define av_cold
Definition: attributes.h:90
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:86
ff_outlink_set_status
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
Definition: filters.h:424
ff_inlink_request_frame
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
Definition: avfilter.c:1593
CALC_DIFF
#define CALC_DIFF(nbits)
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Underlying C type is double.
Definition: opt.h:267
filters.h
decimate_options
static const AVOption decimate_options[]
Definition: vf_decimate.c:73
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
ctx
AVFormatContext * ctx
Definition: movenc.c:49
AV_PIX_FMT_GRAY14
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:485
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:609
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:142
OFFSET
#define OFFSET(x)
Definition: vf_decimate.c:70
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:80
DecimateContext::nondec_tb
AVRational nondec_tb
Definition: vf_decimate.c:55
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: filters.h:263
DecimateContext::dupthresh
int64_t dupthresh
Definition: vf_decimate.c:62
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:87
DecimateContext::last_pts
int64_t last_pts
last output timestamp
Definition: vf_decimate.c:45
DecimateContext::nxblocks
int nxblocks
Definition: vf_decimate.c:51
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:483
DecimateContext::bdiffs
int64_t * bdiffs
Definition: vf_decimate.c:53
av_log_get_level
int av_log_get_level(void)
Get the current log level.
Definition: log.c:442
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
NULL
#define NULL
Definition: coverity.c:32
DecimateContext::ppsrc
int ppsrc
Definition: vf_decimate.c:65
INPUT_MAIN
#define INPUT_MAIN
Definition: vf_decimate.c:28
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
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:85
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:504
DecimateContext::eof
uint32_t eof
bitmask for end of stream
Definition: vf_decimate.c:48
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
ff_inlink_acknowledge_status
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
Test and acknowledge the change of status on the link.
Definition: avfilter.c:1437
DecimateContext::dupthresh_flt
double dupthresh_flt
Definition: vf_decimate.c:60
ff_inlink_queued_frames
size_t ff_inlink_queued_frames(AVFilterLink *link)
Get the number of frames available on the link.
Definition: avfilter.c:1453
ff_filter_link
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition: filters.h:197
AVFilterPad::config_props
int(* config_props)(AVFilterLink *link)
Link configuration callback.
Definition: filters.h:118
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:94
height
#define height
Definition: dsp.h:85
P
#define P
qitem::totdiff
int64_t totdiff
Definition: vf_decimate.c:34
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
DecimateContext::chroma
int chroma
Definition: vf_decimate.c:66
decimate_uninit
static av_cold void decimate_uninit(AVFilterContext *ctx)
Definition: vf_decimate.c:348
DecimateContext::clean_src
AVFrame ** clean_src
frame queue for the clean source
Definition: vf_decimate.c:43
INPUT_CLEANSRC
#define INPUT_CLEANSRC
Definition: vf_decimate.c:29
DecimateContext::blockx
int blockx
Definition: vf_decimate.c:64
DecimateContext::scthresh
int64_t scthresh
Definition: vf_decimate.c:63
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
FF_INLINK_IDX
#define FF_INLINK_IDX(link)
Find the index of a link.
Definition: filters.h:213
av_gcd_q
AVRational av_gcd_q(AVRational a, AVRational b, int max_den, AVRational def)
Return the best rational so that a and b are multiple of it.
Definition: rational.c:184
DecimateContext::mixed
int mixed
Definition: vf_decimate.c:67
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
decimate_init
static av_cold int decimate_init(AVFilterContext *ctx)
Definition: vf_decimate.c:317
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:107
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: filters.h:44
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
AVFilter
Filter definition.
Definition: avfilter.h:201
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
DecimateContext::dec_tb
AVRational dec_tb
Definition: vf_decimate.c:56
DecimateContext::nyblocks
int nyblocks
Definition: vf_decimate.c:51
AVFrame::height
int height
Definition: frame.h:461
status
ov_status_e status
Definition: dnn_backend_openvino.c:100
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
avfilter.h
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(decimate)
DecimateContext::fid
int fid
current frame id in the queue
Definition: vf_decimate.c:40
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
config_output
static int config_output(AVFilterLink *outlink)
Definition: vf_decimate.c:381
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AVFilterContext
An instance of a filter.
Definition: avfilter.h:457
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
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:80
DecimateContext
Definition: vf_decimate.c:37
ff_vf_decimate
const AVFilter ff_vf_decimate
Definition: vf_decimate.c:453
FLAGS
#define FLAGS
Definition: vf_decimate.c:71
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:434
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:79
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:508
h
h
Definition: vp9dsp_template.c:2070
ff_outlink_frame_wanted
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted() function. If this function returns true
width
#define width
Definition: dsp.h:85
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:484
DecimateContext::filled
int filled
1 if the queue is filled, 0 otherwise
Definition: vf_decimate.c:41
DecimateContext::last
AVFrame * last
last frame from the previous queue
Definition: vf_decimate.c:42
qitem::maxbdiff
int64_t maxbdiff
Definition: vf_decimate.c:33
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:89
DecimateContext::cycle
int cycle
Definition: vf_decimate.c:59
decimate_outputs
static const AVFilterPad decimate_outputs[]
Definition: vf_decimate.c:445
ff_filter_set_ready
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Mark a filter ready and schedule it for activation.
Definition: avfilter.c:239
DecimateContext::last_duration
int64_t last_duration
last output duration
Definition: vf_decimate.c:46
Generated on Tue Dec 3 2024 19:22:23 for FFmpeg by   doxygen 1.8.17