FFmpeg: libavfilter/vf_libopencv.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /