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 "internal.h"
37 #include "video.h"
38 static const char * const var_names[] = {
39  "x",
40  "y",
41  "w",
42  "h",
43  "n", ///< number of frame
44  "t", ///< timestamp expressed in seconds
45  NULL
46 };
47 
48 enum var_name {
56 };
57 
58 static int set_expr(AVExpr **pexpr, const char *expr, const char *option, void *log_ctx)
59 {
60  int ret;
61  AVExpr *old = NULL;
62 
63  if (*pexpr)
64  old = *pexpr;
65  ret = av_expr_parse(pexpr, expr, var_names, NULL, NULL, NULL, NULL, 0, log_ctx);
66  if (ret < 0) {
67  av_log(log_ctx, AV_LOG_ERROR,
68  "Error when parsing the expression '%s' for %s\n",
69  expr, option);
70  *pexpr = old;
71  return ret;
72  }
73 
74  av_expr_free(old);
75  return 0;
76 }
77 
78 
79 /**
80  * Apply a simple delogo algorithm to the image in src and put the
81  * result in dst.
82  *
83  * The algorithm is only applied to the region specified by the logo
84  * parameters.
85  *
86  * @param w width of the input image
87  * @param h height of the input image
88  * @param logo_x x coordinate of the top left corner of the logo region
89  * @param logo_y y coordinate of the top left corner of the logo region
90  * @param logo_w width of the logo
91  * @param logo_h height of the logo
92  * @param band the size of the band around the processed area
93  * @param show show a rectangle around the processed area, useful for
94  * parameters tweaking
95  * @param direct if non-zero perform in-place processing
96  */
97 static void apply_delogo(uint8_t *dst, int dst_linesize,
98  uint8_t *src, int src_linesize,
99  int w, int h, AVRational sar,
100  int logo_x, int logo_y, int logo_w, int logo_h,
101  unsigned int band, int show, int direct)
102 {
103  int x, y;
104  uint64_t interp, weightl, weightr, weightt, weightb, weight;
105  uint8_t *xdst, *xsrc;
106 
107  uint8_t *topleft, *botleft, *topright;
108  unsigned int left_sample, right_sample;
109  int xclipl, xclipr, yclipt, yclipb;
110  int logo_x1, logo_x2, logo_y1, logo_y2;
111 
112  xclipl = FFMAX(-logo_x, 0);
113  xclipr = FFMAX(logo_x+logo_w-w, 0);
114  yclipt = FFMAX(-logo_y, 0);
115  yclipb = FFMAX(logo_y+logo_h-h, 0);
116 
117  logo_x1 = logo_x + xclipl;
118  logo_x2 = logo_x + logo_w - xclipr - 1;
119  logo_y1 = logo_y + yclipt;
120  logo_y2 = logo_y + logo_h - yclipb - 1;
121 
122  topleft = src+logo_y1 * src_linesize+logo_x1;
123  topright = src+logo_y1 * src_linesize+logo_x2;
124  botleft = src+logo_y2 * src_linesize+logo_x1;
125 
126  if (!direct)
127  av_image_copy_plane(dst, dst_linesize, src, src_linesize, w, h);
128 
129  dst += (logo_y1 + 1) * dst_linesize;
130  src += (logo_y1 + 1) * src_linesize;
131 
132  for (y = logo_y1+1; y < logo_y2; y++) {
133  left_sample = topleft[src_linesize*(y-logo_y1)] +
134  topleft[src_linesize*(y-logo_y1-1)] +
135  topleft[src_linesize*(y-logo_y1+1)];
136  right_sample = topright[src_linesize*(y-logo_y1)] +
137  topright[src_linesize*(y-logo_y1-1)] +
138  topright[src_linesize*(y-logo_y1+1)];
139 
140  for (x = logo_x1+1,
141  xdst = dst+logo_x1+1,
142  xsrc = src+logo_x1+1; x < logo_x2; x++, xdst++, xsrc++) {
143 
144  if (show && (y == logo_y1+1 || y == logo_y2-1 ||
145  x == logo_x1+1 || x == logo_x2-1)) {
146  *xdst = 0;
147  continue;
148  }
149 
150  /* Weighted interpolation based on relative distances, taking SAR into account */
151  weightl = (uint64_t) (logo_x2-x) * (y-logo_y1) * (logo_y2-y) * sar.den;
152  weightr = (uint64_t)(x-logo_x1) * (y-logo_y1) * (logo_y2-y) * sar.den;
153  weightt = (uint64_t)(x-logo_x1) * (logo_x2-x) * (logo_y2-y) * sar.num;
154  weightb = (uint64_t)(x-logo_x1) * (logo_x2-x) * (y-logo_y1) * sar.num;
155 
156  interp =
157  left_sample * weightl
158  +
159  right_sample * weightr
160  +
161  (topleft[x-logo_x1] +
162  topleft[x-logo_x1-1] +
163  topleft[x-logo_x1+1]) * weightt
164  +
165  (botleft[x-logo_x1] +
166  botleft[x-logo_x1-1] +
167  botleft[x-logo_x1+1]) * weightb;
168  weight = (weightl + weightr + weightt + weightb) * 3U;
169  interp = (interp + (weight >> 1)) / weight;
170 
171  if (y >= logo_y+band && y < logo_y+logo_h-band &&
172  x >= logo_x+band && x < logo_x+logo_w-band) {
173  *xdst = interp;
174  } else {
175  unsigned dist = 0;
176 
177  if (x < logo_x+band)
178  dist = FFMAX(dist, logo_x-x+band);
179  else if (x >= logo_x+logo_w-band)
180  dist = FFMAX(dist, x-(logo_x+logo_w-1-band));
181 
182  if (y < logo_y+band)
183  dist = FFMAX(dist, logo_y-y+band);
184  else if (y >= logo_y+logo_h-band)
185  dist = FFMAX(dist, y-(logo_y+logo_h-1-band));
186 
187  *xdst = (*xsrc*dist + interp*(band-dist))/band;
188  }
189  }
190 
191  dst += dst_linesize;
192  src += src_linesize;
193  }
194 }
195 
196 typedef struct DelogoContext {
197  const AVClass *class;
198  int x, y, w, h, band, show;
199  char *x_expr, *y_expr, *w_expr, *h_expr;
202 } DelogoContext;
203 
204 #define OFFSET(x) offsetof(DelogoContext, x)
205 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
206 
207 static const AVOption delogo_options[]= {
208  { "x", "set logo x position", OFFSET(x_expr), AV_OPT_TYPE_STRING, { .str = "-1" }, 0, 0, FLAGS },
209  { "y", "set logo y position", OFFSET(y_expr), AV_OPT_TYPE_STRING, { .str = "-1" }, 0, 0, FLAGS },
210  { "w", "set logo width", OFFSET(w_expr), AV_OPT_TYPE_STRING, { .str = "-1" }, 0, 0, FLAGS },
211  { "h", "set logo height", OFFSET(h_expr), AV_OPT_TYPE_STRING, { .str = "-1" }, 0, 0, FLAGS },
212  { "show", "show delogo area", OFFSET(show), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
213  { NULL }
214 };
215 
216 AVFILTER_DEFINE_CLASS(delogo);
218 {
219  DelogoContext *s = ctx->priv;
220 
221  av_expr_free(s->x_pexpr); s->x_pexpr = NULL;
222  av_expr_free(s->y_pexpr); s->y_pexpr = NULL;
223  av_expr_free(s->w_pexpr); s->w_pexpr = NULL;
224  av_expr_free(s->h_pexpr); s->h_pexpr = NULL;
225 }
226 
227 static const enum AVPixelFormat pix_fmts[] = {
232 };
233 
235 {
236  DelogoContext *s = ctx->priv;
237  int ret = 0;
238 
239  if ((ret = set_expr(&s->x_pexpr, s->x_expr, "x", ctx)) < 0 ||
240  (ret = set_expr(&s->y_pexpr, s->y_expr, "y", ctx)) < 0 ||
241  (ret = set_expr(&s->w_pexpr, s->w_expr, "w", ctx)) < 0 ||
242  (ret = set_expr(&s->h_pexpr, s->h_expr, "h", ctx)) < 0 )
243  return ret;
244 
245  s->x = av_expr_eval(s->x_pexpr, s->var_values, s);
246  s->y = av_expr_eval(s->y_pexpr, s->var_values, s);
247  s->w = av_expr_eval(s->w_pexpr, s->var_values, s);
248  s->h = av_expr_eval(s->h_pexpr, s->var_values, s);
249 
250 #define CHECK_UNSET_OPT(opt) \
251  if (s->opt == -1) { \
252  av_log(s, AV_LOG_ERROR, "Option %s was not set.\n", #opt); \
253  return AVERROR(EINVAL); \
254  }
255  CHECK_UNSET_OPT(x);
256  CHECK_UNSET_OPT(y);
259 
260  s->band = 1;
261 
262  av_log(ctx, AV_LOG_VERBOSE, "x:%d y:%d, w:%d h:%d band:%d show:%d\n",
263  s->x, s->y, s->w, s->h, s->band, s->show);
264 
265  s->w += s->band*2;
266  s->h += s->band*2;
267  s->x -= s->band;
268  s->y -= s->band;
269 
270  return 0;
271 }
272 
274 {
275  DelogoContext *s = inlink->dst->priv;
276 
277  /* Check whether the logo area fits in the frame */
278  if (s->x + (s->band - 1) < 0 || s->x + s->w - (s->band*2 - 2) > inlink->w ||
279  s->y + (s->band - 1) < 0 || s->y + s->h - (s->band*2 - 2) > inlink->h) {
280  av_log(s, AV_LOG_ERROR, "Logo area is outside of the frame.\n");
281  return AVERROR(EINVAL);
282  }
283 
284  return 0;
285 }
286 
288 {
289  DelogoContext *s = inlink->dst->priv;
290  AVFilterLink *outlink = inlink->dst->outputs[0];
292  AVFrame *out;
293  int hsub0 = desc->log2_chroma_w;
294  int vsub0 = desc->log2_chroma_h;
295  int direct = 0;
296  int plane;
297  AVRational sar;
298  int ret;
299 
300  s->var_values[VAR_N] = inlink->frame_count_out;
301  s->var_values[VAR_T] = TS2T(in->pts, inlink->time_base);
302  s->x = av_expr_eval(s->x_pexpr, s->var_values, s);
303  s->y = av_expr_eval(s->y_pexpr, s->var_values, s);
304  s->w = av_expr_eval(s->w_pexpr, s->var_values, s);
305  s->h = av_expr_eval(s->h_pexpr, s->var_values, s);
306 
307  if (s->x + (s->band - 1) <= 0 || s->x + s->w - (s->band*2 - 2) > inlink->w ||
308  s->y + (s->band - 1) <= 0 || s->y + s->h - (s->band*2 - 2) > inlink->h) {
309  av_log(s, AV_LOG_WARNING, "Logo area is outside of the frame,"
310  " auto set the area inside of the frame\n");
311  }
312 
313  if (s->x + (s->band - 1) <= 0)
314  s->x = 1 + s->band;
315  if (s->y + (s->band - 1) <= 0)
316  s->y = 1 + s->band;
317  if (s->x + s->w - (s->band*2 - 2) > inlink->w)
318  s->w = inlink->w - s->x - (s->band*2 - 2);
319  if (s->y + s->h - (s->band*2 - 2) > inlink->h)
320  s->h = inlink->h - s->y - (s->band*2 - 2);
321 
323  if (ret < 0) {
324  av_frame_free(&in);
325  return ret;
326  }
327 
328  s->w += s->band*2;
329  s->h += s->band*2;
330  s->x -= s->band;
331  s->y -= s->band;
332 
333  if (av_frame_is_writable(in)) {
334  direct = 1;
335  out = in;
336  } else {
337  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
338  if (!out) {
339  av_frame_free(&in);
340  return AVERROR(ENOMEM);
341  }
342 
344  }
345 
346  sar = in->sample_aspect_ratio;
347  /* Assume square pixels if SAR is unknown */
348  if (!sar.num)
349  sar.num = sar.den = 1;
350 
351  for (plane = 0; plane < desc->nb_components; plane++) {
352  int hsub = plane == 1 || plane == 2 ? hsub0 : 0;
353  int vsub = plane == 1 || plane == 2 ? vsub0 : 0;
354 
355  apply_delogo(out->data[plane], out->linesize[plane],
356  in ->data[plane], in ->linesize[plane],
358  AV_CEIL_RSHIFT(inlink->h, vsub),
359  sar, s->x>>hsub, s->y>>vsub,
360  /* Up and left borders were rounded down, inject lost bits
361  * into width and height to avoid error accumulation */
362  AV_CEIL_RSHIFT(s->w + (s->x & ((1<<hsub)-1)), hsub),
363  AV_CEIL_RSHIFT(s->h + (s->y & ((1<<vsub)-1)), vsub),
364  s->band>>FFMIN(hsub, vsub),
365  s->show, direct);
366  }
367 
368  if (!direct)
369  av_frame_free(&in);
370 
371  return ff_filter_frame(outlink, out);
372 }
373 
375  {
376  .name = "default",
377  .type = AVMEDIA_TYPE_VIDEO,
378  .filter_frame = filter_frame,
379  .config_props = config_input,
380  },
381 };
382 
384  .name = "delogo",
385  .description = NULL_IF_CONFIG_SMALL("Remove logo from input video."),
386  .priv_size = sizeof(DelogoContext),
387  .priv_class = &delogo_class,
388  .init = init,
389  .uninit = uninit,
394 };
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:112
ff_vf_delogo
const AVFilter ff_vf_delogo
Definition: vf_delogo.c:383
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
var_name
var_name
Definition: noise.c:46
out
FILE * out
Definition: movenc.c:54
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1018
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2962
DelogoContext::h
int h
Definition: vf_delogo.c:198
FILTER_PIXFMTS_ARRAY
#define FILTER_PIXFMTS_ARRAY(array)
Definition: internal.h:162
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
CHECK_UNSET_OPT
#define CHECK_UNSET_OPT(opt)
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:88
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:452
w
uint8_t w
Definition: llviddspenc.c:38
AVOption
AVOption.
Definition: opt.h:346
VAR_X
@ VAR_X
Definition: vf_delogo.c:49
DelogoContext::var_values
double var_values[VAR_VARS_NB]
Definition: vf_delogo.c:201
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:106
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
video.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
av_image_copy_plane
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:374
hsub
static void hsub(htype *dst, const htype *src, int bins)
Definition: vf_median.c:73
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:711
DelogoContext::x
int x
Definition: vf_delogo.c:198
avfilter_vf_delogo_inputs
static const AVFilterPad avfilter_vf_delogo_inputs[]
Definition: vf_delogo.c:374
interp
interp
Definition: vf_curves.c:61
VAR_N
@ VAR_N
Definition: vf_delogo.c:53
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_delogo.c:234
DelogoContext::x_expr
char * x_expr
Definition: vf_delogo.c:199
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:359
AVRational::num
int num
Numerator.
Definition: rational.h:59
VAR_W
@ VAR_W
Definition: vf_delogo.c:51
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
DelogoContext::h_pexpr
AVExpr * h_pexpr
Definition: vf_delogo.c:200
config_input
static int config_input(AVFilterLink *inlink)
Definition: vf_delogo.c:273
TS2T
#define TS2T(ts, tb)
Definition: internal.h:259
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
DelogoContext::x_pexpr
AVExpr * x_pexpr
Definition: vf_delogo.c:200
VAR_T
@ VAR_T
Definition: vf_delogo.c:54
ff_video_default_filterpad
const AVFilterPad ff_video_default_filterpad[1]
An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_VIDEO.
Definition: video.c:37
DelogoContext::band
int band
Definition: vf_delogo.c:198
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_delogo.c:287
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:108
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
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:793
AVExpr
Definition: eval.c:159
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
DelogoContext::w_expr
char * w_expr
Definition: vf_delogo.c:199
apply_delogo
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:97
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:182
DelogoContext::y
int y
Definition: vf_delogo.c:198
option
option
Definition: libkvazaar.c:320
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:637
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
weight
static int weight(int i, int blen, int offset)
Definition: diracdec.c:1562
FLAGS
#define FLAGS
Definition: vf_delogo.c:205
eval.h
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:106
DelogoContext
Definition: vf_delogo.c:196
DelogoContext::w
int w
Definition: vf_delogo.c:198
DelogoContext::h_expr
char * h_expr
Definition: vf_delogo.c:199
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:573
VAR_VARS_NB
@ VAR_VARS_NB
Definition: vf_delogo.c:55
DelogoContext::show
int show
Definition: vf_delogo.c:198
internal.h
AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
#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:147
VAR_Y
@ VAR_Y
Definition: vf_delogo.c:50
common.h
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
AVFilter
Filter definition.
Definition: avfilter.h:166
ret
ret
Definition: filter_design.txt:187
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_delogo.c:217
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:447
VAR_H
@ VAR_H
Definition: vf_delogo.c:52
U
#define U(x)
Definition: vpx_arith.h:37
AVRational::den
int den
Denominator.
Definition: rational.h:60
OFFSET
#define OFFSET(x)
Definition: vf_delogo.c:204
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
avfilter.h
DelogoContext::y_pexpr
AVExpr * y_pexpr
Definition: vf_delogo.c:200
delogo_options
static const AVOption delogo_options[]
Definition: vf_delogo.c:207
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
AVFilterContext
An instance of a filter.
Definition: avfilter.h:407
desc
const char * desc
Definition: libsvtav1.c:73
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
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
DelogoContext::w_pexpr
AVExpr * w_pexpr
Definition: vf_delogo.c:200
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:251
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:80
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: vf_delogo.c:227
DelogoContext::y_expr
char * y_expr
Definition: vf_delogo.c:199
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:385
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:79
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
h
h
Definition: vp9dsp_template.c:2038
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:239
var_names
static const char *const var_names[]
Definition: vf_delogo.c:38
set_expr
static int set_expr(AVExpr **pexpr, const char *expr, const char *option, void *log_ctx)
Definition: vf_delogo.c:58
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(delogo)