FFmpeg
vf_libopencv.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2010 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  * libopencv wrapper functions
24  */
25 
26 #include "config.h"
27 #if HAVE_OPENCV2_CORE_CORE_C_H
28 #include <opencv2/core/core_c.h>
29 #include <opencv2/imgproc/imgproc_c.h>
30 #else
31 #include <opencv/cv.h>
32 #include <opencv/cxcore.h>
33 #endif
34 #include "libavutil/avstring.h"
35 #include "libavutil/common.h"
36 #include "libavutil/file.h"
37 #include "libavutil/mem.h"
38 #include "libavutil/opt.h"
39 #include "avfilter.h"
40 #include "filters.h"
41 #include "formats.h"
42 #include "video.h"
43 
44 static void fill_iplimage_from_frame(IplImage *img, const AVFrame *frame, enum AVPixelFormat pixfmt)
45 {
46  IplImage *tmpimg;
47  int depth, channels_nb;
48 
49  if (pixfmt == AV_PIX_FMT_GRAY8) { depth = IPL_DEPTH_8U; channels_nb = 1; }
50  else if (pixfmt == AV_PIX_FMT_BGRA) { depth = IPL_DEPTH_8U; channels_nb = 4; }
51  else if (pixfmt == AV_PIX_FMT_BGR24) { depth = IPL_DEPTH_8U; channels_nb = 3; }
52  else return;
53 
54  tmpimg = cvCreateImageHeader((CvSize){frame->width, frame->height}, depth, channels_nb);
55  *img = *tmpimg;
56  img->imageData = img->imageDataOrigin = frame->data[0];
57  img->dataOrder = IPL_DATA_ORDER_PIXEL;
58  img->origin = IPL_ORIGIN_TL;
59  img->widthStep = frame->linesize[0];
60 }
61 
62 static void fill_frame_from_iplimage(AVFrame *frame, const IplImage *img, enum AVPixelFormat pixfmt)
63 {
64  frame->linesize[0] = img->widthStep;
65  frame->data[0] = img->imageData;
66 }
67 
68 typedef struct OCVContext {
69  const AVClass *class;
70  char *name;
71  char *params;
72  int (*init)(AVFilterContext *ctx, const char *args);
74  void (*end_frame_filter)(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg);
75  void *priv;
76 } OCVContext;
77 
78 typedef struct SmoothContext {
79  int type;
80  int param1, param2;
81  double param3, param4;
83 
84 static av_cold int smooth_init(AVFilterContext *ctx, const char *args)
85 {
86  OCVContext *s = ctx->priv;
87  SmoothContext *smooth = s->priv;
88  char type_str[128] = "gaussian";
89 
90  smooth->param1 = 3;
91  smooth->param2 = 0;
92  smooth->param3 = 0.0;
93  smooth->param4 = 0.0;
94 
95  if (args)
96  sscanf(args, "%127[^|]|%d|%d|%lf|%lf", type_str, &smooth->param1, &smooth->param2, &smooth->param3, &smooth->param4);
97 
98  if (!strcmp(type_str, "blur" )) smooth->type = CV_BLUR;
99  else if (!strcmp(type_str, "blur_no_scale")) smooth->type = CV_BLUR_NO_SCALE;
100  else if (!strcmp(type_str, "median" )) smooth->type = CV_MEDIAN;
101  else if (!strcmp(type_str, "gaussian" )) smooth->type = CV_GAUSSIAN;
102  else if (!strcmp(type_str, "bilateral" )) smooth->type = CV_BILATERAL;
103  else {
104  av_log(ctx, AV_LOG_ERROR, "Smoothing type '%s' unknown.\n", type_str);
105  return AVERROR(EINVAL);
106  }
107 
108  if (smooth->param1 < 0 || !(smooth->param1%2)) {
110  "Invalid value '%d' for param1, it has to be a positive odd number\n",
111  smooth->param1);
112  return AVERROR(EINVAL);
113  }
114  if ((smooth->type == CV_BLUR || smooth->type == CV_BLUR_NO_SCALE || smooth->type == CV_GAUSSIAN) &&
115  (smooth->param2 < 0 || (smooth->param2 && !(smooth->param2%2)))) {
117  "Invalid value '%d' for param2, it has to be zero or a positive odd number\n",
118  smooth->param2);
119  return AVERROR(EINVAL);
120  }
121 
122  av_log(ctx, AV_LOG_VERBOSE, "type:%s param1:%d param2:%d param3:%f param4:%f\n",
123  type_str, smooth->param1, smooth->param2, smooth->param3, smooth->param4);
124  return 0;
125 }
126 
127 static void smooth_end_frame_filter(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg)
128 {
129  OCVContext *s = ctx->priv;
130  SmoothContext *smooth = s->priv;
131  cvSmooth(inimg, outimg, smooth->type, smooth->param1, smooth->param2, smooth->param3, smooth->param4);
132 }
133 
134 static int read_shape_from_file(int *cols, int *rows, int **values, const char *filename,
135  void *log_ctx)
136 {
137  uint8_t *buf, *p, *pend;
138  size_t size;
139  int ret, i, j, w;
140 
141  if ((ret = av_file_map(filename, &buf, &size, 0, log_ctx)) < 0)
142  return ret;
143 
144  /* prescan file to get the number of lines and the maximum width */
145  w = 0;
146  for (i = 0; i < size; i++) {
147  if (buf[i] == '\n') {
148  if (*rows == INT_MAX) {
149  av_log(log_ctx, AV_LOG_ERROR, "Overflow on the number of rows in the file\n");
151  goto end;
152  }
153  ++(*rows);
154  *cols = FFMAX(*cols, w);
155  w = 0;
156  } else if (w == INT_MAX) {
157  av_log(log_ctx, AV_LOG_ERROR, "Overflow on the number of columns in the file\n");
158  return AVERROR_INVALIDDATA;
159  }
160  w++;
161  }
162  if (*rows > (SIZE_MAX / sizeof(int) / *cols)) {
163  av_log(log_ctx, AV_LOG_ERROR, "File with size %dx%d is too big\n",
164  *rows, *cols);
166  goto end;
167  }
168  if (!(*values = av_calloc(sizeof(int) * *rows, *cols))) {
169  ret = AVERROR(ENOMEM);
170  goto end;
171  }
172 
173  /* fill *values */
174  p = buf;
175  pend = buf + size-1;
176  for (i = 0; i < *rows; i++) {
177  for (j = 0;; j++) {
178  if (p > pend || *p == '\n') {
179  p++;
180  break;
181  } else
182  (*values)[*cols*i + j] = !!av_isgraph(*(p++));
183  }
184  }
185 
186 end:
187  av_file_unmap(buf, size);
188 
189 #ifdef DEBUG
190  {
191  char *line;
192  if (!(line = av_malloc(*cols + 1)))
193  return AVERROR(ENOMEM);
194  for (i = 0; i < *rows; i++) {
195  for (j = 0; j < *cols; j++)
196  line[j] = (*values)[i * *cols + j] ? '@' : ' ';
197  line[j] = 0;
198  av_log(log_ctx, AV_LOG_DEBUG, "%3d: %s\n", i, line);
199  }
200  av_free(line);
201  }
202 #endif
203 
204  return 0;
205 }
206 
207 static int parse_iplconvkernel(IplConvKernel **kernel, char *buf, void *log_ctx)
208 {
209  char shape_filename[128] = "", shape_str[32] = "rect";
210  int cols = 0, rows = 0, anchor_x = 0, anchor_y = 0, shape = CV_SHAPE_RECT;
211  int *values = NULL, ret = 0;
212 
213  sscanf(buf, "%dx%d+%dx%d/%32[^=]=%127s", &cols, &rows, &anchor_x, &anchor_y, shape_str, shape_filename);
214 
215  if (!strcmp(shape_str, "rect" )) shape = CV_SHAPE_RECT;
216  else if (!strcmp(shape_str, "cross" )) shape = CV_SHAPE_CROSS;
217  else if (!strcmp(shape_str, "ellipse")) shape = CV_SHAPE_ELLIPSE;
218  else if (!strcmp(shape_str, "custom" )) {
219  shape = CV_SHAPE_CUSTOM;
220  if ((ret = read_shape_from_file(&cols, &rows, &values, shape_filename, log_ctx)) < 0)
221  return ret;
222  } else {
223  av_log(log_ctx, AV_LOG_ERROR,
224  "Shape unspecified or type '%s' unknown.\n", shape_str);
225  ret = AVERROR(EINVAL);
226  goto out;
227  }
228 
229  if (rows <= 0 || cols <= 0) {
230  av_log(log_ctx, AV_LOG_ERROR,
231  "Invalid non-positive values for shape size %dx%d\n", cols, rows);
232  ret = AVERROR(EINVAL);
233  goto out;
234  }
235 
236  if (anchor_x < 0 || anchor_y < 0 || anchor_x >= cols || anchor_y >= rows) {
237  av_log(log_ctx, AV_LOG_ERROR,
238  "Shape anchor %dx%d is not inside the rectangle with size %dx%d.\n",
239  anchor_x, anchor_y, cols, rows);
240  ret = AVERROR(EINVAL);
241  goto out;
242  }
243 
244  *kernel = cvCreateStructuringElementEx(cols, rows, anchor_x, anchor_y, shape, values);
245  if (!*kernel) {
246  ret = AVERROR(ENOMEM);
247  goto out;
248  }
249 
250  av_log(log_ctx, AV_LOG_VERBOSE, "Structuring element: w:%d h:%d x:%d y:%d shape:%s\n",
251  rows, cols, anchor_x, anchor_y, shape_str);
252 out:
253  av_freep(&values);
254  return ret;
255 }
256 
257 typedef struct DilateContext {
259  IplConvKernel *kernel;
260 } DilateContext;
261 
262 static av_cold int dilate_init(AVFilterContext *ctx, const char *args)
263 {
264  OCVContext *s = ctx->priv;
265  DilateContext *dilate = s->priv;
266  char default_kernel_str[] = "3x3+0x0/rect";
267  char *kernel_str = NULL;
268  const char *buf = args;
269  int ret;
270 
271  if (args) {
272  kernel_str = av_get_token(&buf, "|");
273 
274  if (!kernel_str)
275  return AVERROR(ENOMEM);
276  }
277 
278  ret = parse_iplconvkernel(&dilate->kernel,
279  (!kernel_str || !*kernel_str) ? default_kernel_str
280  : kernel_str,
281  ctx);
282  av_free(kernel_str);
283  if (ret < 0)
284  return ret;
285 
286  if (!buf || sscanf(buf, "|%d", &dilate->nb_iterations) != 1)
287  dilate->nb_iterations = 1;
288  av_log(ctx, AV_LOG_VERBOSE, "iterations_nb:%d\n", dilate->nb_iterations);
289  if (dilate->nb_iterations <= 0) {
290  av_log(ctx, AV_LOG_ERROR, "Invalid non-positive value '%d' for nb_iterations\n",
291  dilate->nb_iterations);
292  return AVERROR(EINVAL);
293  }
294  return 0;
295 }
296 
298 {
299  OCVContext *s = ctx->priv;
300  DilateContext *dilate = s->priv;
301 
302  cvReleaseStructuringElement(&dilate->kernel);
303 }
304 
305 static void dilate_end_frame_filter(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg)
306 {
307  OCVContext *s = ctx->priv;
308  DilateContext *dilate = s->priv;
309  cvDilate(inimg, outimg, dilate->kernel, dilate->nb_iterations);
310 }
311 
312 static void erode_end_frame_filter(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg)
313 {
314  OCVContext *s = ctx->priv;
315  DilateContext *dilate = s->priv;
316  cvErode(inimg, outimg, dilate->kernel, dilate->nb_iterations);
317 }
318 
319 typedef struct OCVFilterEntry {
320  const char *name;
321  size_t priv_size;
322  int (*init)(AVFilterContext *ctx, const char *args);
324  void (*end_frame_filter)(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg);
326 
330  { "smooth", sizeof(SmoothContext), smooth_init, NULL, smooth_end_frame_filter },
331 };
332 
334 {
335  OCVContext *s = ctx->priv;
336  int i;
337 
338  if (!s->name) {
339  av_log(ctx, AV_LOG_ERROR, "No libopencv filter name specified\n");
340  return AVERROR(EINVAL);
341  }
342  for (i = 0; i < FF_ARRAY_ELEMS(ocv_filter_entries); i++) {
344  if (!strcmp(s->name, entry->name)) {
345  s->init = entry->init;
346  s->uninit = entry->uninit;
347  s->end_frame_filter = entry->end_frame_filter;
348 
349  if (!(s->priv = av_mallocz(entry->priv_size)))
350  return AVERROR(ENOMEM);
351  return s->init(ctx, s->params);
352  }
353  }
354 
355  av_log(ctx, AV_LOG_ERROR, "No libopencv filter named '%s'\n", s->name);
356  return AVERROR(EINVAL);
357 }
358 
360 {
361  OCVContext *s = ctx->priv;
362 
363  if (s->uninit)
364  s->uninit(ctx);
365  av_freep(&s->priv);
366 }
367 
369 {
370  AVFilterContext *ctx = inlink->dst;
371  OCVContext *s = ctx->priv;
372  AVFilterLink *outlink= inlink->dst->outputs[0];
373  AVFrame *out;
374  IplImage inimg, outimg;
375 
376  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
377  if (!out) {
378  av_frame_free(&in);
379  return AVERROR(ENOMEM);
380  }
382 
383  fill_iplimage_from_frame(&inimg , in , inlink->format);
384  fill_iplimage_from_frame(&outimg, out, inlink->format);
385  s->end_frame_filter(ctx, &inimg, &outimg);
386  fill_frame_from_iplimage(out, &outimg, inlink->format);
387 
388  av_frame_free(&in);
389 
390  return ff_filter_frame(outlink, out);
391 }
392 
393 #define OFFSET(x) offsetof(OCVContext, x)
394 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
395 static const AVOption ocv_options[] = {
396  { "filter_name", NULL, OFFSET(name), AV_OPT_TYPE_STRING, .flags = FLAGS },
397  { "filter_params", NULL, OFFSET(params), AV_OPT_TYPE_STRING, .flags = FLAGS },
398  { NULL }
399 };
400 
402 
404  {
405  .name = "default",
406  .type = AVMEDIA_TYPE_VIDEO,
407  .filter_frame = filter_frame,
408  },
409 };
410 
412  {
413  .name = "default",
414  .type = AVMEDIA_TYPE_VIDEO,
415  },
416 };
417 
419  .name = "ocv",
420  .description = NULL_IF_CONFIG_SMALL("Apply transform using libopencv."),
421  .priv_size = sizeof(OCVContext),
422  .priv_class = &ocv_class,
423  .init = init,
424  .uninit = uninit,
428 };
SmoothContext
Definition: vf_libopencv.c:78
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:116
OCVFilterEntry::priv_size
size_t priv_size
Definition: vf_libopencv.c:321
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
FLAGS
#define FLAGS
Definition: vf_libopencv.c:394
entry
#define entry
Definition: aom_film_grain_template.c:66
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
out
FILE * out
Definition: movenc.c:55
parse_iplconvkernel
static int parse_iplconvkernel(IplConvKernel **kernel, char *buf, void *log_ctx)
Definition: vf_libopencv.c:207
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1061
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_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:162
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: filters.h:262
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
w
uint8_t w
Definition: llviddspenc.c:38
AVOption
AVOption.
Definition: opt.h:429
DilateContext
Definition: vf_libopencv.c:257
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
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
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:205
video.h
OCVFilterEntry
Definition: vf_libopencv.c:319
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
formats.h
OCVContext
Definition: vf_libopencv.c:68
OFFSET
#define OFFSET(x)
Definition: vf_libopencv.c:393
dilate_uninit
static av_cold void dilate_uninit(AVFilterContext *ctx)
Definition: vf_libopencv.c:297
av_file_map
int av_file_map(const char *filename, uint8_t **bufptr, size_t *size, int log_offset, void *log_ctx)
Read the file with name filename, and put its content in a newly allocated buffer or map it with mmap...
Definition: file.c:55
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(ocv)
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:38
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_libopencv.c:333
s
#define s(width, name)
Definition: cbs_vp9.c:198
SmoothContext::param4
double param4
Definition: vf_libopencv.c:81
OCVFilterEntry::init
int(* init)(AVFilterContext *ctx, const char *args)
Definition: vf_libopencv.c:322
smooth_end_frame_filter
static void smooth_end_frame_filter(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg)
Definition: vf_libopencv.c:127
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_libopencv.c:368
filters.h
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
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: filters.h:263
av_file_unmap
void av_file_unmap(uint8_t *bufptr, size_t size)
Unmap or free the buffer bufptr created by av_file_map().
Definition: file.c:142
SmoothContext::param3
double param3
Definition: vf_libopencv.c:81
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
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:725
avfilter_vf_ocv_outputs
static const AVFilterPad avfilter_vf_ocv_outputs[]
Definition: vf_libopencv.c:411
DilateContext::kernel
IplConvKernel * kernel
Definition: vf_libopencv.c:259
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
OCVContext::priv
void * priv
Definition: vf_libopencv.c:75
OCVFilterEntry::uninit
void(* uninit)(AVFilterContext *ctx)
Definition: vf_libopencv.c:323
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
OCVContext::init
int(* init)(AVFilterContext *ctx, const char *args)
Definition: vf_libopencv.c:72
dilate_init
static av_cold int dilate_init(AVFilterContext *ctx, const char *args)
Definition: vf_libopencv.c:262
size
int size
Definition: twinvq_data.h:10344
fill_iplimage_from_frame
static void fill_iplimage_from_frame(IplImage *img, const AVFrame *frame, enum AVPixelFormat pixfmt)
Definition: vf_libopencv.c:44
OCVContext::params
char * params
Definition: vf_libopencv.c:71
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_libopencv.c:359
av_isgraph
static av_const int av_isgraph(int c)
Locale-independent conversion of ASCII isgraph.
Definition: avstring.h:210
img
#define img
Definition: vf_colormatrix.c:114
erode_end_frame_filter
static void erode_end_frame_filter(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg)
Definition: vf_libopencv.c:312
line
Definition: graph2dot.c:48
SmoothContext::param2
int param2
Definition: vf_libopencv.c:80
dilate_end_frame_filter
static void dilate_end_frame_filter(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg)
Definition: vf_libopencv.c:305
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
common.h
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
OCVFilterEntry::name
const char * name
Definition: vf_libopencv.c:320
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:44
SmoothContext::param1
int param1
Definition: vf_libopencv.c:80
FILTER_PIXFMTS
#define FILTER_PIXFMTS(...)
Definition: filters.h:248
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
AVFilter
Filter definition.
Definition: avfilter.h:201
ret
ret
Definition: filter_design.txt:187
pixfmt
enum AVPixelFormat pixfmt
Definition: kmsgrab.c:367
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
fill_frame_from_iplimage
static void fill_frame_from_iplimage(AVFrame *frame, const IplImage *img, enum AVPixelFormat pixfmt)
Definition: vf_libopencv.c:62
DilateContext::nb_iterations
int nb_iterations
Definition: vf_libopencv.c:258
avfilter_vf_ocv_inputs
static const AVFilterPad avfilter_vf_ocv_inputs[]
Definition: vf_libopencv.c:403
avfilter.h
av_get_token
char * av_get_token(const char **buf, const char *term)
Unescape the given string until a non escaped terminating char, and return the token corresponding to...
Definition: avstring.c:143
values
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 values
Definition: filter_design.txt:263
file.h
OCVContext::uninit
void(* uninit)(AVFilterContext *ctx)
Definition: vf_libopencv.c:73
AVFilterContext
An instance of a filter.
Definition: avfilter.h:457
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
OCVFilterEntry::end_frame_filter
void(* end_frame_filter)(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg)
Definition: vf_libopencv.c:324
read_shape_from_file
static int read_shape_from_file(int *cols, int *rows, int **values, const char *filename, void *log_ctx)
Definition: vf_libopencv.c:134
mem.h
ff_vf_ocv
const AVFilter ff_vf_ocv
Definition: vf_libopencv.c:418
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
smooth
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifo *values)
Definition: vf_deshake_opencl.c:887
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
OCVContext::end_frame_filter
void(* end_frame_filter)(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg)
Definition: vf_libopencv.c:74
SmoothContext::type
int type
Definition: vf_libopencv.c:79
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ocv_filter_entries
static const OCVFilterEntry ocv_filter_entries[]
Definition: vf_libopencv.c:327
dilate
static int dilate(IPlane *g, IPlane *f, chord_set *SE, LUT *Ty, int y0, int y1)
Definition: vf_morpho.c:465
avstring.h
smooth_init
static av_cold int smooth_init(AVFilterContext *ctx, const char *args)
Definition: vf_libopencv.c:84
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:276
OCVContext::name
char * name
Definition: vf_libopencv.c:70
ocv_options
static const AVOption ocv_options[]
Definition: vf_libopencv.c:395
line
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted line
Definition: swscale.txt:40