FFmpeg: libavfilter/vf_lut2.c Source File

FFmpeg

[フレーム]

libavfilter

vf_lut2.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 #include "config_components.h"

23 #include "libavutil/attributes.h"

24 #include "libavutil/common.h"

25 #include "libavutil/eval.h"

26 #include "libavutil/mem.h"

27 #include "libavutil/opt.h"

28 #include "libavutil/pixdesc.h"

29 #include "avfilter.h"

30 #include "filters.h"

31 #include "formats.h"

32 #include "video.h"

33 #include "framesync.h"

35 static const char *const var_names[] = {

36 "w", ///< width of the input video

37 "h", ///< height of the input video

38 "x", ///< input value for the pixel from input #1

39 "y", ///< input value for the pixel from input #2

40 "bdx", ///< input #1 video bitdepth

41 "bdy", ///< input #2 video bitdepth

42 NULL

43 };

45 enum var_name {

46 VAR_W,

47 VAR_H,

48 VAR_X,

49 VAR_Y,

50 VAR_BITDEPTHX,

51 VAR_BITDEPTHY,

52 VAR_VARS_NB

53 };

55 typedef struct LUT2Context {

56 const AVClass *class;

57 FFFrameSync fs;

59 int odepth;

60 char *comp_expr_str[4];

62 AVExpr *comp_expr[4];

63 double var_values[VAR_VARS_NB];

64 uint16_t *lut[4]; ///< lookup table for each component

65 int width[4], height[4];

66 int widthx[4], heightx[4];

67 int widthy[4], heighty[4];

68 int nb_planesx;

69 int nb_planesy;

70 int nb_planes;

71 int depth, depthx, depthy;

72 int tlut2;

73 AVFrame *prev_frame; /* only used with tlut2 */

75 int (*lut2)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);

76 } LUT2Context;

78 typedef struct ThreadData {

79 AVFrame *out, *srcx, *srcy;

80 } ThreadData;

82 #define OFFSET(x) offsetof(LUT2Context, x)

83 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM

84 #define TFLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM

86 static const AVOption options[] = {

87 { "c0", "set component #0 expression", OFFSET(comp_expr_str[0]), AV_OPT_TYPE_STRING, { .str = "x" }, .flags = TFLAGS },

88 { "c1", "set component #1 expression", OFFSET(comp_expr_str[1]), AV_OPT_TYPE_STRING, { .str = "x" }, .flags = TFLAGS },

89 { "c2", "set component #2 expression", OFFSET(comp_expr_str[2]), AV_OPT_TYPE_STRING, { .str = "x" }, .flags = TFLAGS },

90 { "c3", "set component #3 expression", OFFSET(comp_expr_str[3]), AV_OPT_TYPE_STRING, { .str = "x" }, .flags = TFLAGS },

91 { "d", "set output depth", OFFSET(odepth), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 16, .flags = FLAGS },

92 { NULL }

93 };

95 static av_cold void uninit(AVFilterContext *ctx)

96 {

97 LUT2Context *s = ctx->priv;

98 int i;

100 ff_framesync_uninit(&s->fs);

101 av_frame_free(&s->prev_frame);

102

103 for (i = 0; i < 4; i++) {

104 av_expr_free(s->comp_expr[i]);

105 s->comp_expr[i] = NULL;

106 av_freep(&s->comp_expr_str[i]);

107 av_freep(&s->lut[i]);

108 }

109 }

110

111 #define BIT8_FMTS \

112 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P, \

113 AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, \

114 AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P, \

115 AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P, \

116 AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P, \

117 AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,

118

119 #define BIT9_FMTS \

120 AV_PIX_FMT_GBRP9, AV_PIX_FMT_GRAY9, \

121 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9, \

122 AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,

123

124 #define BIT10_FMTS \

125 AV_PIX_FMT_GRAY10, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10, \

126 AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, \

127 AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,

128

129 #define BIT12_FMTS \

130 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12, \

131 AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA444P12, \

132 AV_PIX_FMT_GRAY12, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRP12,

133

134 #define BIT14_FMTS \

135 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14, \

136 AV_PIX_FMT_GRAY14, AV_PIX_FMT_GBRP14,

137

138 #define BIT16_FMTS \

139 AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, \

140 AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16, \

141 AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRAP16, AV_PIX_FMT_GRAY16,

142

143 static int query_formats(AVFilterContext *ctx)

