FFmpeg
vf_delogo.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2002 Jindrich Makovicka <makovick@gmail.com>
3  * Copyright (c) 2011 Stefano Sabatini
4  * Copyright (c) 2013, 2015 Jean Delvare <jdelvare@suse.com>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License along
19  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
20  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21  */
22 
23 /**
24  * @file
25  * A very simple tv station logo remover
26  * Originally imported from MPlayer libmpcodecs/vf_delogo.c,
27  * the algorithm was later improved.
28  */
29 
30 #include "libavutil/common.h"
31 #include "libavutil/imgutils.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/eval.h"
35 #include "avfilter.h"
36 #include "formats.h"
37 #include "internal.h"
38 #include "video.h"
39 static const char * const var_names[] = {
40  "x",
41  "y",
42  "w",
43  "h",
44  "n", ///< number of frame
45  "t", ///< timestamp expressed in seconds
46  NULL
47 };
48 
49 enum var_name {
57 };
58 #define TS2T(ts, tb) ((ts) == AV_NOPTS_VALUE ? NAN : (double)(ts) * av_q2d(tb))
59 
60 static int set_expr(AVExpr **pexpr, const char *expr, const char *option, void *log_ctx)
61 {
62  int ret;
63  AVExpr *old = NULL;
64 
65  if (*pexpr)
66  old = *pexpr;
67  ret = av_expr_parse(pexpr, expr, var_names, NULL, NULL, NULL, NULL, 0, log_ctx);
68  if (ret < 0) {
69  av_log(log_ctx, AV_LOG_ERROR,
70  "Error when parsing the expression '%s' for %s\n",
71  expr, option);
72  *pexpr = old;
73  return ret;
74  }
75 
76  av_expr_free(old);
77  return 0;
78 }
79 
80 
81 /**
82  * Apply a simple delogo algorithm to the image in src and put the
83  * result in dst.
84  *
85  * The algorithm is only applied to the region specified by the logo
86  * parameters.
87  *
88  * @param w width of the input image
89  * @param h height of the input image
90  * @param logo_x x coordinate of the top left corner of the logo region
91  * @param logo_y y coordinate of the top left corner of the logo region
92  * @param logo_w width of the logo
93  * @param logo_h height of the logo
94  * @param band the size of the band around the processed area
95  * @param show show a rectangle around the processed area, useful for
96  * parameters tweaking
97  * @param direct if non-zero perform in-place processing
98  */
99 static void apply_delogo(uint8_t *dst, int dst_linesize,
100  uint8_t *src, int src_linesize,
101  int w, int h, AVRational sar,
102  int logo_x, int logo_y, int logo_w, int logo_h,
103  unsigned int band, int show, int direct)
104 {
105  int x, y;
106  uint64_t interp, weightl, weightr, weightt, weightb, weight;
107  uint8_t *xdst, *xsrc;
108 
109  uint8_t *topleft, *botleft, *topright;
110  unsigned int left_sample, right_sample;
111  int xclipl, xclipr, yclipt, yclipb;
112  int logo_x1, logo_x2, logo_y1, logo_y2;
113 
114  xclipl = FFMAX(-logo_x, 0);
115  xclipr = FFMAX(logo_x+logo_w-w, 0);
116  yclipt = FFMAX(-logo_y, 0);
117  yclipb = FFMAX(logo_y+logo_h-h, 0);
118 
119  logo_x1 = logo_x + xclipl;
120  logo_x2 = logo_x + logo_w - xclipr - 1;
121  logo_y1 = logo_y + yclipt;
122  logo_y2 = logo_y + logo_h - yclipb - 1;
123 
124  topleft = src+logo_y1 * src_linesize+logo_x1;
125  topright = src+logo_y1 * src_linesize+logo_x2;
126  botleft = src+logo_y2 * src_linesize+logo_x1;
127 
128  if (!direct)
129  av_image_copy_plane(dst, dst_linesize, src, src_linesize, w, h);
130 
131  dst += (logo_y1 + 1) * dst_linesize;
132  src += (logo_y1 + 1) * src_linesize;
133 
134  for (y = logo_y1+1; y < logo_y2; y++) {
135  left_sample = topleft[src_linesize*(y-logo_y1)] +
136  topleft[src_linesize*(y-logo_y1-1)] +
137  topleft[src_linesize*(y-logo_y1+1)];
138  right_sample = topright[src_linesize*(y-logo_y1)] +
139  topright[src_linesize*(y-logo_y1-1)] +
140  topright[src_linesize*(y-logo_y1+1)];
141 
142  for (x = logo_x1+1,
143  xdst = dst+logo_x1+1,
144  xsrc = src+logo_x1+1; x < logo_x2; x++, xdst++, xsrc++) {
145 
146  if (show && (y == logo_y1+1 || y == logo_y2-1 ||
147  x == logo_x1+1 || x == logo_x2-1)) {
148  *xdst = 0;
149  continue;
150  }
151 
152  /* Weighted interpolation based on relative distances, taking SAR into account */
153  weightl = (uint64_t) (logo_x2-x) * (y-logo_y1) * (logo_y2-y) * sar.den;
154  weightr = (uint64_t)(x-logo_x1) * (y-logo_y1) * (logo_y2-y) * sar.den;
155  weightt = (uint64_t)(x-logo_x1) * (logo_x2-x) * (logo_y2-y) * sar.num;
156  weightb = (uint64_t)(x-logo_x1) * (logo_x2-x) * (y-logo_y1) * sar.num;
157 
158  interp =
159  left_sample * weightl
160  +
161  right_sample * weightr
162  +
163  (topleft[x-logo_x1] +
164  topleft[x-logo_x1-1] +
165  topleft[x-logo_x1+1]) * weightt
166  +
167  (botleft[x-logo_x1] +
168  botleft[x-logo_x1-1] +
169  botleft[x-logo_x1+1]) * weightb;
170  weight = (weightl + weightr + weightt + weightb) * 3U;
171  interp = (interp + (weight >> 1)) / weight;
172 
173  if (y >= logo_y+band && y < logo_y+logo_h-band &&
174  x >= logo_x+band && x < logo_x+logo_w-band) {
175  *xdst = interp;
176  } else {
177  unsigned dist = 0;
178 
179  if (x < logo_x+band)
180  dist = FFMAX(dist, logo_x-x+band);
181  else if (x >= logo_x+logo_w-band)
182  dist = FFMAX(dist, x-(logo_x+logo_w-1-band));
183 
184  if (y < logo_y+band)
185  dist = FFMAX(dist, logo_y-y+band);
186  else if (y >= logo_y+logo_h-band)
187  dist = FFMAX(dist, y-(logo_y+logo_h-1-band));
188 
189  *xdst = (*xsrc*dist + interp*(band-dist))/band;
190  }
191  }
192 
193  dst += dst_linesize;
194  src += src_linesize;
195  }
196 }
197 
198 typedef struct DelogoContext {
199  const AVClass *class;
200  int x, y, w, h, band, show;
201  char *x_expr, *y_expr, *w_expr, *h_expr;
204 } DelogoContext;
205 
206 #define OFFSET(x) offsetof(DelogoContext, x)
207 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
208 
209 static const AVOption delogo_options[]= {
210  { "x", "set logo x position", OFFSET(x_expr), AV_OPT_TYPE_STRING, { .str = "-1" }, CHAR_MIN, CHAR_MAX, FLAGS },
211  { "y", "set logo y position", OFFSET(y_expr), AV_OPT_TYPE_STRING, { .str = "-1" }, CHAR_MIN, CHAR_MAX, FLAGS },
212  { "w", "set logo width", OFFSET(w_expr), AV_OPT_TYPE_STRING, { .str = "-1" }, CHAR_MIN, CHAR_MAX, FLAGS },
213  { "h", "set logo height", OFFSET(h_expr), AV_OPT_TYPE_STRING, { .str = "-1" }, CHAR_MIN, CHAR_MAX, FLAGS },
214 #if LIBAVFILTER_VERSION_MAJOR < 7
215  /* Actual default value for band/t is 1, set in init */
216  { "band", "set delogo area band size", OFFSET(band), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
217  { "t", "set delogo area band size", OFFSET(band), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
218 #endif
219  { "show", "show delogo area", OFFSET(show), AV_OPT_TYPE_BOOL,{ .i64 = 0 }, 0, 1, FLAGS },
220  { NULL }
221 };
222 
223 AVFILTER_DEFINE_CLASS(delogo);
225 {
226  DelogoContext *s = ctx->priv;
227 
228  av_expr_free(s->x_pexpr); s->x_pexpr = NULL;
229  av_expr_free(s->y_pexpr); s->y_pexpr = NULL;
230  av_expr_free(s->w_pexpr); s->w_pexpr = NULL;
231  av_expr_free(s->h_pexpr); s->h_pexpr = NULL;
232 }
233 
234 
236 {
237  static const enum AVPixelFormat pix_fmts[] = {
242  };
243  AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
244  if (!fmts_list)
245  return AVERROR(ENOMEM);
246  return ff_set_common_formats(ctx, fmts_list);
247 }
248 
250 {
251  DelogoContext *s = ctx->priv;
252  int ret = 0;
253 
254  if ((ret = set_expr(&s->x_pexpr, s->x_expr, "x", ctx)) < 0 ||
255  (ret = set_expr(&s->y_pexpr, s->y_expr, "y", ctx)) < 0 ||
256  (ret = set_expr(&s->w_pexpr, s->w_expr, "w", ctx)) < 0 ||
257  (ret = set_expr(&s->h_pexpr, s->h_expr, "h", ctx)) < 0 )
258  return ret;
259 
260  s->x = av_expr_eval(s->x_pexpr, s->var_values, s);
261  s->y = av_expr_eval(s->y_pexpr, s->var_values, s);
262  s->w = av_expr_eval(s->w_pexpr, s->var_values, s);
263  s->h = av_expr_eval(s->h_pexpr, s->var_values, s);
264 
265 #define CHECK_UNSET_OPT(opt) \
266  if (s->opt == -1) { \
267  av_log(s, AV_LOG_ERROR, "Option %s was not set.\n", #opt); \
268  return AVERROR(EINVAL); \
269  }
274 
275 #if LIBAVFILTER_VERSION_MAJOR < 7
276  if (s->band == 0) { /* Unset, use default */
277  av_log(ctx, AV_LOG_WARNING, "Note: default band value was changed from 4 to 1.\n");
278  s->band = 1;
279  } else if (s->band != 1) {
280  av_log(ctx, AV_LOG_WARNING, "Option band is deprecated.\n");
281  }
282 #else
283  s->band = 1;
284 #endif
285  av_log(ctx, AV_LOG_VERBOSE, "x:%d y:%d, w:%d h:%d band:%d show:%d\n",
286  s->x, s->y, s->w, s->h, s->band, s->show);
287 
288  s->w += s->band*2;
289  s->h += s->band*2;
290  s->x -= s->band;
291  s->y -= s->band;
292 
293  return 0;
294 }
295 
297 {
298  DelogoContext *s = inlink->dst->priv;
299 
300  /* Check whether the logo area fits in the frame */
301  if (s->x + (s->band - 1) < 0 || s->x + s->w - (s->band*2 - 2) > inlink->w ||
302  s->y + (s->band - 1) < 0 || s->y + s->h - (s->band*2 - 2) > inlink->h) {
303  av_log(s, AV_LOG_ERROR, "Logo area is outside of the frame.\n");
304  return AVERROR(EINVAL);
305  }
306 
307  return 0;
308 }
309 
311 {
312  DelogoContext *s = inlink->dst->priv;
313  AVFilterLink *outlink = inlink->dst->outputs[0];
315  AVFrame *out;
316  int hsub0 = desc->log2_chroma_w;
317  int vsub0 = desc->log2_chroma_h;
318  int direct = 0;
319  int plane;
320  AVRational sar;
321  int ret;
322 
323  s->var_values[VAR_N] = inlink->frame_count_out;
324  s->var_values[VAR_T] = TS2T(in->pts, inlink->time_base);
325  s->x = av_expr_eval(s->x_pexpr, s->var_values, s);
326  s->y = av_expr_eval(s->y_pexpr, s->var_values, s);
327  s->w = av_expr_eval(s->w_pexpr, s->var_values, s);
328  s->h = av_expr_eval(s->h_pexpr, s->var_values, s);
329 
330  if (s->x + (s->band - 1) <= 0 || s->x + s->w - (s->band*2 - 2) > inlink->w ||
331  s->y + (s->band - 1) <= 0 || s->y + s->h - (s->band*2 - 2) > inlink->h) {
332  av_log(s, AV_LOG_WARNING, "Logo area is outside of the frame,"
333  " auto set the area inside of the frame\n");
334  }
335 
336  if (s->x + (s->band - 1) <= 0)
337  s->x = 1 + s->band;
338  if (s->y + (s->band - 1) <= 0)
339  s->y = 1 + s->band;
340  if (s->x + s->w - (s->band*2 - 2) > inlink->w)
341  s->w = inlink->w - s->x - (s->band*2 - 2);
342  if (s->y + s->h - (s->band*2 - 2) > inlink->h)
343  s->h = inlink->h - s->y - (s->band*2 - 2);
344 
345  ret = config_input(inlink);
346  if (ret < 0) {
347  av_frame_free(&in);
348  return ret;
349  }
350 
351  s->w += s->band*2;
352  s->h += s->band*2;
353  s->x -= s->band;
354  s->y -= s->band;
355 
356  if (av_frame_is_writable(in)) {
357  direct = 1;
358  out = in;
359  } else {
360  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
361  if (!out) {
362  av_frame_free(&in);
363  return AVERROR(ENOMEM);
364  }
365 
366  av_frame_copy_props(out, in);
367  }
368 
369  sar = in->sample_aspect_ratio;
370  /* Assume square pixels if SAR is unknown */
371  if (!sar.num)
372  sar.num = sar.den = 1;
373 
374  for (plane = 0; plane < desc->nb_components; plane++) {
375  int hsub = plane == 1 || plane == 2 ? hsub0 : 0;
376  int vsub = plane == 1 || plane == 2 ? vsub0 : 0;
377 
378  apply_delogo(out->data[plane], out->linesize[plane],
379  in ->data[plane], in ->linesize[plane],
380  AV_CEIL_RSHIFT(inlink->w, hsub),
381  AV_CEIL_RSHIFT(inlink->h, vsub),
382  sar, s->x>>hsub, s->y>>vsub,
383  /* Up and left borders were rounded down, inject lost bits
384  * into width and height to avoid error accumulation */
385  AV_CEIL_RSHIFT(s->w + (s->x & ((1<<hsub)-1)), hsub),
386  AV_CEIL_RSHIFT(s->h + (s->y & ((1<<vsub)-1)), vsub),
387  s->band>>FFMIN(hsub, vsub),
388  s->show, direct);
389  }
390 
391  if (!direct)
392  av_frame_free(&in);
393 
394  return ff_filter_frame(outlink, out);
395 }
396 
398  {
399  .name = "default",
400  .type = AVMEDIA_TYPE_VIDEO,
401  .filter_frame = filter_frame,
402  .config_props = config_input,
403  },
404  { NULL }
405 };
406 
408  {
409  .name = "default",
410  .type = AVMEDIA_TYPE_VIDEO,
411  },
412  { NULL }
413 };
414 
416  .name = "delogo",
417  .description = NULL_IF_CONFIG_SMALL("Remove logo from input video."),
418  .priv_size = sizeof(DelogoContext),
419  .priv_class = &delogo_class,
420  .init = init,
421  .uninit = uninit,
423  .inputs = avfilter_vf_delogo_inputs,
424  .outputs = avfilter_vf_delogo_outputs,
426 };
int plane
Definition: avisynth_c.h:384
#define NULL
Definition: coverity.c:32
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:295
AVOption.
Definition: opt.h:246
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
Main libavfilter public API header.
const char * desc
Definition: nvenc.c:68
static void apply_delogo(uint8_t *dst, int dst_linesize, uint8_t *src, int src_linesize, int w, int h, AVRational sar, int logo_x, int logo_y, int logo_w, int logo_h, unsigned int band, int show, int direct)
Apply a simple delogo algorithm to the image in src and put the result in dst.
Definition: vf_delogo.c:99
#define FLAGS
Definition: vf_delogo.c:207
int num
Numerator.
Definition: rational.h:59
static int query_formats(AVFilterContext *ctx)
Definition: vf_delogo.c:235
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:683
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:99
#define src
Definition: vp8dsp.c:254
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
static int set_expr(AVExpr **pexpr, const char *expr, const char *option, void *log_ctx)
Definition: vf_delogo.c:60
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
Definition: avfilter.h:125
const char * name
Pad name.
Definition: internal.h:60
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1093
static int config_input(AVFilterLink *inlink)
Definition: vf_delogo.c:296
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
uint8_t
#define av_cold
Definition: attributes.h:82
AVOptions.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
Definition: eval.c:157
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
AVFilter ff_vf_delogo
Definition: vf_delogo.c:415
#define av_log(a,...)
A filter pad used for either input or output.
Definition: internal.h:54
#define U(x)
Definition: vp56_arith.h:37
#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:569
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
static const AVFilterPad avfilter_vf_delogo_outputs[]
Definition: vf_delogo.c:407
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
#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
char * h_expr
Definition: vf_delogo.c:201
static av_cold int init(AVFilterContext *ctx)
Definition: vf_delogo.c:249
#define OFFSET(x)
Definition: vf_delogo.c:206
#define FFMAX(a, b)
Definition: common.h:94
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
var_name
Definition: aeval.c:46
char * y_expr
Definition: vf_delogo.c:201
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
#define FFMIN(a, b)
Definition: common.h:96
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_delogo.c:310
uint8_t w
Definition: llviddspenc.c:38
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_delogo.c:224
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
AVExpr * x_pexpr
Definition: vf_delogo.c:202
AVFILTER_DEFINE_CLASS(delogo)
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:336
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:594
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
static const char *const var_names[]
Definition: vf_delogo.c:39
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:383
static const AVOption delogo_options[]
Definition: vf_delogo.c:209
AVExpr * w_pexpr
Definition: vf_delogo.c:202
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
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
AVExpr * h_pexpr
Definition: vf_delogo.c:202
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:144
option
Definition: libkvazaar.c:291
Rational number (pair of numerator and denominator).
Definition: rational.h:58
const char * name
Filter name.
Definition: avfilter.h:148
char * x_expr
Definition: vf_delogo.c:201
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
static int weight(int i, int blen, int offset)
Definition: diracdec.c:1564
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
#define TS2T(ts, tb)
Definition: vf_delogo.c:58
char * w_expr
Definition: vf_delogo.c:201
#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:309
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 CHECK_UNSET_OPT(opt)
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
double var_values[VAR_VARS_NB]
Definition: vf_delogo.c:203
common internal and external API header
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
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:754
A list of supported formats for one end of a filter link.
Definition: formats.h:64
An instance of a filter.
Definition: avfilter.h:338
FILE * out
Definition: movenc.c:54
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition: imgutils.c:338
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
static const AVFilterPad avfilter_vf_delogo_inputs[]
Definition: vf_delogo.c:397
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
static void hsub(htype *dst, const htype *src, int bins)
Definition: vf_median.c:74
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:654
simple arithmetic expression evaluator
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
AVExpr * y_pexpr
Definition: vf_delogo.c:202