FFmpeg
f_select.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2011 Stefano Sabatini
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * filter for selecting which frame passes in the filterchain
24  */
25 
26 #include "config_components.h"
27 
28 #include "libavutil/avstring.h"
29 #include "libavutil/eval.h"
30 #include "libavutil/fifo.h"
31 #include "libavutil/imgutils.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/pixdesc.h"
35 #include "avfilter.h"
36 #include "audio.h"
37 #include "filters.h"
38 #include "formats.h"
39 #include "video.h"
40 #include "scene_sad.h"
41 
42 static const char *const var_names[] = {
43  "TB", ///< timebase
44 
45  "pts", ///< original pts in the file of the frame
46  "start_pts", ///< first PTS in the stream, expressed in TB units
47  "prev_pts", ///< previous frame PTS
48  "prev_selected_pts", ///< previous selected frame PTS
49 
50  "t", ///< timestamp expressed in seconds
51  "start_t", ///< first PTS in the stream, expressed in seconds
52  "prev_t", ///< previous frame time
53  "prev_selected_t", ///< previously selected time
54 
55  "pict_type", ///< the type of picture in the movie
56  "I",
57  "P",
58  "B",
59  "S",
60  "SI",
61  "SP",
62  "BI",
63  "PICT_TYPE_I",
64  "PICT_TYPE_P",
65  "PICT_TYPE_B",
66  "PICT_TYPE_S",
67  "PICT_TYPE_SI",
68  "PICT_TYPE_SP",
69  "PICT_TYPE_BI",
70 
71  "interlace_type", ///< the frame interlace type
72  "PROGRESSIVE",
73  "TOPFIRST",
74  "BOTTOMFIRST",
75 
76  "consumed_samples_n",///< number of samples consumed by the filter (only audio)
77  "samples_n", ///< number of samples in the current frame (only audio)
78  "sample_rate", ///< sample rate (only audio)
79 
80  "n", ///< frame number (starting from zero)
81  "selected_n", ///< selected frame number (starting from zero)
82  "prev_selected_n", ///< number of the last selected frame
83 
84  "key", ///< tell if the frame is a key frame
85 #if FF_API_FRAME_PKT
86  "pos", ///< original position in the file of the frame
87 #endif
88 
89  "scene",
90 
91  "concatdec_select", ///< frame is within the interval set by the concat demuxer
92 
93  "ih", ///< ih: Represents the height of the input video frame.
94  "iw", ///< iw: Represents the width of the input video frame.
95 
96  "view",
97 
98  NULL
99 };
100 
101 enum var_name {
103 
108 
113 
129 
134 
138 
142 
144 #if FF_API_FRAME_PKT
145  VAR_POS,
146 #endif
147 
149 
151 
154 
156 
158 };
159 
160 typedef struct SelectContext {
161  const AVClass *class;
162  char *expr_str;
165  int bitdepth;
167  ptrdiff_t width[4];
168  ptrdiff_t height[4];
169  int do_scene_detect; ///< 1 if the expression requires scene detection variables, 0 otherwise
170  ff_scene_sad_fn sad; ///< Sum of the absolute difference function (scene detect only)
171  double prev_mafd; ///< previous MAFD (scene detect only)
172  AVFrame *prev_picref; ///< previous frame (scene detect only)
173  double select;
174  int select_out; ///< mark the selected output pad index
176 } SelectContext;
177 
178 #define OFFSET(x) offsetof(SelectContext, x)
179 #define DEFINE_OPTIONS(filt_name, FLAGS) \
180 static const AVOption filt_name##_options[] = { \
181  { "expr", "set an expression to use for selecting frames", OFFSET(expr_str), AV_OPT_TYPE_STRING, { .str = "1" }, .flags=FLAGS }, \
182  { "e", "set an expression to use for selecting frames", OFFSET(expr_str), AV_OPT_TYPE_STRING, { .str = "1" }, .flags=FLAGS }, \
183  { "outputs", "set the number of outputs", OFFSET(nb_outputs), AV_OPT_TYPE_INT, {.i64 = 1}, 1, INT_MAX, .flags=FLAGS }, \
184  { "n", "set the number of outputs", OFFSET(nb_outputs), AV_OPT_TYPE_INT, {.i64 = 1}, 1, INT_MAX, .flags=FLAGS }, \
185  { NULL } \
186 }
187 
188 static int request_frame(AVFilterLink *outlink);
189 
191 {
192  SelectContext *select = ctx->priv;
193  int i, ret;
194 
195  if ((ret = av_expr_parse(&select->expr, select->expr_str,
196  var_names, NULL, NULL, NULL, NULL, 0, ctx)) < 0) {
197  av_log(ctx, AV_LOG_ERROR, "Error while parsing expression '%s'\n",
198  select->expr_str);
199  return ret;
200  }
201  select->do_scene_detect = !!strstr(select->expr_str, "scene");
202 
203  for (i = 0; i < select->nb_outputs; i++) {
204  AVFilterPad pad = { 0 };
205 
206  pad.name = av_asprintf("output%d", i);
207  if (!pad.name)
208  return AVERROR(ENOMEM);
209  pad.type = ctx->filter->inputs[0].type;
211  if ((ret = ff_append_outpad_free_name(ctx, &pad)) < 0)
212  return ret;
213  }
214 
215  return 0;
216 }
217 
218 #define INTERLACE_TYPE_P 0
219 #define INTERLACE_TYPE_T 1
220 #define INTERLACE_TYPE_B 2
221 
223 {
224  SelectContext *select = inlink->dst->priv;
226  int is_yuv = !(desc->flags & AV_PIX_FMT_FLAG_RGB) &&
227  (desc->flags & AV_PIX_FMT_FLAG_PLANAR) &&
228  desc->nb_components >= 3;
229 
230  select->bitdepth = desc->comp[0].depth;
231  select->nb_planes = is_yuv ? 1 : av_pix_fmt_count_planes(inlink->format);
232 
233  for (int plane = 0; plane < select->nb_planes; plane++) {
234  ptrdiff_t line_size = av_image_get_linesize(inlink->format, inlink->w, plane);
235  int vsub = desc->log2_chroma_h;
236 
237  select->width[plane] = line_size >> (select->bitdepth > 8);
238  select->height[plane] = plane == 1 || plane == 2 ? AV_CEIL_RSHIFT(inlink->h, vsub) : inlink->h;
239  }
240 
241  select->var_values[VAR_N] = 0.0;
242  select->var_values[VAR_SELECTED_N] = 0.0;
243 
244  select->var_values[VAR_TB] = av_q2d(inlink->time_base);
245 
247  select->var_values[VAR_PREV_PTS] = NAN;
250  select->var_values[VAR_PREV_T] = NAN;
251  select->var_values[VAR_START_PTS] = NAN;
252  select->var_values[VAR_START_T] = NAN;
253 
266 
270 
271  select->var_values[VAR_PICT_TYPE] = NAN;
272  select->var_values[VAR_INTERLACE_TYPE] = NAN;
273  select->var_values[VAR_SCENE] = NAN;
275  select->var_values[VAR_SAMPLES_N] = NAN;
276 
277  select->var_values[VAR_IH] = NAN;
278  select->var_values[VAR_IW] = NAN;
279 
280  select->var_values[VAR_SAMPLE_RATE] =
281  inlink->type == AVMEDIA_TYPE_AUDIO ? inlink->sample_rate : NAN;
282 
283  if (CONFIG_SELECT_FILTER && select->do_scene_detect) {
284  select->sad = ff_scene_sad_get_fn(select->bitdepth == 8 ? 8 : 16);
285  if (!select->sad)
286  return AVERROR(EINVAL);
287  }
288  return 0;
289 }
290 
292 {
293  double ret = 0;
294  SelectContext *select = ctx->priv;
295  AVFrame *prev_picref = select->prev_picref;
296 
297  if (prev_picref &&
298  frame->height == prev_picref->height &&
299  frame->width == prev_picref->width) {
300  uint64_t sad = 0;
301  double mafd, diff;
302  uint64_t count = 0;
303 
304  for (int plane = 0; plane < select->nb_planes; plane++) {
305  uint64_t plane_sad;
306  select->sad(prev_picref->data[plane], prev_picref->linesize[plane],
307  frame->data[plane], frame->linesize[plane],
308  select->width[plane], select->height[plane], &plane_sad);
309  sad += plane_sad;
310  count += select->width[plane] * select->height[plane];
311  }
312 
313  mafd = (double)sad / count / (1ULL << (select->bitdepth - 8));
314  diff = fabs(mafd - select->prev_mafd);
315  ret = av_clipf(FFMIN(mafd, diff) / 100., 0, 1);
316  select->prev_mafd = mafd;
317  av_frame_free(&prev_picref);
318  }
319  select->prev_picref = av_frame_clone(frame);
320  return ret;
321 }
322 
324 {
325  AVDictionary *metadata = frame->metadata;
326  AVDictionaryEntry *start_time_entry = av_dict_get(metadata, "lavf.concatdec.start_time", NULL, 0);
327  AVDictionaryEntry *duration_entry = av_dict_get(metadata, "lavf.concatdec.duration", NULL, 0);
328  if (start_time_entry) {
329  int64_t start_time = strtoll(start_time_entry->value, NULL, 10);
330  if (pts >= start_time) {
331  if (duration_entry) {
332  int64_t duration = strtoll(duration_entry->value, NULL, 10);
333  if (pts < start_time + duration)
334  return -1;
335  else
336  return 0;
337  }
338  return -1;
339  }
340  return 0;
341  }
342  return NAN;
343 }
344 
346 {
347  SelectContext *select = ctx->priv;
348  AVFilterLink *inlink = ctx->inputs[0];
350  const AVFrameSideData *sd;
351  double res;
352 
353  if (isnan(select->var_values[VAR_START_PTS]))
354  select->var_values[VAR_START_PTS] = TS2D(frame->pts);
355  if (isnan(select->var_values[VAR_START_T]))
356  select->var_values[VAR_START_T] = TS2D(frame->pts) * av_q2d(inlink->time_base);
357 
358  select->var_values[VAR_N ] = inl->frame_count_out;
359  select->var_values[VAR_PTS] = TS2D(frame->pts);
360  select->var_values[VAR_T ] = TS2D(frame->pts) * av_q2d(inlink->time_base);
361 #if FF_API_FRAME_PKT
363  select->var_values[VAR_POS] = frame->pkt_pos == -1 ? NAN : frame->pkt_pos;
365 #endif
366  select->var_values[VAR_KEY] = !!(frame->flags & AV_FRAME_FLAG_KEY);
368 
369  switch (inlink->type) {
370  case AVMEDIA_TYPE_AUDIO:
371  select->var_values[VAR_SAMPLES_N] = frame->nb_samples;
372  break;
373 
374  case AVMEDIA_TYPE_VIDEO:
375  select->var_values[VAR_IH] = frame->height;
376  select->var_values[VAR_IW] = frame->width;
377 
378  select->var_values[VAR_INTERLACE_TYPE] =
381  select->var_values[VAR_PICT_TYPE] = frame->pict_type;
382  if (select->do_scene_detect) {
383  char buf[32];
385  // TODO: document metadata
386  snprintf(buf, sizeof(buf), "%f", select->var_values[VAR_SCENE]);
387  av_dict_set(&frame->metadata, "lavfi.scene_score", buf, 0);
388  }
389 
390  sd = av_frame_side_data_get(frame->side_data, frame->nb_side_data,
392  select->var_values[VAR_VIEW] = sd ? *(int*)sd->data : NAN;
393  break;
394  }
395 
396  select->select = res = av_expr_eval(select->expr, select->var_values, NULL);
397  av_log(inlink->dst, AV_LOG_DEBUG,
398  "n:%f pts:%f t:%f key:%d",
399  select->var_values[VAR_N],
400  select->var_values[VAR_PTS],
401  select->var_values[VAR_T],
402  !!(frame->flags & AV_FRAME_FLAG_KEY));
403 
404  switch (inlink->type) {
405  case AVMEDIA_TYPE_VIDEO:
406  av_log(inlink->dst, AV_LOG_DEBUG, " interlace_type:%c pict_type:%c scene:%f",
407  !(frame->flags & AV_FRAME_FLAG_INTERLACED) ? 'P' :
408  (frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) ? 'T' : 'B',
409  av_get_picture_type_char(frame->pict_type),
410  select->var_values[VAR_SCENE]);
411  break;
412  case AVMEDIA_TYPE_AUDIO:
413  av_log(inlink->dst, AV_LOG_DEBUG, " samples_n:%d consumed_samples_n:%f",
414  frame->nb_samples,
416  break;
417  }
418 
419  if (res == 0) {
420  select->select_out = -1; /* drop */
421  } else if (isnan(res) || res < 0) {
422  select->select_out = 0; /* first output */
423  } else {
424  select->select_out = FFMIN(ceilf(res)-1, select->nb_outputs-1); /* other outputs */
425  }
426 
427  av_log(inlink->dst, AV_LOG_DEBUG, " -> select:%f select_out:%d\n", res, select->select_out);
428 
429  if (res) {
430  select->var_values[VAR_PREV_SELECTED_N] = select->var_values[VAR_N];
432  select->var_values[VAR_PREV_SELECTED_T] = select->var_values[VAR_T];
433  select->var_values[VAR_SELECTED_N] += 1.0;
434  if (inlink->type == AVMEDIA_TYPE_AUDIO)
435  select->var_values[VAR_CONSUMED_SAMPLES_N] += frame->nb_samples;
436  }
437 
438  select->var_values[VAR_PREV_PTS] = select->var_values[VAR_PTS];
439  select->var_values[VAR_PREV_T] = select->var_values[VAR_T];
440 }
441 
443 {
444  AVFilterContext *ctx = inlink->dst;
445  SelectContext *select = ctx->priv;
446 
448  if (select->select)
449  return ff_filter_frame(ctx->outputs[select->select_out], frame);
450 
452  return 0;
453 }
454 
455 static int request_frame(AVFilterLink *outlink)
456 {
457  AVFilterLink *inlink = outlink->src->inputs[0];
458  int ret = ff_request_frame(inlink);
459  return ret;
460 }
461 
463 {
464  SelectContext *select = ctx->priv;
465 
466  av_expr_free(select->expr);
467  select->expr = NULL;
468 
469  if (select->do_scene_detect) {
470  av_frame_free(&select->prev_picref);
471  }
472 }
473 
474 #if CONFIG_ASELECT_FILTER
475 
477 AVFILTER_DEFINE_CLASS(aselect);
478 
479 static av_cold int aselect_init(AVFilterContext *ctx)
480 {
481  SelectContext *select = ctx->priv;
482  int ret;
483 
484  if ((ret = init(ctx)) < 0)
485  return ret;
486 
487  if (select->do_scene_detect) {
488  av_log(ctx, AV_LOG_ERROR, "Scene detection is ignored in aselect filter\n");
489  return AVERROR(EINVAL);
490  }
491 
492  return 0;
493 }
494 
495 static const AVFilterPad avfilter_af_aselect_inputs[] = {
496  {
497  .name = "default",
498  .type = AVMEDIA_TYPE_AUDIO,
499  .config_props = config_input,
500  .filter_frame = filter_frame,
501  },
502 };
503 
504 const AVFilter ff_af_aselect = {
505  .name = "aselect",
506  .description = NULL_IF_CONFIG_SMALL("Select audio frames to pass in output."),
507  .init = aselect_init,
508  .uninit = uninit,
509  .priv_size = sizeof(SelectContext),
510  FILTER_INPUTS(avfilter_af_aselect_inputs),
511  .priv_class = &aselect_class,
513 };
514 #endif /* CONFIG_ASELECT_FILTER */
515 
516 #if CONFIG_SELECT_FILTER
517 
518 static int query_formats(const AVFilterContext *ctx,
519  AVFilterFormatsConfig **cfg_in,
520  AVFilterFormatsConfig **cfg_out)
521 {
522  const SelectContext *select = ctx->priv;
523 
524  if (select->do_scene_detect) {
525  static const enum AVPixelFormat pix_fmts[] = {
532  };
533  return ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
534  }
535  return 0;
536 }
537 
539 AVFILTER_DEFINE_CLASS(select);
540 
541 static av_cold int select_init(AVFilterContext *ctx)
542 {
543  int ret;
544 
545  if ((ret = init(ctx)) < 0)
546  return ret;
547 
548  return 0;
549 }
550 
551 static const AVFilterPad avfilter_vf_select_inputs[] = {
552  {
553  .name = "default",
554  .type = AVMEDIA_TYPE_VIDEO,
555  .config_props = config_input,
556  .filter_frame = filter_frame,
557  },
558 };
559 
560 const AVFilter ff_vf_select = {
561  .name = "select",
562  .description = NULL_IF_CONFIG_SMALL("Select video frames to pass in output."),
563  .init = select_init,
564  .uninit = uninit,
565  .priv_size = sizeof(SelectContext),
566  .priv_class = &select_class,
567  FILTER_INPUTS(avfilter_vf_select_inputs),
570 };
571 #endif /* CONFIG_SELECT_FILTER */
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
VAR_PICT_TYPE_S
@ VAR_PICT_TYPE_S
Definition: f_select.c:125
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
VAR_INTERLACE_TYPE_P
@ VAR_INTERLACE_TYPE_P
Definition: f_select.c:131
var_name
var_name
Definition: noise.c:47
VAR_P
@ VAR_P
Definition: f_select.c:116
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
request_frame
static int request_frame(AVFilterLink *outlink)
Definition: f_select.c:455
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
SelectContext
Definition: f_select.c:160
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_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:115
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
VAR_PREV_T
@ VAR_PREV_T
Definition: f_select.c:111
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: filters.h:262
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
get_concatdec_select
static double get_concatdec_select(AVFrame *frame, int64_t pts)
Definition: f_select.c:323
pixdesc.h
AVFrame::width
int width
Definition: frame.h:461
VAR_INTERLACE_TYPE_B
@ VAR_INTERLACE_TYPE_B
Definition: f_select.c:133
VAR_T
@ VAR_T
Definition: f_select.c:109
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: f_select.c:462
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:502
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:475
VAR_START_T
@ VAR_START_T
Definition: f_select.c:110
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:76
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
AVDictionary
Definition: dict.c:34
VAR_SAMPLE_RATE
@ VAR_SAMPLE_RATE
Definition: f_select.c:137
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:205
SelectContext::sad
ff_scene_sad_fn sad
Sum of the absolute difference function (scene detect only)
Definition: f_select.c:170
video.h
VAR_SCENE
@ VAR_SCENE
Definition: f_select.c:148
VAR_CONSUMED_SAMPLES_N
@ VAR_CONSUMED_SAMPLES_N
Definition: f_select.c:135
ceilf
static __device__ float ceilf(float a)
Definition: cuda_runtime.h:175
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:410
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:653
formats.h
av_expr_parse
int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)
Parse an expression.
Definition: eval.c:710
VAR_PREV_SELECTED_N
@ VAR_PREV_SELECTED_N
Definition: f_select.c:141
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3210
fifo.h
VAR_SAMPLES_N
@ VAR_SAMPLES_N
Definition: f_select.c:136
VAR_START_PTS
@ VAR_START_PTS
Definition: f_select.c:105
VAR_PICT_TYPE_P
@ VAR_PICT_TYPE_P
Definition: f_select.c:123
pts
static int64_t pts
Definition: transcode_aac.c:644
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:358
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:38
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:357
VAR_BI
@ VAR_BI
Definition: f_select.c:121
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
SelectContext::width
ptrdiff_t width[4]
Definition: f_select.c:167
AVFilterPad::request_frame
int(* request_frame)(AVFilterLink *link)
Frame request callback.
Definition: filters.h:102
av_cold
#define av_cold
Definition: attributes.h:90
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:640
duration
int64_t duration
Definition: movenc.c:65
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:62
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
get_scene_score
static double get_scene_score(AVFilterContext *ctx, AVFrame *frame)
Definition: f_select.c:291
INTERLACE_TYPE_T
#define INTERLACE_TYPE_T
Definition: f_select.c:219
VAR_SI
@ VAR_SI
Definition: f_select.c:119
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
VAR_PREV_SELECTED_PTS
@ VAR_PREV_SELECTED_PTS
Definition: f_select.c:107
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
VAR_PICT_TYPE
@ VAR_PICT_TYPE
Definition: f_select.c:114
filters.h
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:304
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_expr_eval
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:792
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
AVExpr
Definition: eval.c:158
SelectContext::select_out
int select_out
mark the selected output pad index
Definition: f_select.c:174
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:73
VAR_IW
@ VAR_IW
Definition: f_select.c:153
VAR_PREV_SELECTED_T
@ VAR_PREV_SELECTED_T
Definition: f_select.c:112
NAN
#define NAN
Definition: mathematics.h:115
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
INTERLACE_TYPE_B
#define INTERLACE_TYPE_B
Definition: f_select.c:220
ff_scene_sad_get_fn
ff_scene_sad_fn ff_scene_sad_get_fn(int depth)
Definition: scene_sad.c:59
VAR_N
@ VAR_N
Definition: f_select.c:139
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
NULL
#define NULL
Definition: coverity.c:32
VAR_POS
@ VAR_POS
Definition: noise.c:56
ff_af_aselect
const AVFilter ff_af_aselect
isnan
#define isnan(x)
Definition: libm.h:340
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
AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:465
AV_PICTURE_TYPE_SI
@ AV_PICTURE_TYPE_SI
Switching Intra.
Definition: avutil.h:283
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
SelectContext::select
double select
Definition: f_select.c:173
VAR_VIEW
@ VAR_VIEW
Definition: f_select.c:155
SelectContext::prev_picref
AVFrame * prev_picref
previous frame (scene detect only)
Definition: f_select.c:172
DEFINE_OPTIONS
#define DEFINE_OPTIONS(filt_name, FLAGS)
Definition: f_select.c:179
double
double
Definition: af_crystalizer.c:132
av_clipf
av_clipf
Definition: af_crystalizer.c:122
init
static av_cold int init(AVFilterContext *ctx)
Definition: f_select.c:190
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
AVFILTER_DEFINE_CLASS
#define AVFILTER_DEFINE_CLASS(fname)
Definition: filters.h:273
AV_PICTURE_TYPE_SP
@ AV_PICTURE_TYPE_SP
Switching Predicted.
Definition: avutil.h:284
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:101
SelectContext::prev_mafd
double prev_mafd
previous MAFD (scene detect only)
Definition: f_select.c:171
AVFilterFormatsConfig
Lists of formats / etc.
Definition: avfilter.h:111
SelectContext::do_scene_detect
int do_scene_detect
1 if the expression requires scene detection variables, 0 otherwise
Definition: f_select.c:169
scene_sad.h
ff_filter_link
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition: filters.h:197
TS2D
#define TS2D(ts)
Definition: filters.h:277
AVFILTER_FLAG_DYNAMIC_OUTPUTS
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
Definition: avfilter.h:147
config_input
static int config_input(AVFilterLink *inlink)
Definition: f_select.c:222
eval.h
AV_OPT_FLAG_FILTERING_PARAM
#define AV_OPT_FLAG_FILTERING_PARAM
A generic parameter which can be set by the user for filtering.
Definition: opt.h:381
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
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
AV_PIX_FMT_FLAG_RGB
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:136
start_time
static int64_t start_time
Definition: ffplay.c:326
VAR_INTERLACE_TYPE
@ VAR_INTERLACE_TYPE
Definition: f_select.c:130
VAR_VARS_NB
@ VAR_VARS_NB
Definition: f_select.c:157
AVFrameSideData::data
uint8_t * data
Definition: frame.h:267
ff_scene_sad_fn
void(* ff_scene_sad_fn)(SCENE_SAD_PARAMS)
Definition: scene_sad.h:34
var_names
static const char *const var_names[]
Definition: f_select.c:42
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:166
SelectContext::expr
AVExpr * expr
Definition: f_select.c:163
VAR_IH
@ VAR_IH
Definition: f_select.c:152
AV_FRAME_DATA_VIEW_ID
@ AV_FRAME_DATA_VIEW_ID
This side data must be associated with a video frame.
Definition: frame.h:245
av_image_get_linesize
int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane)
Compute the size of an image line with format pix_fmt and width width for the plane plane.
Definition: imgutils.c:76
av_get_picture_type_char
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:40
VAR_TB
@ VAR_TB
Definition: f_select.c:102
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
SelectContext::expr_str
char * expr_str
Definition: f_select.c:162
internal.h
FILTER_QUERY_FUNC2
#define FILTER_QUERY_FUNC2(func)
Definition: filters.h:239
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
Definition: f_select.c:442
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_OPT_FLAG_VIDEO_PARAM
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:358
SelectContext::nb_planes
int nb_planes
Definition: f_select.c:166
VAR_PICT_TYPE_SI
@ VAR_PICT_TYPE_SI
Definition: f_select.c:126
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:44
SelectContext::bitdepth
int bitdepth
Definition: f_select.c:165
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:648
select_frame
static void select_frame(AVFilterContext *ctx, AVFrame *frame)
Definition: f_select.c:345
VAR_B
@ VAR_B
Definition: f_select.c:117
AVFilter
Filter definition.
Definition: avfilter.h:201
VAR_PICT_TYPE_BI
@ VAR_PICT_TYPE_BI
Definition: f_select.c:128
ret
ret
Definition: filter_design.txt:187
AVFilterPad::type
enum AVMediaType type
AVFilterPad type.
Definition: filters.h:49
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
VAR_KEY
@ VAR_KEY
Definition: f_select.c:143
VAR_SELECTED_N
@ VAR_SELECTED_N
Definition: f_select.c:140
SelectContext::var_values
double var_values[VAR_VARS_NB]
Definition: f_select.c:164
SelectContext::nb_outputs
int nb_outputs
Definition: f_select.c:175
AVFrame::height
int height
Definition: frame.h:461
VAR_S
@ VAR_S
Definition: f_select.c:118
ff_set_common_formats_from_list2
int ff_set_common_formats_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const int *fmts)
Definition: formats.c:1016
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
VAR_PICT_TYPE_I
@ VAR_PICT_TYPE_I
Definition: f_select.c:122
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
VAR_PREV_PTS
@ VAR_PREV_PTS
Definition: f_select.c:106
avfilter.h
VAR_SP
@ VAR_SP
Definition: f_select.c:120
AVFILTER_FLAG_METADATA_ONLY
#define AVFILTER_FLAG_METADATA_ONLY
The filter is a "metadata" filter - it does not modify the frame data in any way.
Definition: avfilter.h:168
AV_PIX_FMT_FLAG_PLANAR
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:132
VAR_PICT_TYPE_SP
@ VAR_PICT_TYPE_SP
Definition: f_select.c:127
AVFilterContext
An instance of a filter.
Definition: avfilter.h:457
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
desc
const char * desc
Definition: libsvtav1.c:79
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
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:77
audio.h
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:265
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AVDictionaryEntry
Definition: dict.h:89
VAR_PTS
@ VAR_PTS
Definition: f_select.c:104
ff_append_outpad_free_name
int ff_append_outpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:143
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:88
AV_PICTURE_TYPE_BI
@ AV_PICTURE_TYPE_BI
BI type.
Definition: avutil.h:285
av_frame_side_data_get
static const AVFrameSideData * av_frame_side_data_get(AVFrameSideData *const *sd, const int nb_sd, enum AVFrameSideDataType type)
Wrapper around av_frame_side_data_get_c() to workaround the limitation that for any type T the conver...
Definition: frame.h:1159
SelectContext::height
ptrdiff_t height[4]
Definition: f_select.c:168
imgutils.h
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_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVDictionaryEntry::value
char * value
Definition: dict.h:91
avstring.h
VAR_PICT_TYPE_B
@ VAR_PICT_TYPE_B
Definition: f_select.c:124
VAR_INTERLACE_TYPE_T
@ VAR_INTERLACE_TYPE_T
Definition: f_select.c:132
ff_vf_select
const AVFilter ff_vf_select
snprintf
#define snprintf
Definition: snprintf.h:34
query_formats
static int query_formats(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition: aeval.c:245
VAR_I
@ VAR_I
Definition: f_select.c:115
VAR_CONCATDEC_SELECT
@ VAR_CONCATDEC_SELECT
Definition: f_select.c:150
INTERLACE_TYPE_P
#define INTERLACE_TYPE_P
Definition: f_select.c:218