144 {

145 LUT2Context *s = ctx->priv;

146 static const enum AVPixelFormat all_pix_fmts[] = {

147 BIT8_FMTS

148 BIT9_FMTS

149 BIT10_FMTS

150 BIT12_FMTS

151 AV_PIX_FMT_NONE

152 };

153 static const enum AVPixelFormat bit8_pix_fmts[] = {

154 BIT8_FMTS

155 AV_PIX_FMT_NONE

156 };

157 static const enum AVPixelFormat bit9_pix_fmts[] = {

158 BIT9_FMTS

159 AV_PIX_FMT_NONE

160 };

161 static const enum AVPixelFormat bit10_pix_fmts[] = {

162 BIT10_FMTS

163 AV_PIX_FMT_NONE

164 };

165 static const enum AVPixelFormat bit12_pix_fmts[] = {

166 BIT12_FMTS

167 AV_PIX_FMT_NONE

168 };

169 static const enum AVPixelFormat bit14_pix_fmts[] = {

170 BIT14_FMTS

171 AV_PIX_FMT_NONE

172 };

173 static const enum AVPixelFormat bit16_pix_fmts[] = {

174 BIT16_FMTS

175 AV_PIX_FMT_NONE

176 };

177 const enum AVPixelFormat *pix_fmts;

178 int ret;

179

180 if (s->tlut2 || !s->odepth)

181 return ff_set_common_formats_from_list(ctx, all_pix_fmts);

182

183 ret = ff_formats_ref(ff_make_format_list(all_pix_fmts), &ctx->inputs[0]->outcfg.formats);

184 if (ret < 0)

185 return ret;

186

187 switch (s->odepth) {

188 case 8: pix_fmts = bit8_pix_fmts; break;

189 case 9: pix_fmts = bit9_pix_fmts; break;

190 case 10: pix_fmts = bit10_pix_fmts; break;

191 case 12: pix_fmts = bit12_pix_fmts; break;

192 case 14: pix_fmts = bit14_pix_fmts; break;

193 case 16: pix_fmts = bit16_pix_fmts; break;

194 default: av_log(ctx, AV_LOG_ERROR, "Unsupported output bit depth %d.\n", s->odepth);

195 return AVERROR(EINVAL);

196 }

197

198 return ff_formats_ref(ff_make_format_list(pix_fmts), &ctx->outputs[0]->incfg.formats);

199 }

200

201 static int config_inputx(AVFilterLink *inlink)

202 {

203 AVFilterContext *ctx = inlink->dst;

204 LUT2Context *s = ctx->priv;

205 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);

206 int hsub = desc->log2_chroma_w;

207 int vsub = desc->log2_chroma_h;

208

209 s->nb_planesx = av_pix_fmt_count_planes(inlink->format);

210 s->heightx[1] = s->heightx[2] = AV_CEIL_RSHIFT(inlink->h, vsub);

211 s->heightx[0] = s->heightx[3] = inlink->h;

212 s->widthx[1] = s->widthx[2] = AV_CEIL_RSHIFT(inlink->w, hsub);

213 s->widthx[0] = s->widthx[3] = inlink->w;

214

215 s->var_values[VAR_W] = inlink->w;

216 s->var_values[VAR_H] = inlink->h;

217 s->depthx = desc->comp[0].depth;

218 s->var_values[VAR_BITDEPTHX] = s->depthx;

219

220 if (s->tlut2) {

221 s->depthy = desc->comp[0].depth;

222 s->var_values[VAR_BITDEPTHY] = s->depthy;

223 }

224

225 return 0;

226 }

227

228 static int config_inputy(AVFilterLink *inlink)

229 {

230 AVFilterContext *ctx = inlink->dst;

231 LUT2Context *s = ctx->priv;

232 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);

233 int hsub = desc->log2_chroma_w;

234 int vsub = desc->log2_chroma_h;

235

236 s->nb_planesy = av_pix_fmt_count_planes(inlink->format);

237 s->depthy = desc->comp[0].depth;

238 s->var_values[VAR_BITDEPTHY] = s->depthy;

239 s->heighty[1] = s->heighty[2] = AV_CEIL_RSHIFT(inlink->h, vsub);

240 s->heighty[0] = s->heighty[3] = inlink->h;

241 s->widthy[1] = s->widthy[2] = AV_CEIL_RSHIFT(inlink->w, hsub);

242 s->widthy[0] = s->widthy[3] = inlink->w;

243

244 return 0;

245 }

246

247 #define DEFINE_LUT2(zname, xname, yname, ztype, xtype, ytype, zdiv, xdiv, ydiv) \

248 static int lut2_##zname##_##xname##_##yname(AVFilterContext *ctx, \

249 void *arg, \

250 int jobnr, int nb_jobs) \

