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/opt.h"
23 #include "libavutil/pixdesc.h"
24 #include "libavutil/timestamp.h"
25 #include "avfilter.h"
26 #include "internal.h"
27 
28 #define INPUT_MAIN 0
29 #define INPUT_CLEANSRC 1
30 
31 struct qitem {
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  AVRational ts_unit; ///< timestamp units for the output frames
46  int64_t start_pts; ///< base for output timestamps
47  uint32_t eof; ///< bitmask for end of stream
48  int hsub, vsub; ///< chroma subsampling values
49  int depth;
50  int nxblocks, nyblocks;
51  int bdiffsize;
52  int64_t *bdiffs;
53 
54  /* options */
55  int cycle;
56  double dupthresh_flt;
57  double scthresh_flt;
58  int64_t dupthresh;
59  int64_t scthresh;
60  int blockx, blocky;
61  int ppsrc;
62  int chroma;
64 
65 #define OFFSET(x) offsetof(DecimateContext, x)
66 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
67 
68 static const AVOption decimate_options[] = {
69  { "cycle", "set the number of frame from which one will be dropped", OFFSET(cycle), AV_OPT_TYPE_INT, {.i64 = 5}, 2, 25, FLAGS },
70  { "dupthresh", "set duplicate threshold", OFFSET(dupthresh_flt), AV_OPT_TYPE_DOUBLE, {.dbl = 1.1}, 0, 100, FLAGS },
71  { "scthresh", "set scene change threshold", OFFSET(scthresh_flt), AV_OPT_TYPE_DOUBLE, {.dbl = 15.0}, 0, 100, FLAGS },
72  { "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 },
73  { "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 },
74  { "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 },
75  { "chroma", "set whether or not chroma is considered in the metric calculations", OFFSET(chroma), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
76  { NULL }
77 };
78 
79 AVFILTER_DEFINE_CLASS(decimate);
80 
81 static void calc_diffs(const DecimateContext *dm, struct qitem *q,
82  const AVFrame *f1, const AVFrame *f2)
83 {
84  int64_t maxdiff = -1;
85  int64_t *bdiffs = dm->bdiffs;
86  int plane, i, j;
87 
88  memset(bdiffs, 0, dm->bdiffsize * sizeof(*bdiffs));
89 
90  for (plane = 0; plane < (dm->chroma && f1->data[2] ? 3 : 1); plane++) {
91  int x, y, xl;
92  const int linesize1 = f1->linesize[plane];
93  const int linesize2 = f2->linesize[plane];
94  const uint8_t *f1p = f1->data[plane];
95  const uint8_t *f2p = f2->data[plane];
96  int width = plane ? AV_CEIL_RSHIFT(f1->width, dm->hsub) : f1->width;
97  int height = plane ? AV_CEIL_RSHIFT(f1->height, dm->vsub) : f1->height;
98  int hblockx = dm->blockx / 2;
99  int hblocky = dm->blocky / 2;
100 
101  if (plane) {
102  hblockx >>= dm->hsub;
103  hblocky >>= dm->vsub;
104  }
105 
106  for (y = 0; y < height; y++) {
107  int ydest = y / hblocky;
108  int xdest = 0;
109 
110 #define CALC_DIFF(nbits) do { \
111  for (x = 0; x < width; x += hblockx) { \
112  int64_t acc = 0; \
113  int m = FFMIN(width, x + hblockx); \
114  for (xl = x; xl < m; xl++) \
115  acc += abs(((const uint##nbits##_t *)f1p)[xl] - \
116  ((const uint##nbits##_t *)f2p)[xl]); \
117  bdiffs[ydest * dm->nxblocks + xdest] += acc; \
118  xdest++; \
119  } \
120 } while (0)
121  if (dm->depth == 8) CALC_DIFF(8);
122  else CALC_DIFF(16);
123 
124  f1p += linesize1;
125  f2p += linesize2;
126  }
127  }
128 
129  for (i = 0; i < dm->nyblocks - 1; i++) {
130  for (j = 0; j < dm->nxblocks - 1; j++) {
131  int64_t tmp = bdiffs[ i * dm->nxblocks + j ]
132  + bdiffs[ i * dm->nxblocks + j + 1]
133  + bdiffs[(i + 1) * dm->nxblocks + j ]
134  + bdiffs[(i + 1) * dm->nxblocks + j + 1];
135  if (tmp > maxdiff)
136  maxdiff = tmp;
137  }
138  }
139 
140  q->totdiff = 0;
141  for (i = 0; i < dm->bdiffsize; i++)
142  q->totdiff += bdiffs[i];
143  q->maxbdiff = maxdiff;
144 }
145 
147 {
148  int scpos = -1, duppos = -1;
149  int drop = INT_MIN, i, lowest = 0, ret;
150  AVFilterContext *ctx = inlink->dst;
151  AVFilterLink *outlink = ctx->outputs[0];
152  DecimateContext *dm = ctx->priv;
153  AVFrame *prv;
154 
155  /* update frames queue(s) */
156  if (FF_INLINK_IDX(inlink) == INPUT_MAIN) {
157  dm->queue[dm->fid].frame = in;
158  dm->got_frame[INPUT_MAIN] = 1;
159  } else {
160  dm->clean_src[dm->fid] = in;
161  dm->got_frame[INPUT_CLEANSRC] = 1;
162  }
163  if (!dm->got_frame[INPUT_MAIN] || (dm->ppsrc && !dm->got_frame[INPUT_CLEANSRC]))
164  return 0;
166 
167  if (dm->ppsrc)
168  in = dm->clean_src[dm->fid];
169 
170  if (in) {
171  /* update frame metrics */
172  prv = dm->fid ? (dm->ppsrc ? dm->clean_src[dm->fid - 1] : dm->queue[dm->fid - 1].frame) : dm->last;
173  if (!prv) {
174  dm->queue[dm->fid].maxbdiff = INT64_MAX;
175  dm->queue[dm->fid].totdiff = INT64_MAX;
176  } else {
177  calc_diffs(dm, &dm->queue[dm->fid], prv, in);
178  }
179  if (++dm->fid != dm->cycle)
180  return 0;
181  av_frame_free(&dm->last);
182  dm->last = av_frame_clone(in);
183  dm->fid = 0;
184 
185  /* we have a complete cycle, select the frame to drop */
186  lowest = 0;
187  for (i = 0; i < dm->cycle; i++) {
188  if (dm->queue[i].totdiff > dm->scthresh)
189  scpos = i;
190  if (dm->queue[i].maxbdiff < dm->queue[lowest].maxbdiff)
191  lowest = i;
192  }
193  if (dm->queue[lowest].maxbdiff < dm->dupthresh)
194  duppos = lowest;
195  drop = scpos >= 0 && duppos < 0 ? scpos : lowest;
196  }
197 
198  /* metrics debug */
199  if (av_log_get_level() >= AV_LOG_DEBUG) {
200  av_log(ctx, AV_LOG_DEBUG, "1/%d frame drop:\n", dm->cycle);
201  for (i = 0; i < dm->cycle && dm->queue[i].frame; i++) {
202  av_log(ctx, AV_LOG_DEBUG," #%d: totdiff=%08"PRIx64" maxbdiff=%08"PRIx64"%s%s%s%s\n",
203  i + 1, dm->queue[i].totdiff, dm->queue[i].maxbdiff,
204  i == scpos ? " sc" : "",
205  i == duppos ? " dup" : "",
206  i == lowest ? " lowest" : "",
207  i == drop ? " [DROP]" : "");
208  }
209  }
210 
211  /* push all frames except the drop */
212  ret = 0;
213  for (i = 0; i < dm->cycle && dm->queue[i].frame; i++) {
214  if (i == drop) {
215  if (dm->ppsrc)
216  av_frame_free(&dm->clean_src[i]);
217  av_frame_free(&dm->queue[i].frame);
218  } else {
219  AVFrame *frame = dm->queue[i].frame;
220  if (frame->pts != AV_NOPTS_VALUE && dm->start_pts == AV_NOPTS_VALUE)
221  dm->start_pts = frame->pts;
222  if (dm->ppsrc) {
223  av_frame_free(&frame);
224  frame = dm->clean_src[i];
225  }
226  frame->pts = av_rescale_q(outlink->frame_count_in, dm->ts_unit, (AVRational){1,1}) +
227  (dm->start_pts == AV_NOPTS_VALUE ? 0 : dm->start_pts);
228  ret = ff_filter_frame(outlink, frame);
229  if (ret < 0)
230  break;
231  }
232  }
233 
234  return ret;
235 }
236 
238 {
239  int max_value;
240  AVFilterContext *ctx = inlink->dst;
241  DecimateContext *dm = ctx->priv;
242  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(inlink->format);
243  const int w = inlink->w;
244  const int h = inlink->h;
245 
246  dm->hsub = pix_desc->log2_chroma_w;
247  dm->vsub = pix_desc->log2_chroma_h;
248  dm->depth = pix_desc->comp[0].depth;
249  max_value = (1 << dm->depth) - 1;
250  dm->scthresh = (int64_t)(((int64_t)max_value * w * h * dm->scthresh_flt) / 100);
251  dm->dupthresh = (int64_t)(((int64_t)max_value * dm->blockx * dm->blocky * dm->dupthresh_flt) / 100);
252  dm->nxblocks = (w + dm->blockx/2 - 1) / (dm->blockx/2);
253  dm->nyblocks = (h + dm->blocky/2 - 1) / (dm->blocky/2);
254  dm->bdiffsize = dm->nxblocks * dm->nyblocks;
255  dm->bdiffs = av_malloc_array(dm->bdiffsize, sizeof(*dm->bdiffs));
256  dm->queue = av_calloc(dm->cycle, sizeof(*dm->queue));
257 
258  if (!dm->bdiffs || !dm->queue)
259  return AVERROR(ENOMEM);
260 
261  if (dm->ppsrc) {
262  dm->clean_src = av_calloc(dm->cycle, sizeof(*dm->clean_src));
263  if (!dm->clean_src)
264  return AVERROR(ENOMEM);
265  }
266 
267  return 0;
268 }
269 
271 {
272  DecimateContext *dm = ctx->priv;
273  AVFilterPad pad = {
274  .name = av_strdup("main"),
275  .type = AVMEDIA_TYPE_VIDEO,
276  .filter_frame = filter_frame,
277  .config_props = config_input,
278  };
279  int ret;
280 
281  if (!pad.name)
282  return AVERROR(ENOMEM);
283  if ((ret = ff_insert_inpad(ctx, INPUT_MAIN, &pad)) < 0) {
284  av_freep(&pad.name);
285  return ret;
286  }
287 
288  if (dm->ppsrc) {
289  pad.name = av_strdup("clean_src");
290  pad.config_props = NULL;
291  if (!pad.name)
292  return AVERROR(ENOMEM);
293  if ((ret = ff_insert_inpad(ctx, INPUT_CLEANSRC, &pad)) < 0) {
294  av_freep(&pad.name);
295  return ret;
296  }
297  }
298 
299  if ((dm->blockx & (dm->blockx - 1)) ||
300  (dm->blocky & (dm->blocky - 1))) {
301  av_log(ctx, AV_LOG_ERROR, "blockx and blocky settings must be power of two\n");
302  return AVERROR(EINVAL);
303  }
304 
306 
307  return 0;
308 }
309 
311 {
312  int i;
313  DecimateContext *dm = ctx->priv;
314 
315  av_frame_free(&dm->last);
316  av_freep(&dm->bdiffs);
317  av_freep(&dm->queue);
318  av_freep(&dm->clean_src);
319  for (i = 0; i < ctx->nb_inputs; i++)
320  av_freep(&ctx->input_pads[i].name);
321 }
322 
323 static int request_inlink(AVFilterContext *ctx, int lid)
324 {
325  int ret = 0;
326  DecimateContext *dm = ctx->priv;
327 
328  if (!dm->got_frame[lid]) {
329  AVFilterLink *inlink = ctx->inputs[lid];
330  ret = ff_request_frame(inlink);
331  if (ret == AVERROR_EOF) { // flushing
332  dm->eof |= 1 << lid;
333  ret = filter_frame(inlink, NULL);
334  }
335  }
336  return ret;
337 }
338 
339 static int request_frame(AVFilterLink *outlink)
340 {
341  int ret;
342  AVFilterContext *ctx = outlink->src;
343  DecimateContext *dm = ctx->priv;
344  const uint32_t eof_mask = 1<<INPUT_MAIN | dm->ppsrc<<INPUT_CLEANSRC;
345 
346  if ((dm->eof & eof_mask) == eof_mask) // flush done?
347  return AVERROR_EOF;
348  if ((ret = request_inlink(ctx, INPUT_MAIN)) < 0)
349  return ret;
350  if (dm->ppsrc && (ret = request_inlink(ctx, INPUT_CLEANSRC)) < 0)
351  return ret;
352  return 0;
353 }
354 
356 {
357  static const enum AVPixelFormat pix_fmts[] = {
358 #define PF_NOALPHA(suf) AV_PIX_FMT_YUV420##suf, AV_PIX_FMT_YUV422##suf, AV_PIX_FMT_YUV444##suf
359 #define PF_ALPHA(suf) AV_PIX_FMT_YUVA420##suf, AV_PIX_FMT_YUVA422##suf, AV_PIX_FMT_YUVA444##suf
360 #define PF(suf) PF_NOALPHA(suf), PF_ALPHA(suf)
361  PF(P), PF(P9), PF(P10), PF_NOALPHA(P12), PF_NOALPHA(P14), PF(P16),
365  };
366  AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
367  if (!fmts_list)
368  return AVERROR(ENOMEM);
369  return ff_set_common_formats(ctx, fmts_list);
370 }
371 
372 static int config_output(AVFilterLink *outlink)
373 {
374  AVFilterContext *ctx = outlink->src;
375  DecimateContext *dm = ctx->priv;
376  const AVFilterLink *inlink =
377  ctx->inputs[dm->ppsrc ? INPUT_CLEANSRC : INPUT_MAIN];
378  AVRational fps = inlink->frame_rate;
379 
380  if (!fps.num || !fps.den) {
381  av_log(ctx, AV_LOG_ERROR, "The input needs a constant frame rate; "
382  "current rate of %d/%d is invalid\n", fps.num, fps.den);
383  return AVERROR(EINVAL);
384  }
385  fps = av_mul_q(fps, (AVRational){dm->cycle - 1, dm->cycle});
386  av_log(ctx, AV_LOG_VERBOSE, "FPS: %d/%d -> %d/%d\n",
387  inlink->frame_rate.num, inlink->frame_rate.den, fps.num, fps.den);
388  outlink->time_base = inlink->time_base;
389  outlink->frame_rate = fps;
390  outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
391  outlink->w = inlink->w;
392  outlink->h = inlink->h;
393  dm->ts_unit = av_inv_q(av_mul_q(fps, outlink->time_base));
394  return 0;
395 }
396 
397 static const AVFilterPad decimate_outputs[] = {
398  {
399  .name = "default",
400  .type = AVMEDIA_TYPE_VIDEO,
401  .request_frame = request_frame,
402  .config_props = config_output,
403  },
404  { NULL }
405 };
406 
408  .name = "decimate",
409  .description = NULL_IF_CONFIG_SMALL("Decimate frames (post field matching filter)."),
410  .init = decimate_init,
411  .uninit = decimate_uninit,
412  .priv_size = sizeof(DecimateContext),
414  .outputs = decimate_outputs,
415  .priv_class = &decimate_class,
417 };
int plane
Definition: avisynth_c.h:384
static const AVFilterPad decimate_outputs[]
Definition: vf_decimate.c:397
#define NULL
Definition: coverity.c:32
#define P
uint32_t eof
bitmask for end of stream
Definition: vf_decimate.c:47
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
This structure describes decoded (raw) audio or video data.
Definition: frame.h:268
AVOption.
Definition: opt.h:246
Main libavfilter public API header.
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
Definition: avfilter.h:105
int num
Numerator.
Definition: rational.h:59
int64_t maxbdiff
Definition: vf_decimate.c:33
int64_t totdiff
Definition: vf_decimate.c:34
#define PF(suf)
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
AVFrame ** clean_src
frame queue for the clean source
Definition: vf_decimate.c:43
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
int64_t scthresh
Definition: vf_decimate.c:59
const char * name
Pad name.
Definition: internal.h:60
#define CALC_DIFF(nbits)
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:346
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1080
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
#define av_cold
Definition: attributes.h:82
AVOptions.
timestamp utils, mostly useful for debugging/logging purposes
#define OFFSET(x)
Definition: vf_decimate.c:65
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:361
int fid
current frame id in the queue
Definition: vf_decimate.c:40
AVFILTER_DEFINE_CLASS(decimate)
#define height
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
#define av_log(a,...)
A filter pad used for either input or output.
Definition: internal.h:54
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
AVFilterPad * input_pads
array of input pads
Definition: avfilter.h:345
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
int width
Definition: frame.h:326
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:568
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
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:1511
AVFilter ff_vf_decimate
Definition: vf_decimate.c:407
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
AVFrame * last
last frame from the previous queue
Definition: vf_decimate.c:42
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void * priv
private data for use by the filter
Definition: avfilter.h:353
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
AVFrame * frame
Definition: vf_decimate.c:32
int av_log_get_level(void)
Get the current log level.
Definition: log.c:380
int64_t start_pts
base for output timestamps
Definition: vf_decimate.c:46
int filled
1 if the queue is filled, 0 otherwise
Definition: vf_decimate.c:41
int(* config_props)(AVFilterLink *link)
Link configuration callback.
Definition: internal.h:129
static av_cold void decimate_uninit(AVFilterContext *ctx)
Definition: vf_decimate.c:310
unsigned nb_inputs
number of input pads
Definition: avfilter.h:347
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:371
static int config_input(AVFilterLink *inlink)
Definition: vf_decimate.c:237
#define width
uint8_t w
Definition: llviddspenc.c:38
AVFormatContext * ctx
Definition: movenc.c:48
#define PF_NOALPHA(suf)
static int request_inlink(AVFilterContext *ctx, int lid)
Definition: vf_decimate.c:323
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:540
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
if(ret)
struct qitem * queue
window of cycle frames and the associated data diff
Definition: vf_decimate.c:39
double scthresh_flt
Definition: vf_decimate.c:57
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
static const AVOption decimate_options[]
Definition: vf_decimate.c:68
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:299
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
AVRational ts_unit
timestamp units for the output frames
Definition: vf_decimate.c:45
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
Describe the class of an AVClass context structure.
Definition: log.h:67
static av_cold int decimate_init(AVFilterContext *ctx)
Definition: vf_decimate.c:270
#define FLAGS
Definition: vf_decimate.c:66
Filter definition.
Definition: avfilter.h:144
int vsub
chroma subsampling values
Definition: vf_decimate.c:48
Rational number (pair of numerator and denominator).
Definition: rational.h:58
static int request_frame(AVFilterLink *outlink)
Definition: vf_decimate.c:339
int got_frame[2]
frame request flag for each input stream
Definition: vf_decimate.c:44
const char * name
Filter name.
Definition: avfilter.h:148
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_decimate.c:146
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
#define flags(name, subs,...)
Definition: cbs_av1.c:561
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:282
#define INPUT_CLEANSRC
Definition: vf_decimate.c:29
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
#define FF_INLINK_IDX(link)
Find the index of a link.
Definition: internal.h:348
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
Y , 8bpp.
Definition: pixfmt.h:74
static void calc_diffs(const DecimateContext *dm, struct qitem *q, const AVFrame *f1, const AVFrame *f2)
Definition: vf_decimate.c:81
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
int den
Denominator.
Definition: rational.h:60
int64_t dupthresh
Definition: vf_decimate.c:58
A list of supported formats for one end of a filter link.
Definition: formats.h:64
static int config_output(AVFilterLink *outlink)
Definition: vf_decimate.c:372
An instance of a filter.
Definition: avfilter.h:338
#define INPUT_MAIN
Definition: vf_decimate.c:28
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
int height
Definition: frame.h:326
#define av_freep(p)
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
#define av_malloc_array(a, b)
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:407
internal API functions
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
int depth
Number of bits in the component.
Definition: pixdesc.h:58
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
static int query_formats(AVFilterContext *ctx)
Definition: vf_decimate.c:355
int64_t * bdiffs
Definition: vf_decimate.c:52
double dupthresh_flt
Definition: vf_decimate.c:56
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
static int ff_insert_inpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new input pad for the filter.
Definition: internal.h:277
static uint8_t tmp[11]
Definition: aes_ctr.c:26