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 "libavutil/avstring.h"
27 #include "libavutil/eval.h"
28 #include "libavutil/fifo.h"
29 #include "libavutil/imgutils.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/pixdesc.h"
33 #include "avfilter.h"
34 #include "audio.h"
35 #include "formats.h"
36 #include "internal.h"
37 #include "video.h"
38 #include "scene_sad.h"
39 
40 static const char *const var_names[] = {
41  "TB", ///< timebase
42 
43  "pts", ///< original pts in the file of the frame
44  "start_pts", ///< first PTS in the stream, expressed in TB units
45  "prev_pts", ///< previous frame PTS
46  "prev_selected_pts", ///< previous selected frame PTS
47 
48  "t", ///< timestamp expressed in seconds
49  "start_t", ///< first PTS in the stream, expressed in seconds
50  "prev_t", ///< previous frame time
51  "prev_selected_t", ///< previously selected time
52 
53  "pict_type", ///< the type of picture in the movie
54  "I",
55  "P",
56  "B",
57  "S",
58  "SI",
59  "SP",
60  "BI",
61  "PICT_TYPE_I",
62  "PICT_TYPE_P",
63  "PICT_TYPE_B",
64  "PICT_TYPE_S",
65  "PICT_TYPE_SI",
66  "PICT_TYPE_SP",
67  "PICT_TYPE_BI",
68 
69  "interlace_type", ///< the frame interlace type
70  "PROGRESSIVE",
71  "TOPFIRST",
72  "BOTTOMFIRST",
73 
74  "consumed_samples_n",///< number of samples consumed by the filter (only audio)
75  "samples_n", ///< number of samples in the current frame (only audio)
76  "sample_rate", ///< sample rate (only audio)
77 
78  "n", ///< frame number (starting from zero)
79  "selected_n", ///< selected frame number (starting from zero)
80  "prev_selected_n", ///< number of the last selected frame
81 
82  "key", ///< tell if the frame is a key frame
83  "pos", ///< original position in the file of the frame
84 
85  "scene",
86 
87  "concatdec_select", ///< frame is within the interval set by the concat demuxer
88 
89  NULL
90 };
91 
92 enum var_name {
94 
99 
104 
120 
125 
129 
133 
136 
138 
140 
142 };
143 
144 typedef struct SelectContext {
145  const AVClass *class;
146  char *expr_str;
149  int bitdepth;
151  ptrdiff_t width[4];
152  ptrdiff_t height[4];
153  int do_scene_detect; ///< 1 if the expression requires scene detection variables, 0 otherwise
154  ff_scene_sad_fn sad; ///< Sum of the absolute difference function (scene detect only)
155  double prev_mafd; ///< previous MAFD (scene detect only)
156  AVFrame *prev_picref; ///< previous frame (scene detect only)
157  double select;
158  int select_out; ///< mark the selected output pad index
160 } SelectContext;
161 
162 #define OFFSET(x) offsetof(SelectContext, x)
163 #define DEFINE_OPTIONS(filt_name, FLAGS) \
164 static const AVOption filt_name##_options[] = { \
165  { "expr", "set an expression to use for selecting frames", OFFSET(expr_str), AV_OPT_TYPE_STRING, { .str = "1" }, .flags=FLAGS }, \
166  { "e", "set an expression to use for selecting frames", OFFSET(expr_str), AV_OPT_TYPE_STRING, { .str = "1" }, .flags=FLAGS }, \
167  { "outputs", "set the number of outputs", OFFSET(nb_outputs), AV_OPT_TYPE_INT, {.i64 = 1}, 1, INT_MAX, .flags=FLAGS }, \
168  { "n", "set the number of outputs", OFFSET(nb_outputs), AV_OPT_TYPE_INT, {.i64 = 1}, 1, INT_MAX, .flags=FLAGS }, \
169  { NULL } \
170 }
171 
172 static int request_frame(AVFilterLink *outlink);
173 
175 {
176  SelectContext *select = ctx->priv;
177  int i, ret;
178 
179  if ((ret = av_expr_parse(&select->expr, select->expr_str,
180  var_names, NULL, NULL, NULL, NULL, 0, ctx)) < 0) {
181  av_log(ctx, AV_LOG_ERROR, "Error while parsing expression '%s'\n",
182  select->expr_str);
183  return ret;
184  }
185  select->do_scene_detect = !!strstr(select->expr_str, "scene");
186 
187  for (i = 0; i < select->nb_outputs; i++) {
188  AVFilterPad pad = { 0 };
189 
190  pad.name = av_asprintf("output%d", i);
191  if (!pad.name)
192  return AVERROR(ENOMEM);
193  pad.type = ctx->filter->inputs[0].type;
195  if ((ret = ff_insert_outpad(ctx, i, &pad)) < 0) {
196  av_freep(&pad.name);
197  return ret;
198  }
199  }
200 
201  return 0;
202 }
203 
204 #define INTERLACE_TYPE_P 0
205 #define INTERLACE_TYPE_T 1
206 #define INTERLACE_TYPE_B 2
207 
209 {
210  SelectContext *select = inlink->dst->priv;
212  int is_yuv = !(desc->flags & AV_PIX_FMT_FLAG_RGB) &&
213  (desc->flags & AV_PIX_FMT_FLAG_PLANAR) &&
214  desc->nb_components >= 3;
215 
216  select->bitdepth = desc->comp[0].depth;
217  select->nb_planes = is_yuv ? 1 : av_pix_fmt_count_planes(inlink->format);
218 
219  for (int plane = 0; plane < select->nb_planes; plane++) {
220  ptrdiff_t line_size = av_image_get_linesize(inlink->format, inlink->w, plane);
221  int vsub = desc->log2_chroma_h;
222 
223  select->width[plane] = line_size >> (select->bitdepth > 8);
224  select->height[plane] = plane == 1 || plane == 2 ? AV_CEIL_RSHIFT(inlink->h, vsub) : inlink->h;
225  }
226 
227  select->var_values[VAR_N] = 0.0;
228  select->var_values[VAR_SELECTED_N] = 0.0;
229 
230  select->var_values[VAR_TB] = av_q2d(inlink->time_base);
231 
232  select->var_values[VAR_PREV_PTS] = NAN;
235  select->var_values[VAR_PREV_T] = NAN;
236  select->var_values[VAR_START_PTS] = NAN;
237  select->var_values[VAR_START_T] = NAN;
238 
251 
255 
256  select->var_values[VAR_PICT_TYPE] = NAN;
257  select->var_values[VAR_INTERLACE_TYPE] = NAN;
258  select->var_values[VAR_SCENE] = NAN;
260  select->var_values[VAR_SAMPLES_N] = NAN;
261 
262  select->var_values[VAR_SAMPLE_RATE] =
263  inlink->type == AVMEDIA_TYPE_AUDIO ? inlink->sample_rate : NAN;
264 
265  if (CONFIG_SELECT_FILTER && select->do_scene_detect) {
266  select->sad = ff_scene_sad_get_fn(select->bitdepth == 8 ? 8 : 16);
267  if (!select->sad)
268  return AVERROR(EINVAL);
269  }
270  return 0;
271 }
272 
274 {
275  double ret = 0;
276  SelectContext *select = ctx->priv;
277  AVFrame *prev_picref = select->prev_picref;
278 
279  if (prev_picref &&
280  frame->height == prev_picref->height &&
281  frame->width == prev_picref->width) {
282  uint64_t sad = 0;
283  double mafd, diff;
284  uint64_t count = 0;
285 
286  for (int plane = 0; plane < select->nb_planes; plane++) {
287  uint64_t plane_sad;
288  select->sad(prev_picref->data[plane], prev_picref->linesize[plane],
289  frame->data[plane], frame->linesize[plane],
290  select->width[plane], select->height[plane], &plane_sad);
291  sad += plane_sad;
292  count += select->width[plane] * select->height[plane];
293  }
294 
295  emms_c();
296  mafd = (double)sad / count / (1ULL << (select->bitdepth - 8));
297  diff = fabs(mafd - select->prev_mafd);
298  ret = av_clipf(FFMIN(mafd, diff) / 100., 0, 1);
299  select->prev_mafd = mafd;
300  av_frame_free(&prev_picref);
301  }
302  select->prev_picref = av_frame_clone(frame);
303  return ret;
304 }
305 
306 static double get_concatdec_select(AVFrame *frame, int64_t pts)
307 {
308  AVDictionary *metadata = frame->metadata;
309  AVDictionaryEntry *start_time_entry = av_dict_get(metadata, "lavf.concatdec.start_time", NULL, 0);
310  AVDictionaryEntry *duration_entry = av_dict_get(metadata, "lavf.concatdec.duration", NULL, 0);
311  if (start_time_entry) {
312  int64_t start_time = strtoll(start_time_entry->value, NULL, 10);
313  if (pts >= start_time) {
314  if (duration_entry) {
315  int64_t duration = strtoll(duration_entry->value, NULL, 10);
316  if (pts < start_time + duration)
317  return -1;
318  else
319  return 0;
320  }
321  return -1;
322  }
323  return 0;
324  }
325  return NAN;
326 }
327 
329 {
330  SelectContext *select = ctx->priv;
331  AVFilterLink *inlink = ctx->inputs[0];
332  double res;
333 
334  if (isnan(select->var_values[VAR_START_PTS]))
335  select->var_values[VAR_START_PTS] = TS2D(frame->pts);
336  if (isnan(select->var_values[VAR_START_T]))
337  select->var_values[VAR_START_T] = TS2D(frame->pts) * av_q2d(inlink->time_base);
338 
339  select->var_values[VAR_N ] = inlink->frame_count_out;
340  select->var_values[VAR_PTS] = TS2D(frame->pts);
341  select->var_values[VAR_T ] = TS2D(frame->pts) * av_q2d(inlink->time_base);
342  select->var_values[VAR_POS] = frame->pkt_pos == -1 ? NAN : frame->pkt_pos;
343  select->var_values[VAR_KEY] = frame->key_frame;
345 
346  switch (inlink->type) {
347  case AVMEDIA_TYPE_AUDIO:
348  select->var_values[VAR_SAMPLES_N] = frame->nb_samples;
349  break;
350 
351  case AVMEDIA_TYPE_VIDEO:
352  select->var_values[VAR_INTERLACE_TYPE] =
353  !frame->interlaced_frame ? INTERLACE_TYPE_P :
354  frame->top_field_first ? INTERLACE_TYPE_T : INTERLACE_TYPE_B;
355  select->var_values[VAR_PICT_TYPE] = frame->pict_type;
356  if (select->do_scene_detect) {
357  char buf[32];
359  // TODO: document metadata
360  snprintf(buf, sizeof(buf), "%f", select->var_values[VAR_SCENE]);
361  av_dict_set(&frame->metadata, "lavfi.scene_score", buf, 0);
362  }
363  break;
364  }
365 
366  select->select = res = av_expr_eval(select->expr, select->var_values, NULL);
367  av_log(inlink->dst, AV_LOG_DEBUG,
368  "n:%f pts:%f t:%f key:%d",
369  select->var_values[VAR_N],
370  select->var_values[VAR_PTS],
371  select->var_values[VAR_T],
372  frame->key_frame);
373 
374  switch (inlink->type) {
375  case AVMEDIA_TYPE_VIDEO:
376  av_log(inlink->dst, AV_LOG_DEBUG, " interlace_type:%c pict_type:%c scene:%f",
377  (!frame->interlaced_frame) ? 'P' :
378  frame->top_field_first ? 'T' : 'B',
379  av_get_picture_type_char(frame->pict_type),
380  select->var_values[VAR_SCENE]);
381  break;
382  case AVMEDIA_TYPE_AUDIO:
383  av_log(inlink->dst, AV_LOG_DEBUG, " samples_n:%d consumed_samples_n:%f",
384  frame->nb_samples,
386  break;
387  }
388 
389  if (res == 0) {
390  select->select_out = -1; /* drop */
391  } else if (isnan(res) || res < 0) {
392  select->select_out = 0; /* first output */
393  } else {
394  select->select_out = FFMIN(ceilf(res)-1, select->nb_outputs-1); /* other outputs */
395  }
396 
397  av_log(inlink->dst, AV_LOG_DEBUG, " -> select:%f select_out:%d\n", res, select->select_out);
398 
399  if (res) {
400  select->var_values[VAR_PREV_SELECTED_N] = select->var_values[VAR_N];
402  select->var_values[VAR_PREV_SELECTED_T] = select->var_values[VAR_T];
403  select->var_values[VAR_SELECTED_N] += 1.0;
404  if (inlink->type == AVMEDIA_TYPE_AUDIO)
405  select->var_values[VAR_CONSUMED_SAMPLES_N] += frame->nb_samples;
406  }
407 
408  select->var_values[VAR_PREV_PTS] = select->var_values[VAR_PTS];
409  select->var_values[VAR_PREV_T] = select->var_values[VAR_T];
410 }
411 
413 {
414  AVFilterContext *ctx = inlink->dst;
415  SelectContext *select = ctx->priv;
416 
418  if (select->select)
419  return ff_filter_frame(ctx->outputs[select->select_out], frame);
420 
422  return 0;
423 }
424 
425 static int request_frame(AVFilterLink *outlink)
426 {
427  AVFilterLink *inlink = outlink->src->inputs[0];
428  int ret = ff_request_frame(inlink);
429  return ret;
430 }
431 
433 {
434  SelectContext *select = ctx->priv;
435  int i;
436 
437  av_expr_free(select->expr);
438  select->expr = NULL;
439 
440  for (i = 0; i < ctx->nb_outputs; i++)
441  av_freep(&ctx->output_pads[i].name);
442 
443  if (select->do_scene_detect) {
444  av_frame_free(&select->prev_picref);
445  }
446 }
447 
448 #if CONFIG_ASELECT_FILTER
449 
451 AVFILTER_DEFINE_CLASS(aselect);
452 
453 static av_cold int aselect_init(AVFilterContext *ctx)
454 {
455  SelectContext *select = ctx->priv;
456  int ret;
457 
458  if ((ret = init(ctx)) < 0)
459  return ret;
460 
461  if (select->do_scene_detect) {
462  av_log(ctx, AV_LOG_ERROR, "Scene detection is ignored in aselect filter\n");
463  return AVERROR(EINVAL);
464  }
465 
466  return 0;
467 }
468 
469 static const AVFilterPad avfilter_af_aselect_inputs[] = {
470  {
471  .name = "default",
472  .type = AVMEDIA_TYPE_AUDIO,
473  .config_props = config_input,
474  .filter_frame = filter_frame,
475  },
476  { NULL }
477 };
478 
479 const AVFilter ff_af_aselect = {
480  .name = "aselect",
481  .description = NULL_IF_CONFIG_SMALL("Select audio frames to pass in output."),
482  .init = aselect_init,
483  .uninit = uninit,
484  .priv_size = sizeof(SelectContext),
485  .inputs = avfilter_af_aselect_inputs,
486  .priv_class = &aselect_class,
488 };
489 #endif /* CONFIG_ASELECT_FILTER */
490 
491 #if CONFIG_SELECT_FILTER
492 
493 static int query_formats(AVFilterContext *ctx)
494 {
495  SelectContext *select = ctx->priv;
496 
497  if (!select->do_scene_detect) {
499  } else {
500  int ret;
501  static const enum AVPixelFormat pix_fmts[] = {
508  };
510 
511  if (!fmts_list)
512  return AVERROR(ENOMEM);
513  ret = ff_set_common_formats(ctx, fmts_list);
514  if (ret < 0)
515  return ret;
516  }
517  return 0;
518 }
519 
521 AVFILTER_DEFINE_CLASS(select);
522 
523 static av_cold int select_init(AVFilterContext *ctx)
524 {
525  int ret;
526 
527  if ((ret = init(ctx)) < 0)
528  return ret;
529 
530  return 0;
531 }
532 
533 static const AVFilterPad avfilter_vf_select_inputs[] = {
534  {
535  .name = "default",
536  .type = AVMEDIA_TYPE_VIDEO,
537  .config_props = config_input,
538  .filter_frame = filter_frame,
539  },
540  { NULL }
541 };
542 
543 const AVFilter ff_vf_select = {
544  .name = "select",
545  .description = NULL_IF_CONFIG_SMALL("Select video frames to pass in output."),
546  .init = select_init,
547  .uninit = uninit,
548  .query_formats = query_formats,
549  .priv_size = sizeof(SelectContext),
550  .priv_class = &select_class,
551  .inputs = avfilter_vf_select_inputs,
553 };
554 #endif /* CONFIG_SELECT_FILTER */
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
VAR_PICT_TYPE_S
@ VAR_PICT_TYPE_S
Definition: f_select.c:116
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
AV_OPT_FLAG_VIDEO_PARAM
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:280
VAR_INTERLACE_TYPE_P
@ VAR_INTERLACE_TYPE_P
Definition: f_select.c:122
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:286
VAR_P
@ VAR_P
Definition: f_select.c:107
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:978
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2540
request_frame
static int request_frame(AVFilterLink *outlink)
Definition: f_select.c:425
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
SelectContext
Definition: f_select.c:144
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:113
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
VAR_PREV_T
@ VAR_PREV_T
Definition: f_select.c:102
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
get_concatdec_select
static double get_concatdec_select(AVFrame *frame, int64_t pts)
Definition: f_select.c:306
pixdesc.h
AVFrame::width
int width
Definition: frame.h:361
VAR_INTERLACE_TYPE_B
@ VAR_INTERLACE_TYPE_B
Definition: f_select.c:124
VAR_T
@ VAR_T
Definition: f_select.c:100
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: f_select.c:432
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:395
VAR_START_T
@ VAR_START_T
Definition: f_select.c:101
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
AVDictionary
Definition: dict.c:30
VAR_POS
@ VAR_POS
Definition: f_select.c:135
VAR_SAMPLE_RATE
@ VAR_SAMPLE_RATE
Definition: f_select.c:128
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:149
SelectContext::sad
ff_scene_sad_fn sad
Sum of the absolute difference function (scene detect only)
Definition: f_select.c:154
video.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:293
VAR_SCENE
@ VAR_SCENE
Definition: f_select.c:137
VAR_CONSUMED_SAMPLES_N
@ VAR_CONSUMED_SAMPLES_N
Definition: f_select.c:126
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:317
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
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:685
VAR_PREV_SELECTED_N
@ VAR_PREV_SELECTED_N
Definition: f_select.c:132
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2580
fifo.h
VAR_SAMPLES_N
@ VAR_SAMPLES_N
Definition: f_select.c:127
VAR_START_PTS
@ VAR_START_PTS
Definition: f_select.c:96
VAR_PICT_TYPE_P
@ VAR_PICT_TYPE_P
Definition: f_select.c:114
pts
static int64_t pts
Definition: transcode_aac.c:653
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:336
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
VAR_BI
@ VAR_BI
Definition: f_select.c:112
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
SelectContext::width
ptrdiff_t width[4]
Definition: f_select.c:151
AVFilterPad::request_frame
int(* request_frame)(AVFilterLink *link)
Frame request callback.
Definition: internal.h:102
av_cold
#define av_cold
Definition: attributes.h:90
inputs
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 inputs
Definition: filter_design.txt:243
ff_set_common_formats
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:580
duration
int64_t duration
Definition: movenc.c:64
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:40
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
get_scene_score
static double get_scene_score(AVFilterContext *ctx, AVFrame *frame)
Definition: f_select.c:273
INTERLACE_TYPE_T
#define INTERLACE_TYPE_T
Definition: f_select.c:205
VAR_SI
@ VAR_SI
Definition: f_select.c:110
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:51
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
VAR_PREV_SELECTED_PTS
@ VAR_PREV_SELECTED_PTS
Definition: f_select.c:98
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:105
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
var_name
var_name
Definition: noise_bsf.c:47
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
av_expr_eval
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:766
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
AVExpr
Definition: eval.c:157
SelectContext::select_out
int select_out
mark the selected output pad index
Definition: f_select.c:158
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
VAR_PREV_SELECTED_T
@ VAR_PREV_SELECTED_T
Definition: f_select.c:103
NAN
#define NAN
Definition: mathematics.h:64
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:279
INTERLACE_TYPE_B
#define INTERLACE_TYPE_B
Definition: f_select.c:206
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:130
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
TS2D
#define TS2D(ts)
Definition: internal.h:208
NULL
#define NULL
Definition: coverity.c:32
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:78
AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:341
av_clipf
#define av_clipf
Definition: common.h:144
AV_PICTURE_TYPE_SI
@ AV_PICTURE_TYPE_SI
Switching Intra.
Definition: avutil.h:278
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
SelectContext::select
double select
Definition: f_select.c:157
SelectContext::prev_picref
AVFrame * prev_picref
previous frame (scene detect only)
Definition: f_select.c:156
DEFINE_OPTIONS
#define DEFINE_OPTIONS(filt_name, FLAGS)
Definition: f_select.c:163
init
static av_cold int init(AVFilterContext *ctx)
Definition: f_select.c:174
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AV_PICTURE_TYPE_SP
@ AV_PICTURE_TYPE_SP
Switching Predicted.
Definition: avutil.h:279
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:94
SelectContext::prev_mafd
double prev_mafd
previous MAFD (scene detect only)
Definition: f_select.c:155
SelectContext::do_scene_detect
int do_scene_detect
1 if the expression requires scene detection variables, 0 otherwise
Definition: f_select.c:153
scene_sad.h
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:112
config_input
static int config_input(AVFilterLink *inlink)
Definition: f_select.c:208
eval.h
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
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:116
ff_default_query_formats
int ff_default_query_formats(AVFilterContext *ctx)
Definition: formats.c:586
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:330
VAR_INTERLACE_TYPE
@ VAR_INTERLACE_TYPE
Definition: f_select.c:121
VAR_VARS_NB
@ VAR_VARS_NB
Definition: f_select.c:141
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:40
SelectContext::expr
AVExpr * expr
Definition: f_select.c:147
internal.h
AVFILTER_DEFINE_CLASS
#define AVFILTER_DEFINE_CLASS(fname)
Definition: internal.h:288
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:88
VAR_TB
@ VAR_TB
Definition: f_select.c:93
i
int i
Definition: input.c:406
SelectContext::expr_str
char * expr_str
Definition: f_select.c:146
internal.h
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
Definition: f_select.c:412
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
SelectContext::nb_planes
int nb_planes
Definition: f_select.c:150
VAR_PICT_TYPE_SI
@ VAR_PICT_TYPE_SI
Definition: f_select.c:117
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
SelectContext::bitdepth
int bitdepth
Definition: f_select.c:149
select_frame
static void select_frame(AVFilterContext *ctx, AVFrame *frame)
Definition: f_select.c:328
VAR_B
@ VAR_B
Definition: f_select.c:108
AVFilter
Filter definition.
Definition: avfilter.h:145
VAR_PICT_TYPE_BI
@ VAR_PICT_TYPE_BI
Definition: f_select.c:119
ret
ret
Definition: filter_design.txt:187
AVFilterPad::type
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:65
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:134
VAR_SELECTED_N
@ VAR_SELECTED_N
Definition: f_select.c:131
SelectContext::var_values
double var_values[VAR_VARS_NB]
Definition: f_select.c:148
SelectContext::nb_outputs
int nb_outputs
Definition: f_select.c:159
AVFrame::height
int height
Definition: frame.h:361
VAR_S
@ VAR_S
Definition: f_select.c:109
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
VAR_PICT_TYPE_I
@ VAR_PICT_TYPE_I
Definition: f_select.c:113
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
ff_insert_outpad
static int ff_insert_outpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new output pad for the filter.
Definition: internal.h:248
VAR_PREV_PTS
@ VAR_PREV_PTS
Definition: f_select.c:97
avfilter.h
VAR_SP
@ VAR_SP
Definition: f_select.c:111
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:118
AVFilterContext
An instance of a filter.
Definition: avfilter.h:333
desc
const char * desc
Definition: libsvtav1.c:79
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
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
audio.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
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
AVDictionaryEntry
Definition: dict.h:79
VAR_PTS
@ VAR_PTS
Definition: f_select.c:95
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
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:70
AV_PICTURE_TYPE_BI
@ AV_PICTURE_TYPE_BI
BI type.
Definition: avutil.h:280
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: aeval.c:243
SelectContext::height
ptrdiff_t height[4]
Definition: f_select.c:152
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVDictionaryEntry::value
char * value
Definition: dict.h:81
avstring.h
VAR_PICT_TYPE_B
@ VAR_PICT_TYPE_B
Definition: f_select.c:115
VAR_INTERLACE_TYPE_T
@ VAR_INTERLACE_TYPE_T
Definition: f_select.c:123
ff_vf_select
const AVFilter ff_vf_select
snprintf
#define snprintf
Definition: snprintf.h:34
VAR_I
@ VAR_I
Definition: f_select.c:106
VAR_CONCATDEC_SELECT
@ VAR_CONCATDEC_SELECT
Definition: f_select.c:139
INTERLACE_TYPE_P
#define INTERLACE_TYPE_P
Definition: f_select.c:204