251 { \

252 LUT2Context *s = ctx->priv; \

253 ThreadData *td = arg; \

254 AVFrame *out = td->out; \

255 AVFrame *srcx = td->srcx; \

256 AVFrame *srcy = td->srcy; \

257 const int odepth = s->odepth; \

258 int p, y, x; \

259 \

260 for (p = 0; p < s->nb_planes; p++) { \

261 const int slice_start = (s->heightx[p] * jobnr) / nb_jobs; \

262 const int slice_end = (s->heightx[p] * (jobnr+1)) / nb_jobs; \

263 const uint16_t *lut = s->lut[p]; \

264 const xtype *srcxx; \

265 const ytype *srcyy; \

266 ztype *dst; \

267 \

268 dst = (ztype *)(out->data[p] + slice_start * out->linesize[p]); \

269 srcxx = (const xtype *)(srcx->data[p] + slice_start * srcx->linesize[p]);\

270 srcyy = (const ytype *)(srcy->data[p] + slice_start * srcy->linesize[p]);\

271 \

272 for (y = slice_start; y < slice_end; y++) { \

273 for (x = 0; x < s->widthx[p]; x++) { \

274 dst[x] = av_clip_uintp2_c(lut[(srcyy[x] << s->depthx) | srcxx[x]], odepth); \

275 } \

276 \

277 dst += out->linesize[p] / zdiv; \

278 srcxx += srcx->linesize[p] / xdiv; \

279 srcyy += srcy->linesize[p] / ydiv; \

280 } \

281 } \

282 return 0; \

283 }

284

285 DEFINE_LUT2(8, 8, 8, uint8_t, uint8_t, uint8_t, 1, 1, 1)

286 DEFINE_LUT2(8, 8, 16, uint8_t, uint8_t, uint16_t, 1, 1, 2)

287 DEFINE_LUT2(8, 16, 8, uint8_t, uint16_t, uint8_t, 1, 2, 1)

288 DEFINE_LUT2(8, 16, 16, uint8_t, uint16_t, uint16_t, 1, 2, 2)

289 DEFINE_LUT2(16, 8, 8, uint16_t, uint8_t, uint8_t, 2, 1, 1)

290 DEFINE_LUT2(16, 8, 16, uint16_t, uint8_t, uint16_t, 2, 1, 2)

291 DEFINE_LUT2(16, 16, 8, uint16_t, uint16_t, uint8_t, 2, 2, 1)

292 DEFINE_LUT2(16, 16, 16, uint16_t, uint16_t, uint16_t, 2, 2, 2)

293

294 static int process_frame(FFFrameSync *fs)

295 {

296 AVFilterContext *ctx = fs->parent;

297 LUT2Context *s = fs->opaque;

298 AVFilterLink *outlink = ctx->outputs[0];

299 AVFrame *out, *srcx = NULL, *srcy = NULL;

300 int ret;

301

302 if ((ret = ff_framesync_get_frame(&s->fs, 0, &srcx, 0)) < 0 ||

303 (ret = ff_framesync_get_frame(&s->fs, 1, &srcy, 0)) < 0)

304 return ret;

305

306 if (ctx->is_disabled || !srcy) {

307 out = av_frame_clone(srcx);

308 if (!out)

309 return AVERROR(ENOMEM);

310 } else {

311 ThreadData td;

312

313 out = ff_get_video_buffer(outlink, outlink->w, outlink->h);

314 if (!out)

315 return AVERROR(ENOMEM);

316 av_frame_copy_props(out, srcx);

317

318 td.out = out;

319 td.srcx = srcx;

320 td.srcy = srcy;

321 ff_filter_execute(ctx, s->lut2, &td, NULL,

322 FFMIN(s->heightx[1], ff_filter_get_nb_threads(ctx)));

323 }

324

325 out->pts = av_rescale_q(s->fs.pts, s->fs.time_base, outlink->time_base);

326

327 return ff_filter_frame(outlink, out);

328 }

329

330 static int config_output(AVFilterLink *outlink)

