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/opt.h"
38 #include "avfilter.h"
39 #include "formats.h"
40 #include "internal.h"
41 #include "video.h"
42 
43 static void fill_iplimage_from_frame(IplImage *img, const AVFrame *frame, enum AVPixelFormat pixfmt)
44 {
45  IplImage *tmpimg;
46  int depth, channels_nb;
47 
48  if (pixfmt == AV_PIX_FMT_GRAY8) { depth = IPL_DEPTH_8U; channels_nb = 1; }
49  else if (pixfmt == AV_PIX_FMT_BGRA) { depth = IPL_DEPTH_8U; channels_nb = 4; }
50  else if (pixfmt == AV_PIX_FMT_BGR24) { depth = IPL_DEPTH_8U; channels_nb = 3; }
51  else return;
52 
53  tmpimg = cvCreateImageHeader((CvSize){frame->width, frame->height}, depth, channels_nb);
54  *img = *tmpimg;
55  img->imageData = img->imageDataOrigin = frame->data[0];
56  img->dataOrder = IPL_DATA_ORDER_PIXEL;
57  img->origin = IPL_ORIGIN_TL;
58  img->widthStep = frame->linesize[0];
59 }
60 
61 static void fill_frame_from_iplimage(AVFrame *frame, const IplImage *img, enum AVPixelFormat pixfmt)
62 {
63  frame->linesize[0] = img->widthStep;
64  frame->data[0] = img->imageData;
65 }
66 
68 {
69  static const enum AVPixelFormat pix_fmts[] = {
71  };
73  if (!fmts_list)
74  return AVERROR(ENOMEM);
75  return ff_set_common_formats(ctx, fmts_list);
76 }
77 
78 typedef struct OCVContext {
79  const AVClass *class;
80  char *name;
81  char *params;
82  int (*init)(AVFilterContext *ctx, const char *args);
84  void (*end_frame_filter)(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg);
85  void *priv;
86 } OCVContext;
87 
88 typedef struct SmoothContext {
89  int type;
90  int param1, param2;
91  double param3, param4;
93 
94 static av_cold int smooth_init(AVFilterContext *ctx, const char *args)
95 {
96  OCVContext *s = ctx->priv;
97  SmoothContext *smooth = s->priv;
98  char type_str[128] = "gaussian";
99 
100  smooth->param1 = 3;
101  smooth->param2 = 0;
102  smooth->param3 = 0.0;
103  smooth->param4 = 0.0;
104 
105  if (args)
106  sscanf(args, "%127[^|]|%d|%d|%lf|%lf", type_str, &smooth->param1, &smooth->param2, &smooth->param3, &smooth->param4);
107 
108  if (!strcmp(type_str, "blur" )) smooth->type = CV_BLUR;
109  else if (!strcmp(type_str, "blur_no_scale")) smooth->type = CV_BLUR_NO_SCALE;
110  else if (!strcmp(type_str, "median" )) smooth->type = CV_MEDIAN;
111  else if (!strcmp(type_str, "gaussian" )) smooth->type = CV_GAUSSIAN;
112  else if (!strcmp(type_str, "bilateral" )) smooth->type = CV_BILATERAL;
113  else {
114  av_log(ctx, AV_LOG_ERROR, "Smoothing type '%s' unknown.\n", type_str);
115  return AVERROR(EINVAL);
116  }
117 
118  if (smooth->param1 < 0 || !(smooth->param1%2)) {
120  "Invalid value '%d' for param1, it has to be a positive odd number\n",
121  smooth->param1);
122  return AVERROR(EINVAL);
123  }
124  if ((smooth->type == CV_BLUR || smooth->type == CV_BLUR_NO_SCALE || smooth->type == CV_GAUSSIAN) &&
125  (smooth->param2 < 0 || (smooth->param2 && !(smooth->param2%2)))) {
127  "Invalid value '%d' for param2, it has to be zero or a positive odd number\n",
128  smooth->param2);
129  return AVERROR(EINVAL);
130  }
131 
132  av_log(ctx, AV_LOG_VERBOSE, "type:%s param1:%d param2:%d param3:%f param4:%f\n",
133  type_str, smooth->param1, smooth->param2, smooth->param3, smooth->param4);
134  return 0;
135 }
136 
137 static void smooth_end_frame_filter(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg)
138 {
139  OCVContext *s = ctx->priv;
140  SmoothContext *smooth = s->priv;
141  cvSmooth(inimg, outimg, smooth->type, smooth->param1, smooth->param2, smooth->param3, smooth->param4);
142 }
143 
144 static int read_shape_from_file(int *cols, int *rows, int **values, const char *filename,
145  void *log_ctx)
146 {
147  uint8_t *buf, *p, *pend;
148  size_t size;
149  int ret, i, j, w;
150 
151  if ((ret = av_file_map(filename, &buf, &size, 0, log_ctx)) < 0)
152  return ret;
153 
154  /* prescan file to get the number of lines and the maximum width */
155  w = 0;
156  for (i = 0; i < size; i++) {
157  if (buf[i] == '\n') {
158  if (*rows == INT_MAX) {
159  av_log(log_ctx, AV_LOG_ERROR, "Overflow on the number of rows in the file\n");
161  goto end;
162  }
163  ++(*rows);
164  *cols = FFMAX(*cols, w);
165  w = 0;
166  } else if (w == INT_MAX) {
167  av_log(log_ctx, AV_LOG_ERROR, "Overflow on the number of columns in the file\n");
168  return AVERROR_INVALIDDATA;
169  }
170  w++;
171  }
172  if (*rows > (SIZE_MAX / sizeof(int) / *cols)) {
173  av_log(log_ctx, AV_LOG_ERROR, "File with size %dx%d is too big\n",
174  *rows, *cols);
176  goto end;
177  }
178  if (!(*values = av_mallocz_array(sizeof(int) * *rows, *cols))) {
179  ret = AVERROR(ENOMEM);
180  goto end;
181  }
182 
183  /* fill *values */
184  p = buf;
185  pend = buf + size-1;
186  for (i = 0; i < *rows; i++) {
187  for (j = 0;; j++) {
188  if (p > pend || *p == '\n') {
189  p++;
190  break;
191  } else
192  (*values)[*cols*i + j] = !!av_isgraph(*(p++));
193  }
194  }
195 
196 end:
197  av_file_unmap(buf, size);
198 
199 #ifdef DEBUG
200  {
201  char *line;
202  if (!(line = av_malloc(*cols + 1)))
203  return AVERROR(ENOMEM);
204  for (i = 0; i < *rows; i++) {
205  for (j = 0; j < *cols; j++)
206  line[j] = (*values)[i * *cols + j] ? '@' : ' ';
207  line[j] = 0;
208  av_log(log_ctx, AV_LOG_DEBUG, "%3d: %s\n", i, line);
209  }
210  av_free(line);
211  }
212 #endif
213 
214  return 0;
215 }
216 
217 static int parse_iplconvkernel(IplConvKernel **kernel, char *buf, void *log_ctx)
218 {
219  char shape_filename[128] = "", shape_str[32] = "rect";
220  int cols = 0, rows = 0, anchor_x = 0, anchor_y = 0, shape = CV_SHAPE_RECT;
221  int *values = NULL, ret = 0;
222 
223  sscanf(buf, "%dx%d+%dx%d/%32[^=]=%127s", &cols, &rows, &anchor_x, &anchor_y, shape_str, shape_filename);
224 
225  if (!strcmp(shape_str, "rect" )) shape = CV_SHAPE_RECT;
226  else if (!strcmp(shape_str, "cross" )) shape = CV_SHAPE_CROSS;
227  else if (!strcmp(shape_str, "ellipse")) shape = CV_SHAPE_ELLIPSE;
228  else if (!strcmp(shape_str, "custom" )) {
229  shape = CV_SHAPE_CUSTOM;
230  if ((ret = read_shape_from_file(&cols, &rows, &values, shape_filename, log_ctx)) < 0)
231  return ret;
232  } else {
233  av_log(log_ctx, AV_LOG_ERROR,
234  "Shape unspecified or type '%s' unknown.\n", shape_str);
235  ret = AVERROR(EINVAL);
236  goto out;
237  }
238 
239  if (rows <= 0 || cols <= 0) {
240  av_log(log_ctx, AV_LOG_ERROR,
241  "Invalid non-positive values for shape size %dx%d\n", cols, rows);
242  ret = AVERROR(EINVAL);
243  goto out;
244  }
245 
246  if (anchor_x < 0 || anchor_y < 0 || anchor_x >= cols || anchor_y >= rows) {
247  av_log(log_ctx, AV_LOG_ERROR,
248  "Shape anchor %dx%d is not inside the rectangle with size %dx%d.\n",
249  anchor_x, anchor_y, cols, rows);
250  ret = AVERROR(EINVAL);
251  goto out;
252  }
253 
254  *kernel = cvCreateStructuringElementEx(cols, rows, anchor_x, anchor_y, shape, values);
255  if (!*kernel) {
256  ret = AVERROR(ENOMEM);
257  goto out;
258  }
259 
260  av_log(log_ctx, AV_LOG_VERBOSE, "Structuring element: w:%d h:%d x:%d y:%d shape:%s\n",
261  rows, cols, anchor_x, anchor_y, shape_str);
262 out:
263  av_freep(&values);
264  return ret;
265 }
266 
267 typedef struct DilateContext {
269  IplConvKernel *kernel;
270 } DilateContext;
271 
272 static av_cold int dilate_init(AVFilterContext *ctx, const char *args)
273 {
274  OCVContext *s = ctx->priv;
275  DilateContext *dilate = s->priv;
276  char default_kernel_str[] = "3x3+0x0/rect";
277  char *kernel_str = NULL;
278  const char *buf = args;
279  int ret;
280 
281  if (args) {
282  kernel_str = av_get_token(&buf, "|");
283 
284  if (!kernel_str)
285  return AVERROR(ENOMEM);
286  }
287 
288  ret = parse_iplconvkernel(&dilate->kernel,
289  (!kernel_str || !*kernel_str) ? default_kernel_str
290  : kernel_str,
291  ctx);
292  av_free(kernel_str);
293  if (ret < 0)
294  return ret;
295 
296  if (!buf || sscanf(buf, "|%d", &dilate->nb_iterations) != 1)
297  dilate->nb_iterations = 1;
298  av_log(ctx, AV_LOG_VERBOSE, "iterations_nb:%d\n", dilate->nb_iterations);
299  if (dilate->nb_iterations <= 0) {
300  av_log(ctx, AV_LOG_ERROR, "Invalid non-positive value '%d' for nb_iterations\n",
301  dilate->nb_iterations);
302  return AVERROR(EINVAL);
303  }
304  return 0;
305 }
306 
308 {
309  OCVContext *s = ctx->priv;
310  DilateContext *dilate = s->priv;
311 
312  cvReleaseStructuringElement(&dilate->kernel);
313 }
314 
315 static void dilate_end_frame_filter(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg)
316 {
317  OCVContext *s = ctx->priv;
318  DilateContext *dilate = s->priv;
319  cvDilate(inimg, outimg, dilate->kernel, dilate->nb_iterations);
320 }
321 
322 static void erode_end_frame_filter(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg)
323 {
324  OCVContext *s = ctx->priv;
325  DilateContext *dilate = s->priv;
326  cvErode(inimg, outimg, dilate->kernel, dilate->nb_iterations);
327 }
328 
329 typedef struct OCVFilterEntry {
330  const char *name;
331  size_t priv_size;
332  int (*init)(AVFilterContext *ctx, const char *args);
334  void (*end_frame_filter)(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg);
336 
340  { "smooth", sizeof(SmoothContext), smooth_init, NULL, smooth_end_frame_filter },
341 };
342 
344 {
345  OCVContext *s = ctx->priv;
346  int i;
347 
348  if (!s->name) {
349  av_log(ctx, AV_LOG_ERROR, "No libopencv filter name specified\n");
350  return AVERROR(EINVAL);
351  }
352  for (i = 0; i < FF_ARRAY_ELEMS(ocv_filter_entries); i++) {
353  const OCVFilterEntry *entry = &ocv_filter_entries[i];
354  if (!strcmp(s->name, entry->name)) {
355  s->init = entry->init;
356  s->uninit = entry->uninit;
357  s->end_frame_filter = entry->end_frame_filter;
358 
359  if (!(s->priv = av_mallocz(entry->priv_size)))
360  return AVERROR(ENOMEM);
361  return s->init(ctx, s->params);
362  }
363  }
364 
365  av_log(ctx, AV_LOG_ERROR, "No libopencv filter named '%s'\n", s->name);
366  return AVERROR(EINVAL);
367 }
368 
370 {
371  OCVContext *s = ctx->priv;
372 
373  if (s->uninit)
374  s->uninit(ctx);
375  av_freep(&s->priv);
376 }
377 
379 {
380  AVFilterContext *ctx = inlink->dst;
381  OCVContext *s = ctx->priv;
382  AVFilterLink *outlink= inlink->dst->outputs[0];
383  AVFrame *out;
384  IplImage inimg, outimg;
385 
386  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
387  if (!out) {
388  av_frame_free(&in);
389  return AVERROR(ENOMEM);
390  }
392 
393  fill_iplimage_from_frame(&inimg , in , inlink->format);
394  fill_iplimage_from_frame(&outimg, out, inlink->format);
395  s->end_frame_filter(ctx, &inimg, &outimg);
396  fill_frame_from_iplimage(out, &outimg, inlink->format);
397 
398  av_frame_free(&in);
399 
400  return ff_filter_frame(outlink, out);
401 }
402 
403 #define OFFSET(x) offsetof(OCVContext, x)
404 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
405 static const AVOption ocv_options[] = {
406  { "filter_name", NULL, OFFSET(name), AV_OPT_TYPE_STRING, .flags = FLAGS },
407  { "filter_params", NULL, OFFSET(params), AV_OPT_TYPE_STRING, .flags = FLAGS },
408  { NULL }
409 };
410 
412 
414  {
415  .name = "default",
416  .type = AVMEDIA_TYPE_VIDEO,
417  .filter_frame = filter_frame,
418  },
419  { NULL }
420 };
421 
423  {
424  .name = "default",
425  .type = AVMEDIA_TYPE_VIDEO,
426  },
427  { NULL }
428 };
429 
431  .name = "ocv",
432  .description = NULL_IF_CONFIG_SMALL("Apply transform using libopencv."),
433  .priv_size = sizeof(OCVContext),
434  .priv_class = &ocv_class,
436  .init = init,
437  .uninit = uninit,
440 };
SmoothContext
Definition: vf_libopencv.c:88
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:97
OCVFilterEntry::priv_size
size_t priv_size
Definition: vf_libopencv.c:331
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
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:404
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
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:286
out
FILE * out
Definition: movenc.c:54
parse_iplconvkernel
static int parse_iplconvkernel(IplConvKernel **kernel, char *buf, void *log_ctx)
Definition: vf_libopencv.c:217
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:151
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:978
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:112
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
w
uint8_t w
Definition: llviddspenc.c:38
AVOption
AVOption.
Definition: opt.h:247
DilateContext
Definition: vf_libopencv.c:267
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:196
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
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
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:149
video.h
OCVFilterEntry
Definition: vf_libopencv.c:329
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
formats.h
OCVContext
Definition: vf_libopencv.c:78
OFFSET
#define OFFSET(x)
Definition: vf_libopencv.c:403
dilate_uninit
static av_cold void dilate_uninit(AVFilterContext *ctx)
Definition: vf_libopencv.c:307
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:53
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(ocv)
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
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
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_libopencv.c:343
s
#define s(width, name)
Definition: cbs_vp9.c:257
SmoothContext::param4
double param4
Definition: vf_libopencv.c:91
OCVFilterEntry::init
int(* init)(AVFilterContext *ctx, const char *args)
Definition: vf_libopencv.c:332
smooth_end_frame_filter
static void smooth_end_frame_filter(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg)
Definition: vf_libopencv.c:137
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_libopencv.c:378
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
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_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:144
SmoothContext::param3
double param3
Definition: vf_libopencv.c:91
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:537
avfilter_vf_ocv_outputs
static const AVFilterPad avfilter_vf_ocv_outputs[]
Definition: vf_libopencv.c:422
DilateContext::kernel
IplConvKernel * kernel
Definition: vf_libopencv.c:269
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
OCVContext::priv
void * priv
Definition: vf_libopencv.c:85
OCVFilterEntry::uninit
void(* uninit)(AVFilterContext *ctx)
Definition: vf_libopencv.c:333
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
OCVContext::init
int(* init)(AVFilterContext *ctx, const char *args)
Definition: vf_libopencv.c:82
dilate_init
static av_cold int dilate_init(AVFilterContext *ctx, const char *args)
Definition: vf_libopencv.c:272
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:43
OCVContext::params
char * params
Definition: vf_libopencv.c:81
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_libopencv.c:369
av_isgraph
static av_const int av_isgraph(int c)
Locale-independent conversion of ASCII isgraph.
Definition: avstring.h:219
img
#define img
Definition: vf_colormatrix.c:116
erode_end_frame_filter
static void erode_end_frame_filter(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg)
Definition: vf_libopencv.c:322
line
Definition: graph2dot.c:48
SmoothContext::param2
int param2
Definition: vf_libopencv.c:90
dilate_end_frame_filter
static void dilate_end_frame_filter(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg)
Definition: vf_libopencv.c:315
internal.h
i
int i
Definition: input.c:406
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:243
OCVFilterEntry::name
const char * name
Definition: vf_libopencv.c:330
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
SmoothContext::param1
int param1
Definition: vf_libopencv.c:90
smooth
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
Definition: vf_deshake_opencl.c:903
AVFilter
Filter definition.
Definition: avfilter.h:145
ret
ret
Definition: filter_design.txt:187
pixfmt
enum AVPixelFormat pixfmt
Definition: kmsgrab.c:365
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
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_libopencv.c:67
fill_frame_from_iplimage
static void fill_frame_from_iplimage(AVFrame *frame, const IplImage *img, enum AVPixelFormat pixfmt)
Definition: vf_libopencv.c:61
DilateContext::nb_iterations
int nb_iterations
Definition: vf_libopencv.c:268
avfilter_vf_ocv_inputs
static const AVFilterPad avfilter_vf_ocv_inputs[]
Definition: vf_libopencv.c:413
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
avfilter.h
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:83
AVFilterContext
An instance of a filter.
Definition: avfilter.h:333
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:334
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:144
ff_vf_ocv
const AVFilter ff_vf_ocv
Definition: vf_libopencv.c:430
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
OCVContext::end_frame_filter
void(* end_frame_filter)(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg)
Definition: vf_libopencv.c:84
SmoothContext::type
int type
Definition: vf_libopencv.c:89
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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:337
avstring.h
smooth_init
static av_cold int smooth_init(AVFilterContext *ctx, const char *args)
Definition: vf_libopencv.c:94
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:228
OCVContext::name
char * name
Definition: vf_libopencv.c:80
int
int
Definition: ffmpeg_filter.c:156
ocv_options
static const AVOption ocv_options[]
Definition: vf_libopencv.c:405
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