FFmpeg: libavfilter/vf_libopencv.c Source File

FFmpeg

[フレーム]

libavfilter

vf_libopencv.c

Go to the documentation of this file.

1 /*

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 */

21 /**

22 * @file

23 * libopencv wrapper functions

24 */

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"

44 static void fill_iplimage_from_frame(IplImage *img, const AVFrame *frame, enum AVPixelFormat pixfmt)

45 {

46 IplImage *tmpimg;

47 int depth, channels_nb;

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;

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 }

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 }

68 typedef struct OCVContext {

69 const AVClass *class;

70 char *name;

71 char *params;

72 int (*init)(AVFilterContext *ctx, const char *args);

73 void (*uninit)(AVFilterContext *ctx);

74 void (*end_frame_filter)(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg);

75 void *priv;

76 } OCVContext;

78 typedef struct SmoothContext {

79 int type;

80 int param1, param2;

81 double param3, param4;

82 } SmoothContext;

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";

90 smooth->param1 = 3;

91 smooth->param2 = 0;

92 smooth->param3 = 0.0;

93 smooth->param4 = 0.0;

95 if (args)

96 sscanf(args, "%127[^|]|%d|%d|%lf|%lf", type_str, &smooth->param1, &smooth->param2, &smooth->param3, &smooth->param4);

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)) {

109 av_log(ctx, AV_LOG_ERROR,

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)))) {

116 av_log(ctx, AV_LOG_ERROR,

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");

150 ret = AVERROR_INVALIDDATA;

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);

165 ret = AVERROR_INVALIDDATA;

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 {

258 int nb_iterations;

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

297 static av_cold void dilate_uninit(AVFilterContext *ctx)

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);

323 void (*uninit)(AVFilterContext *ctx);

324 void (*end_frame_filter)(AVFilterContext *ctx, IplImage *inimg, IplImage *outimg);

325 } OCVFilterEntry;

326

327 static const OCVFilterEntry ocv_filter_entries[] = {

328 { "dilate", sizeof(DilateContext), dilate_init, dilate_uninit, dilate_end_frame_filter },

329 { "erode", sizeof(DilateContext), dilate_init, dilate_uninit, erode_end_frame_filter },

330 { "smooth", sizeof(SmoothContext), smooth_init, NULL, smooth_end_frame_filter },

331 };

332

333 static av_cold int init(AVFilterContext *ctx)

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++) {

343 const OCVFilterEntry *entry = &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

359 static av_cold void uninit(AVFilterContext *ctx)

360 {

361 OCVContext *s = ctx->priv;

362

363 if (s->uninit)

364 s->uninit(ctx);

365 av_freep(&s->priv);

366 }

367

368 static int filter_frame(AVFilterLink *inlink, AVFrame *in)

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 }

381 av_frame_copy_props(out, in);

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

401 AVFILTER_DEFINE_CLASS(ocv);

402

403 static const AVFilterPad avfilter_vf_ocv_inputs[] = {

404 {

405 .name = "default",

406 .type = AVMEDIA_TYPE_VIDEO,

407 .filter_frame = filter_frame,

408 },

409 };

410

411 static const AVFilterPad avfilter_vf_ocv_outputs[] = {

412 {

413 .name = "default",

414 .type = AVMEDIA_TYPE_VIDEO,

415 },

416 };

417

418 const AVFilter ff_vf_ocv = {

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,

425 FILTER_INPUTS(avfilter_vf_ocv_inputs),

426 FILTER_OUTPUTS(avfilter_vf_ocv_outputs),

427 FILTER_PIXFMTS(AV_PIX_FMT_BGR24, AV_PIX_FMT_BGRA, AV_PIX_FMT_GRAY8),

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

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:1023

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

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:196

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

AVFilterLink

A link between two filters.

Definition: avfilter.h:557

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: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:333

#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:201

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: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:713

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

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

AVFilterLink::w

int w

agreed upon image width

Definition: avfilter.h:569

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

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

AVFilterLink::h

int h

agreed upon image height

Definition: avfilter.h:570

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

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

Generated on Fri Aug 22 2025 13:59:16 for FFmpeg by doxygen 1.8.17