331 {

332 AVFilterContext *ctx = outlink->src;

333 LUT2Context *s = ctx->priv;

334 int p, ret;

335

336 s->depth = s->depthx + s->depthy;

337 s->nb_planes = s->nb_planesx;

338

339 s->lut2 = s->depth > 16 ? lut2_16_16_16 : lut2_8_8_8;

340 if (s->odepth) {

341 if (s->depthx == 8 && s->depthy == 8 && s->odepth > 8)

342 s->lut2 = lut2_16_8_8;

343 if (s->depthx > 8 && s->depthy == 8 && s->odepth > 8)

344 s->lut2 = lut2_16_16_8;

345 if (s->depthx == 8 && s->depthy > 8 && s->odepth > 8)

346 s->lut2 = lut2_16_8_16;

347 if (s->depthx == 8 && s->depthy == 8 && s->odepth == 8)

348 s->lut2 = lut2_8_8_8;

349 if (s->depthx > 8 && s->depthy == 8 && s->odepth == 8)

350 s->lut2 = lut2_8_16_8;

351 if (s->depthx == 8 && s->depthy > 8 && s->odepth == 8)

352 s->lut2 = lut2_8_8_16;

353 if (s->depthx > 8 && s->depthy > 8 && s->odepth == 8)

354 s->lut2 = lut2_8_16_16;

355 } else {

356 s->odepth = s->depthx;

357 }

358

359 for (p = 0; p < s->nb_planes; p++) {

360 if (!s->lut[p])

361 s->lut[p] = av_malloc_array(1 << s->depth, sizeof(uint16_t));

362 if (!s->lut[p])

363 return AVERROR(ENOMEM);

364 }

365

366 for (p = 0; p < s->nb_planes; p++) {

367 double res;

368 int x, y;

369

370 /* create the parsed expression */

371 av_expr_free(s->comp_expr[p]);

372 s->comp_expr[p] = NULL;

373 ret = av_expr_parse(&s->comp_expr[p], s->comp_expr_str[p],

374 var_names, NULL, NULL, NULL, NULL, 0, ctx);

375 if (ret < 0) {

376 av_log(ctx, AV_LOG_ERROR,

377 "Error when parsing the expression '%s' for the component %d.\n",

378 s->comp_expr_str[p], p);

379 return AVERROR(EINVAL);

380 }

381

382 /* compute the lut */

383 for (y = 0; y < (1 << s->depthy); y++) {

384 s->var_values[VAR_Y] = y;

385 for (x = 0; x < (1 << s->depthx); x++) {

386 s->var_values[VAR_X] = x;

387 res = av_expr_eval(s->comp_expr[p], s->var_values, s);

388 if (isnan(res)) {

389 av_log(ctx, AV_LOG_ERROR,

390 "Error when evaluating the expression '%s' for the values %d and %d for the component %d.\n",

391 s->comp_expr_str[p], x, y, p);

392 return AVERROR(EINVAL);

393 }

394

395 s->lut[p][(y << s->depthx) + x] = res;

396 }

397 }

398 }

399

400 return 0;

401 }

402

403 static int lut2_config_output(AVFilterLink *outlink)

404 {

405 AVFilterContext *ctx = outlink->src;

406 LUT2Context *s = ctx->priv;

407 AVFilterLink *srcx = ctx->inputs[0];

408 AVFilterLink *srcy = ctx->inputs[1];

409 FilterLink *il = ff_filter_link(srcx);

410 FilterLink *ol = ff_filter_link(outlink);

411 FFFrameSyncIn *in;

412 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);

413 int hsub = desc->log2_chroma_w;

414 int vsub = desc->log2_chroma_h;

415 int ret;

416

417 outlink->w = srcx->w;

418 outlink->h = srcx->h;

419 outlink->time_base = srcx->time_base;

420 outlink->sample_aspect_ratio = srcx->sample_aspect_ratio;

421 ol->frame_rate = il->frame_rate;

422

423 s->nb_planes = av_pix_fmt_count_planes(outlink->format);

424 s->height[1] = s->height[2] = AV_CEIL_RSHIFT(outlink->h, vsub);

425 s->height[0] = s->height[3] = outlink->h;

426 s->width[1] = s->width[2] = AV_CEIL_RSHIFT(outlink->w, hsub);

427 s->width[0] = s->width[3] = outlink->w;

428

429 if (!s->odepth && srcx->format != srcy->format) {

430 av_log(ctx, AV_LOG_ERROR, "inputs must be of same pixel format\n");

431 return AVERROR(EINVAL);

432 }

433

434 if (srcx->w != srcy->w || srcx->h != srcy->h) {

435 av_log(ctx, AV_LOG_ERROR, "First input link %s parameters "

436 "(size %dx%d) do not match the corresponding "

437 "second input link %s parameters (size %dx%d)\n",

438 ctx->input_pads[0].name, srcx->w, srcx->h,

439 ctx->input_pads[1].name,

440 srcy->w, srcy->h);

441 return AVERROR(EINVAL);

442 }

443

444 if (s->nb_planesx != s->nb_planesy) {

445 av_log(ctx, AV_LOG_ERROR, "First input link %s number of planes "

446 "(%d) do not match the corresponding "

447 "second input link %s number of planes (%d)\n",

448 ctx->input_pads[0].name, s->nb_planesx,

449 ctx->input_pads[1].name, s->nb_planesy);

450 return AVERROR(EINVAL);

451 }

452

453 if (s->nb_planesx != s->nb_planes) {

454 av_log(ctx, AV_LOG_ERROR, "First input link %s number of planes "

455 "(%d) do not match the corresponding "

456 "output link %s number of planes (%d)\n",

457 ctx->input_pads[0].name, s->nb_planesx,

458 ctx->output_pads[0].name, s->nb_planes);

459 return AVERROR(EINVAL);

460 }

461

462 if (s->widthx[1] != s->widthy[1] || s->heightx[1] != s->heighty[1]) {

463 av_log(ctx, AV_LOG_ERROR, "First input link %s 2nd plane "

464 "(size %dx%d) do not match the corresponding "

465 "second input link %s 2nd plane (size %dx%d)\n",

466 ctx->input_pads[0].name, s->widthx[1], s->heightx[1],

467 ctx->input_pads[1].name,

468 s->widthy[1], s->heighty[1]);

469 return AVERROR(EINVAL);

470 }

471

472 if (s->widthx[2] != s->widthy[2] || s->heightx[2] != s->heighty[2]) {

473 av_log(ctx, AV_LOG_ERROR, "First input link %s 3rd plane "

474 "(size %dx%d) do not match the corresponding "

475 "second input link %s 3rd plane (size %dx%d)\n",

476 ctx->input_pads[0].name, s->widthx[2], s->heightx[2],

477 ctx->input_pads[1].name,

478 s->widthy[2], s->heighty[2]);

479 return AVERROR(EINVAL);

480 }

481

482 if (s->widthx[1] != s->width[1] || s->heightx[1] != s->height[1]) {

483 av_log(ctx, AV_LOG_ERROR, "First input link %s 2nd plane "

484 "(size %dx%d) do not match the corresponding "

485 "output link %s 2nd plane (size %dx%d)\n",

486 ctx->input_pads[0].name, s->widthx[1], s->heightx[1],

487 ctx->output_pads[0].name, s->width[1], s->height[1]);

488 return AVERROR(EINVAL);

489 }

490

491 if (s->widthx[2] != s->width[2] || s->heightx[2] != s->height[2]) {

492 av_log(ctx, AV_LOG_ERROR, "First input link %s 3rd plane "

493 "(size %dx%d) do not match the corresponding "

494 "output link %s 3rd plane (size %dx%d)\n",

495 ctx->input_pads[0].name, s->widthx[2], s->heightx[2],

496 ctx->output_pads[0].name, s->width[2], s->height[2]);

497 return AVERROR(EINVAL);

498 }

499

500 if ((ret = ff_framesync_init(&s->fs, ctx, 2)) < 0)

501 return ret;

502

503 in = s->fs.in;

504 in[0].time_base = srcx->time_base;

505 in[1].time_base = srcy->time_base;

506 in[0].sync = 2;

507 in[0].before = EXT_STOP;

508 in[0].after = EXT_INFINITY;

509 in[1].sync = 1;

510 in[1].before = EXT_STOP;

511 in[1].after = EXT_INFINITY;

512 s->fs.opaque = s;

513 s->fs.on_event = process_frame;

514

515 if ((ret = config_output(outlink)) < 0)

516 return ret;

517

518 ret = ff_framesync_configure(&s->fs);

519 outlink->time_base = s->fs.time_base;

520

521 return ret;

522 }

523

524 static int activate(AVFilterContext *ctx)

525 {

526 LUT2Context *s = ctx->priv;

527 return ff_framesync_activate(&s->fs);

528 }

529

530 static const AVFilterPad inputs[] = {

531 {

532 .name = "srcx",

533 .type = AVMEDIA_TYPE_VIDEO,

534 .config_props = config_inputx,

535 },

536 {

537 .name = "srcy",

538 .type = AVMEDIA_TYPE_VIDEO,

539 .config_props = config_inputy,

540 },

541 };

542

543 static const AVFilterPad outputs[] = {

544 {

545 .name = "default",

546 .type = AVMEDIA_TYPE_VIDEO,

547 .config_props = lut2_config_output,

548 },

549 };

550

551 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,

552 char *res, int res_len, int flags)

553 {

554 int ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);

555

556 if (ret < 0)

557 return ret;

558

559 return config_output(ctx->outputs[0]);

560 }

561

562 #define lut2_options options

563

564 FRAMESYNC_DEFINE_CLASS(lut2, LUT2Context, fs);

565

566 const AVFilter ff_vf_lut2 = {

567 .name = "lut2",

568 .description = NULL_IF_CONFIG_SMALL("Compute and apply a lookup table from two video inputs."),

569 .preinit = lut2_framesync_preinit,

570 .priv_size = sizeof(LUT2Context),

571 .priv_class = &lut2_class,

572 .uninit = uninit,

573 .activate = activate,

574 FILTER_INPUTS(inputs),

575 FILTER_OUTPUTS(outputs),

576 FILTER_QUERY_FUNC(query_formats),

577 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |

578 AVFILTER_FLAG_SLICE_THREADS,

579 .process_command = process_command,

580 };

581

582 #if CONFIG_TLUT2_FILTER

583

584 static av_cold int init(AVFilterContext *ctx)

585 {

586 LUT2Context *s = ctx->priv;

587

588 s->tlut2 = !strcmp(ctx->filter->name, "tlut2");

589

590 return 0;

591 }

592

593 static int tlut2_filter_frame(AVFilterLink *inlink, AVFrame *frame)

594 {

595 AVFilterContext *ctx = inlink->dst;

596 LUT2Context *s = ctx->priv;

597 AVFilterLink *outlink = ctx->outputs[0];

598

599 if (s->prev_frame) {

600 AVFrame *out;

601

602 if (ctx->is_disabled) {

603 out = av_frame_clone(frame);

604 } else {

605 ThreadData td;

606

607 out = ff_get_video_buffer(outlink, outlink->w, outlink->h);

608 if (!out) {

609 av_frame_free(&s->prev_frame);

610 s->prev_frame = frame;

611 return AVERROR(ENOMEM);

612 }

613

614 av_frame_copy_props(out, frame);

615

616 td.out = out;

617 td.srcx = frame;

618 td.srcy = s->prev_frame;

619 ff_filter_execute(ctx, s->lut2, &td, NULL,

620 FFMIN(s->heightx[1], ff_filter_get_nb_threads(ctx)));

621 }

622 av_frame_free(&s->prev_frame);

623 s->prev_frame = frame;

624 return ff_filter_frame(outlink, out);

625 }

626 s->prev_frame = frame;

627 return 0;

628 }

629

630 static const AVOption tlut2_options[] = {

631 { "c0", "set component #0 expression", OFFSET(comp_expr_str[0]), AV_OPT_TYPE_STRING, { .str = "x" }, .flags = TFLAGS },

632 { "c1", "set component #1 expression", OFFSET(comp_expr_str[1]), AV_OPT_TYPE_STRING, { .str = "x" }, .flags = TFLAGS },

633 { "c2", "set component #2 expression", OFFSET(comp_expr_str[2]), AV_OPT_TYPE_STRING, { .str = "x" }, .flags = TFLAGS },

634 { "c3", "set component #3 expression", OFFSET(comp_expr_str[3]), AV_OPT_TYPE_STRING, { .str = "x" }, .flags = TFLAGS },

635 { NULL }

636 };

637

638 AVFILTER_DEFINE_CLASS(tlut2);

639

640 static const AVFilterPad tlut2_inputs[] = {

641 {

642 .name = "default",

643 .type = AVMEDIA_TYPE_VIDEO,

644 .filter_frame = tlut2_filter_frame,

645 .config_props = config_inputx,

646 },

647 };

648

649 static const AVFilterPad tlut2_outputs[] = {

650 {

651 .name = "default",

652 .type = AVMEDIA_TYPE_VIDEO,

653 .config_props = config_output,

654 },

655 };

656

657 const AVFilter ff_vf_tlut2 = {

658 .name = "tlut2",

659 .description = NULL_IF_CONFIG_SMALL("Compute and apply a lookup table from two successive frames."),

660 .priv_size = sizeof(LUT2Context),

661 .priv_class = &tlut2_class,

662 .init = init,

663 .uninit = uninit,

664 FILTER_INPUTS(tlut2_inputs),

665 FILTER_OUTPUTS(tlut2_outputs),

666 FILTER_QUERY_FUNC(query_formats),

667 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |

668 AVFILTER_FLAG_SLICE_THREADS,

669 .process_command = process_command,

670 };

671

672 #endif

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

FFFrameSyncIn::time_base

AVRational time_base

Time base for the incoming frames.

Definition: framesync.h:117

ff_framesync_configure

int ff_framesync_configure(FFFrameSync *fs)

Configure a frame sync structure.

Definition: framesync.c:137

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

config_output

static int config_output(AVFilterLink *outlink)

Definition: vf_lut2.c:330

BIT8_FMTS

#define BIT8_FMTS

Definition: vf_lut2.c:111

VAR_VARS_NB

@ VAR_VARS_NB

Definition: vf_lut2.c:52

LUT2Context::lut2

int(* lut2)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

Definition: vf_lut2.c:75

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

opt.h

var_name

Definition: noise.c:47

ff_make_format_list

AVFilterFormats * ff_make_format_list(const int *fmts)

Create a list of supported formats.

Definition: formats.c:435

BIT14_FMTS

#define BIT14_FMTS

Definition: vf_lut2.c:134

ff_framesync_uninit

void ff_framesync_uninit(FFFrameSync *fs)

Free all memory currently allocated.

Definition: framesync.c:301

out

FILE * out

Definition: movenc.c:55

VAR_BITDEPTHY

@ VAR_BITDEPTHY

Definition: vf_lut2.c:51

ff_filter_frame

int ff_filter_frame(AVFilterLink *link, AVFrame *frame)

Send a frame of data to the next filter.

Definition: avfilter.c:1023

av_pix_fmt_desc_get

const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:2965

ff_framesync_get_frame

int ff_framesync_get_frame(FFFrameSync *fs, unsigned in, AVFrame **rframe, unsigned get)

Get the current frame in an input.

Definition: framesync.c:269

LUT2Context::fs

FFFrameSync fs

Definition: vf_lut2.c:57

LUT2Context::depthx

int depthx

Definition: vf_lut2.c:71

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

LUT2Context

Definition: vf_lut2.c:55

FILTER_INPUTS

#define FILTER_INPUTS(array)

Definition: filters.h:262

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:389

pixdesc.h

AVOption

AVOption.

Definition: opt.h:429

LUT2Context::tlut2

int tlut2

Definition: vf_lut2.c:72

LUT2Context::widthx

int widthx[4]

Definition: vf_lut2.c:66

ff_vf_tlut2

const AVFilter ff_vf_tlut2

DEFINE_LUT2

#define DEFINE_LUT2(zname, xname, yname, ztype, xtype, ytype, zdiv, xdiv, ydiv)

Definition: vf_lut2.c:247

AVFilter::name

const char * name

Filter name.

Definition: avfilter.h:205

FFFrameSync

Frame sync structure.

Definition: framesync.h:168

EXT_INFINITY

@ EXT_INFINITY

Extend the frame to infinity.

Definition: framesync.h:75

ThreadData::out

AVFrame * out

Definition: af_adeclick.c:526

config_inputx

static int config_inputx(AVFilterLink *inlink)

Definition: vf_lut2.c:201

video.h

AVFilterLink

A link between two filters.

Definition: avfilter.h:557

VAR_H

@ VAR_H

Definition: vf_lut2.c:47

ThreadData::srcx

AVFrame * srcx

Definition: vf_lut2.c:79

FilterLink

Link properties exposed to filter code, but not external callers.

Definition: filters.h:127

LUT2Context::heightx

int heightx[4]

Definition: vf_lut2.c:66

hsub

static void hsub(htype *dst, const htype *src, int bins)

Definition: vf_median.c:74

formats.h

av_expr_parse

int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)

Parse an expression.

Definition: eval.c:710

av_pix_fmt_count_planes

int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:3005

EXT_STOP

@ EXT_STOP

Completely stop all streams with this one.

Definition: framesync.h:65

LUT2Context::depthy

int depthy

Definition: vf_lut2.c:71

FFFrameSyncIn

Input stream structure.

Definition: framesync.h:102

LUT2Context::depth

int depth

Definition: vf_lut2.c:71

FFFrameSyncIn::sync

unsigned sync

Synchronization level: frames on input at the highest sync level will generate output frame events.

Definition: framesync.h:160

process_frame

static int process_frame(FFFrameSync *fs)

Definition: vf_lut2.c:294

LUT2Context::height

int height[4]

Definition: vf_lut2.c:65

av_expr_free

void av_expr_free(AVExpr *e)

Free a parsed expression previously created with av_expr_parse().

Definition: eval.c:358

LUT2Context::prev_frame

AVFrame * prev_frame

Definition: vf_lut2.c:73

AVFilterPad

A filter pad used for either input or output.

Definition: filters.h:38

LUT2Context::odepth

int odepth

Definition: vf_lut2.c:59

LUT2Context::var_values

double var_values[VAR_VARS_NB]

Definition: vf_lut2.c:63

var_names

static const char *const var_names[]

Definition: vf_lut2.c:35

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

FLAGS

#define FLAGS

Definition: vf_lut2.c:83

av_cold

#define av_cold

Definition: attributes.h:90

activate

static int activate(AVFilterContext *ctx)

Definition: vf_lut2.c:524

#define s(width, name)

Definition: cbs_vp9.c:198

process_command

static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)

Definition: vf_lut2.c:551

AV_CEIL_RSHIFT

#define AV_CEIL_RSHIFT(a, b)

Definition: common.h:60

TFLAGS

#define TFLAGS

Definition: vf_lut2.c:84

ff_formats_ref

int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)

Add *ref as a new reference to formats.

Definition: formats.c:678

LUT2Context::nb_planesx

int nb_planesx

Definition: vf_lut2.c:68

AVFilterLink::sample_aspect_ratio

AVRational sample_aspect_ratio

agreed upon sample aspect ratio

Definition: avfilter.h:571

ff_set_common_formats_from_list

int ff_set_common_formats_from_list(AVFilterContext *ctx, const int *fmts)

Equivalent to ff_set_common_formats(ctx, ff_make_format_list(fmts))

Definition: formats.c:873

uninit

static av_cold void uninit(AVFilterContext *ctx)

Definition: vf_lut2.c:95

filters.h

OFFSET

#define OFFSET(x)

Definition: vf_lut2.c:82

pix_fmts

static enum AVPixelFormat pix_fmts[]

Definition: libkvazaar.c:304

ctx

AVFormatContext * ctx

Definition: movenc.c:49

av_expr_eval

double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)

Evaluate a previously parsed expression.

Definition: eval.c:792

av_frame_clone

AVFrame * av_frame_clone(const AVFrame *src)

Create a new frame that references the same data as src.

Definition: frame.c:597

av_rescale_q

int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)

Rescale a 64-bit integer by 2 rational numbers.

Definition: mathematics.c:142

AVExpr

Definition: eval.c:158

FILTER_OUTPUTS

#define FILTER_OUTPUTS(array)

Definition: filters.h:263

arg

const char * arg

Definition: jacosubdec.c:67

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

#define fs(width, name, subs,...)

Definition: cbs_vp9.c:200

LUT2Context::width

int width[4]

Definition: vf_lut2.c:65

lut2_config_output

static int lut2_config_output(AVFilterLink *outlink)

Definition: vf_lut2.c:403

BIT9_FMTS

#define BIT9_FMTS

Definition: vf_lut2.c:119

isnan

#define isnan(x)

Definition: libm.h:340

VAR_X

@ VAR_X

Definition: vf_lut2.c:48

LUT2Context::widthy

int widthy[4]

Definition: vf_lut2.c:67

AVFILTER_DEFINE_CLASS

#define AVFILTER_DEFINE_CLASS(fname)

Definition: filters.h:273

ff_filter_link

static FilterLink * ff_filter_link(AVFilterLink *link)

Definition: filters.h:197

LUT2Context::comp_expr

AVExpr * comp_expr[4]

Definition: vf_lut2.c:62

LUT2Context::lut

uint16_t * lut[4]

lookup table for each component

Definition: vf_lut2.c:64

inputs

static const AVFilterPad inputs[]

Definition: vf_lut2.c:530

VAR_W

@ VAR_W

Definition: vf_lut2.c:46

eval.h

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:368

BIT10_FMTS

#define BIT10_FMTS

Definition: vf_lut2.c:124

BIT16_FMTS

#define BIT16_FMTS

Definition: vf_lut2.c:138

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

AVFilterLink::format

int format

agreed upon media format

Definition: avfilter.h:566

AVFilterLink::src

AVFilterContext * src

source filter

Definition: avfilter.h:558

ff_filter_process_command

int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)

Generic processing of user supplied commands that are set in the same way as the filter options.

Definition: avfilter.c:894

VAR_BITDEPTHX

@ VAR_BITDEPTHX

Definition: vf_lut2.c:50

attributes.h

all_pix_fmts

static enum AVPixelFormat all_pix_fmts[]

Definition: jpeg2000dec.c:190

options

static const AVOption options[]

Definition: vf_lut2.c:86

LUT2Context::heighty

int heighty[4]

Definition: vf_lut2.c:67

LUT2Context::comp_expr_str

char * comp_expr_str[4]

Definition: vf_lut2.c:60

#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

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:31

LUT2Context::nb_planesy

int nb_planesy

Definition: vf_lut2.c:69

common.h

ff_filter_get_nb_threads

int ff_filter_get_nb_threads(AVFilterContext *ctx)

Get number of threads for current filter instance.

Definition: avfilter.c:834

ThreadData

Used for passing data between threads.

Definition: dsddec.c:71

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

config_inputy

static int config_inputy(AVFilterLink *inlink)

Definition: vf_lut2.c:228

AVFilterPad::name

const char * name

Pad name.

Definition: filters.h:44

AVFilter

Filter definition.

Definition: avfilter.h:201

outputs

static const AVFilterPad outputs[]

Definition: vf_lut2.c:543

ret

Definition: filter_design.txt:187

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

ff_framesync_init

int ff_framesync_init(FFFrameSync *fs, AVFilterContext *parent, unsigned nb_in)

Initialize a frame sync structure.

Definition: framesync.c:86

FFFrameSyncIn::before

enum FFFrameSyncExtMode before

Extrapolation mode for timestamps before the first frame.

Definition: framesync.h:107

ff_vf_lut2

const AVFilter ff_vf_lut2

Definition: vf_lut2.c:566