FFmpeg: libavfilter/vf_identity.c Source File

FFmpeg

[フレーム]

libavfilter

vf_identity.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 * Calculate the Identity between two input videos.

24 */

26 #include "config_components.h"

28 #include "libavutil/avstring.h"

29 #include "libavutil/opt.h"

30 #include "libavutil/pixdesc.h"

31 #include "avfilter.h"

32 #include "drawutils.h"

33 #include "formats.h"

34 #include "framesync.h"

35 #include "internal.h"

36 #include "video.h"

37 #include "scene_sad.h"

39 typedef struct IdentityContext {

40 const AVClass *class;

41 FFFrameSync fs;

42 double score, min_score, max_score, score_comp[4];

43 uint64_t nb_frames;

44 int is_rgb;

45 int is_msad;

46 uint8_t rgba_map[4];

47 int max[4];

48 char comps[4];

49 int nb_components;

50 int nb_threads;

51 int planewidth[4];

52 int planeheight[4];

53 uint64_t **scores;

54 unsigned (*filter_line)(const uint8_t *buf, const uint8_t *ref, int w);

55 int (*filter_slice)(AVFilterContext *ctx, void *arg,

56 int jobnr, int nb_jobs);

57 ff_scene_sad_fn sad;

58 } IdentityContext;

60 #define OFFSET(x) offsetof(IdentityContext, x)

61 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM

63 static unsigned identity_line_8bit(const uint8_t *main_line, const uint8_t *ref_line, int outw)

64 {

65 unsigned score = 0;

67 for (int j = 0; j < outw; j++)

68 score += main_line[j] == ref_line[j];

70 return score;

71 }

73 static unsigned identity_line_16bit(const uint8_t *mmain_line, const uint8_t *rref_line, int outw)

74 {

75 const uint16_t *main_line = (const uint16_t *)mmain_line;

76 const uint16_t *ref_line = (const uint16_t *)rref_line;

77 unsigned score = 0;

79 for (int j = 0; j < outw; j++)

80 score += main_line[j] == ref_line[j];

82 return score;

83 }

85 typedef struct ThreadData {

86 const uint8_t *main_data[4];

87 const uint8_t *ref_data[4];

88 int main_linesize[4];

89 int ref_linesize[4];

90 int planewidth[4];

91 int planeheight[4];

92 uint64_t **score;

93 int nb_components;

94 } ThreadData;

96 static

97 int compute_images_msad(AVFilterContext *ctx, void *arg,

98 int jobnr, int nb_jobs)

99 {

100 IdentityContext *s = ctx->priv;

101 ThreadData *td = arg;

102 uint64_t *score = td->score[jobnr];

103

104 for (int c = 0; c < td->nb_components; c++) {

105 const int outw = td->planewidth[c];

106 const int outh = td->planeheight[c];

107 const int slice_start = (outh * jobnr) / nb_jobs;

108 const int slice_end = (outh * (jobnr+1)) / nb_jobs;

109 const int ref_linesize = td->ref_linesize[c];

110 const int main_linesize = td->main_linesize[c];

111 const uint8_t *main_line = td->main_data[c] + main_linesize * slice_start;

112 const uint8_t *ref_line = td->ref_data[c] + ref_linesize * slice_start;

113 uint64_t m = 0;

114

115 s->sad(main_line, main_linesize, ref_line, ref_linesize,

116 outw, slice_end - slice_start, &m);

117

118 score[c] = m;

119 }

120

121 return 0;

122 }

123

124 static

125 int compute_images_identity(AVFilterContext *ctx, void *arg,

126 int jobnr, int nb_jobs)

127 {

128 IdentityContext *s = ctx->priv;

129 ThreadData *td = arg;

130 uint64_t *score = td->score[jobnr];

131

132 for (int c = 0; c < td->nb_components; c++) {

133 const int outw = td->planewidth[c];

134 const int outh = td->planeheight[c];

135 const int slice_start = (outh * jobnr) / nb_jobs;

136 const int slice_end = (outh * (jobnr+1)) / nb_jobs;

137 const int ref_linesize = td->ref_linesize[c];

138 const int main_linesize = td->main_linesize[c];

139 const uint8_t *main_line = td->main_data[c] + main_linesize * slice_start;

140 const uint8_t *ref_line = td->ref_data[c] + ref_linesize * slice_start;

141 uint64_t m = 0;

142

143 for (int i = slice_start; i < slice_end; i++) {

144 m += s->filter_line(main_line, ref_line, outw);

145 ref_line += ref_linesize;

146 main_line += main_linesize;

147 }

148 score[c] = m;

149 }

150

151 return 0;

152 }

153

154 static void set_meta(AVFilterContext *ctx,

155 AVDictionary **metadata, const char *key, char comp, float d)

156 {

157 char value[128];

158 snprintf(value, sizeof(value), "%f", d);

159 if (comp) {

160 char key2[128];

161 snprintf(key2, sizeof(key2), "lavfi.%s.%s%s%c",

162 ctx->filter->name, ctx->filter->name, key, comp);

163 av_dict_set(metadata, key2, value, 0);

164 } else {

165 char key2[128];

166 snprintf(key2, sizeof(key2), "lavfi.%s.%s%s",

167 ctx->filter->name, ctx->filter->name, key);

168 av_dict_set(metadata, key2, value, 0);

169 }

170 }

171

172 static int do_identity(FFFrameSync *fs)

173 {

174 AVFilterContext *ctx = fs->parent;

175 IdentityContext *s = ctx->priv;

176 AVFrame *master, *ref;

177 double comp_score[4], score = 0.;

178 uint64_t comp_sum[4] = { 0 };

179 AVDictionary **metadata;

180 ThreadData td;

181 int ret;

182

183 ret = ff_framesync_dualinput_get(fs, &master, &ref);

184 if (ret < 0)

185 return ret;

186 if (ctx->is_disabled || !ref)

187 return ff_filter_frame(ctx->outputs[0], master);

188 metadata = &master->metadata;

189

190 td.nb_components = s->nb_components;

191 td.score = s->scores;

192 for (int c = 0; c < s->nb_components; c++) {

193 td.main_data[c] = master->data[c];

194 td.ref_data[c] = ref->data[c];

195 td.main_linesize[c] = master->linesize[c];

196 td.ref_linesize[c] = ref->linesize[c];

197 td.planewidth[c] = s->planewidth[c];

198 td.planeheight[c] = s->planeheight[c];

199 }

200

201 ff_filter_execute(ctx, s->filter_slice, &td, NULL,

202 FFMIN(s->planeheight[1], s->nb_threads));

203

204 for (int j = 0; j < s->nb_threads; j++) {

205 for (int c = 0; c < s->nb_components; c++)

206 comp_sum[c] += s->scores[j][c];

207 }

208

209 for (int c = 0; c < s->nb_components; c++)

210 comp_score[c] = comp_sum[c] / ((double)s->planewidth[c] * s->planeheight[c]);

211

212 for (int c = 0; c < s->nb_components && s->is_msad; c++)

213 comp_score[c] /= (double)s->max[c];

214

215 for (int c = 0; c < s->nb_components; c++)

216 score += comp_score[c];

217 score /= s->nb_components;

218

219 s->min_score = FFMIN(s->min_score, score);

220 s->max_score = FFMAX(s->max_score, score);

221

222 s->score += score;

223

224 for (int j = 0; j < s->nb_components; j++)

225 s->score_comp[j] += comp_score[j];

226 s->nb_frames++;

227

228 for (int j = 0; j < s->nb_components; j++) {

229 int c = s->is_rgb ? s->rgba_map[j] : j;

230 set_meta(ctx, metadata, ".", s->comps[j], comp_score[c]);

231 }

232 set_meta(ctx, metadata, "_avg", 0, score);

233

234 return ff_filter_frame(ctx->outputs[0], master);

235 }

236

237 static av_cold int init(AVFilterContext *ctx)

238 {

239 IdentityContext *s = ctx->priv;

240

241 s->fs.on_event = do_identity;

242

243 return 0;

244 }

245

246 static const enum AVPixelFormat pix_fmts[] = {

247 AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,

248 #define PF_NOALPHA(suf) AV_PIX_FMT_YUV420##suf, AV_PIX_FMT_YUV422##suf, AV_PIX_FMT_YUV444##suf

249 #define PF_ALPHA(suf) AV_PIX_FMT_YUVA420##suf, AV_PIX_FMT_YUVA422##suf, AV_PIX_FMT_YUVA444##suf

250 #define PF(suf) PF_NOALPHA(suf), PF_ALPHA(suf)

251 PF(P), PF(P9), PF(P10), PF_NOALPHA(P12), PF_NOALPHA(P14), PF(P16),

252 AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,

253 AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,

254 AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,

255 AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,

256 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,

257 AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,

258 AV_PIX_FMT_NONE

259 };

260

261 static int config_input_ref(AVFilterLink *inlink)

262 {

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

264 AVFilterContext *ctx = inlink->dst;

265 IdentityContext *s = ctx->priv;

266

267 s->nb_threads = ff_filter_get_nb_threads(ctx);

268 s->nb_components = desc->nb_components;

269 if (ctx->inputs[0]->w != ctx->inputs[1]->w ||

270 ctx->inputs[0]->h != ctx->inputs[1]->h) {

271 av_log(ctx, AV_LOG_ERROR, "Width and height of input videos must be same.\n");

272 return AVERROR(EINVAL);

273 }

274

275 s->is_rgb = ff_fill_rgba_map(s->rgba_map, inlink->format) >= 0;

276 s->comps[0] = s->is_rgb ? 'R' : 'Y' ;

277 s->comps[1] = s->is_rgb ? 'G' : 'U' ;

278 s->comps[2] = s->is_rgb ? 'B' : 'V' ;

279 s->comps[3] = 'A';

280

281 s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);

282 s->planeheight[0] = s->planeheight[3] = inlink->h;

283 s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);

284 s->planewidth[0] = s->planewidth[3] = inlink->w;

285

286 s->scores = av_calloc(s->nb_threads, sizeof(*s->scores));

287 if (!s->scores)

288 return AVERROR(ENOMEM);

289

290 for (int t = 0; t < s->nb_threads; t++) {

291 s->scores[t] = av_calloc(s->nb_components, sizeof(*s->scores[0]));

292 if (!s->scores[t])

293 return AVERROR(ENOMEM);

294 }

295

296 s->min_score = +INFINITY;

297 s->max_score = -INFINITY;

298

299 s->max[0] = (1 << desc->comp[0].depth) - 1;

300 s->max[1] = (1 << desc->comp[1].depth) - 1;

301 s->max[2] = (1 << desc->comp[2].depth) - 1;

302 s->max[3] = (1 << desc->comp[3].depth) - 1;

303

304 s->is_msad = !strcmp(ctx->filter->name, "msad");

305 s->filter_slice = !s->is_msad ? compute_images_identity : compute_images_msad;

306 s->filter_line = desc->comp[0].depth > 8 ? identity_line_16bit : identity_line_8bit;

307

308 s->sad = ff_scene_sad_get_fn(desc->comp[0].depth <= 8 ? 8 : 16);

309 if (!s->sad)

310 return AVERROR(EINVAL);

311

312 return 0;

313 }

314

315 static int config_output(AVFilterLink *outlink)

316 {

317 AVFilterContext *ctx = outlink->src;

318 IdentityContext *s = ctx->priv;

319 AVFilterLink *mainlink = ctx->inputs[0];

320 int ret;

321

322 ret = ff_framesync_init_dualinput(&s->fs, ctx);

323 if (ret < 0)

324 return ret;

325 outlink->w = mainlink->w;

326 outlink->h = mainlink->h;

327 outlink->time_base = mainlink->time_base;

328 outlink->sample_aspect_ratio = mainlink->sample_aspect_ratio;

329 outlink->frame_rate = mainlink->frame_rate;

330 if ((ret = ff_framesync_configure(&s->fs)) < 0)

331 return ret;

332

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

334

335 if (av_cmp_q(mainlink->time_base, outlink->time_base) ||

336 av_cmp_q(ctx->inputs[1]->time_base, outlink->time_base))

337 av_log(ctx, AV_LOG_WARNING, "not matching timebases found between first input: %d/%d and second input %d/%d, results may be incorrect!\n",

338 mainlink->time_base.num, mainlink->time_base.den,

339 ctx->inputs[1]->time_base.num, ctx->inputs[1]->time_base.den);

340

341 return 0;

342 }

343

344 static int activate(AVFilterContext *ctx)

345 {

346 IdentityContext *s = ctx->priv;

347 return ff_framesync_activate(&s->fs);

348 }

349

350 static av_cold void uninit(AVFilterContext *ctx)

351 {

352 IdentityContext *s = ctx->priv;

353

354 if (s->nb_frames > 0) {

355 char buf[256];

356

357 buf[0] = 0;

358 for (int j = 0; j < s->nb_components; j++) {

359 int c = s->is_rgb ? s->rgba_map[j] : j;

360 av_strlcatf(buf, sizeof(buf), " %c:%f", s->comps[j], s->score_comp[c] / s->nb_frames);

361 }

362

363 av_log(ctx, AV_LOG_INFO, "%s%s average:%f min:%f max:%f\n",

364 ctx->filter->name,

365 buf,

366 s->score / s->nb_frames,

367 s->min_score,

368 s->max_score);

369 }

370

371 ff_framesync_uninit(&s->fs);

372 for (int t = 0; t < s->nb_threads && s->scores; t++)

373 av_freep(&s->scores[t]);

374 av_freep(&s->scores);

375 }

376

377 static const AVFilterPad identity_inputs[] = {

378 {

379 .name = "main",

380 .type = AVMEDIA_TYPE_VIDEO,

381 },{

382 .name = "reference",

383 .type = AVMEDIA_TYPE_VIDEO,

384 .config_props = config_input_ref,

385 },

386 };

387

388 static const AVFilterPad identity_outputs[] = {

389 {

390 .name = "default",

391 .type = AVMEDIA_TYPE_VIDEO,

392 .config_props = config_output,

393 },

394 };

395

396 static const AVOption options[] = {

397 { NULL }

398 };

399

400 #if CONFIG_IDENTITY_FILTER

401

402 #define identity_options options

403 FRAMESYNC_DEFINE_CLASS(identity, IdentityContext, fs);

404

405 const AVFilter ff_vf_identity = {

406 .name = "identity",

407 .description = NULL_IF_CONFIG_SMALL("Calculate the Identity between two video streams."),

408 .preinit = identity_framesync_preinit,

409 .init = init,

410 .uninit = uninit,

411 .activate = activate,

412 .priv_size = sizeof(IdentityContext),

413 .priv_class = &identity_class,

414 FILTER_INPUTS(identity_inputs),

415 FILTER_OUTPUTS(identity_outputs),

416 FILTER_PIXFMTS_ARRAY(pix_fmts),

417 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |

418 AVFILTER_FLAG_SLICE_THREADS |

419 AVFILTER_FLAG_METADATA_ONLY,

420 };

421

422 #endif /* CONFIG_IDENTITY_FILTER */

423

424 #if CONFIG_MSAD_FILTER

425

426 #define msad_options options

427 FRAMESYNC_DEFINE_CLASS(msad, IdentityContext, fs);

428

429 const AVFilter ff_vf_msad = {

430 .name = "msad",

431 .description = NULL_IF_CONFIG_SMALL("Calculate the MSAD between two video streams."),

432 .preinit = msad_framesync_preinit,

433 .init = init,

434 .uninit = uninit,

435 .activate = activate,

436 .priv_size = sizeof(IdentityContext),

437 .priv_class = &msad_class,

438 FILTER_INPUTS(identity_inputs),

439 FILTER_OUTPUTS(identity_outputs),

440 FILTER_PIXFMTS_ARRAY(pix_fmts),

441 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |

442 AVFILTER_FLAG_SLICE_THREADS |

443 AVFILTER_FLAG_METADATA_ONLY,

444 };

445

446 #endif /* CONFIG_MSAD_FILTER */

AV_PIX_FMT_GBRAP16

#define AV_PIX_FMT_GBRAP16

Definition: pixfmt.h:481

ff_framesync_configure

int ff_framesync_configure(FFFrameSync *fs)

Configure a frame sync structure.

Definition: framesync.c:134

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

IdentityContext::nb_components

int nb_components

Definition: vf_identity.c:49

#define td

Definition: regdef.h:70

AVPixelFormat

Pixel format.

Definition: pixfmt.h:64

IdentityContext::sad

ff_scene_sad_fn sad

Definition: vf_identity.c:57

INFINITY

#define INFINITY

Definition: mathematics.h:67

ff_vf_identity

const AVFilter ff_vf_identity

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_framesync_uninit

void ff_framesync_uninit(FFFrameSync *fs)

Free all memory currently allocated.

Definition: framesync.c:304

comp

static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)

Definition: eamad.c:80

ff_filter_frame

int ff_filter_frame(AVFilterLink *link, AVFrame *frame)

Send a frame of data to the next filter.

Definition: avfilter.c:969

av_pix_fmt_desc_get

const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:2888

FILTER_PIXFMTS_ARRAY

#define FILTER_PIXFMTS_ARRAY(array)

Definition: internal.h:174

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

IdentityContext::fs

FFFrameSync fs

Definition: vf_identity.c:41

config_input_ref

static int config_input_ref(AVFilterLink *inlink)

Definition: vf_identity.c:261

AVFrame

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

Definition: frame.h:330

pixdesc.h

uint8_t w

Definition: llviddspenc.c:38

ThreadData::ref_linesize

int ref_linesize

Definition: vf_bm3d.c:58

IdentityContext::score

double score

Definition: vf_identity.c:42

do_identity

static int do_identity(FFFrameSync *fs)

Definition: vf_identity.c:172

AVOption

AVOption.

Definition: opt.h:251

PF_NOALPHA

#define PF_NOALPHA(suf)

FRAMESYNC_DEFINE_CLASS

#define FRAMESYNC_DEFINE_CLASS(name, context, field)

Definition: framesync.h:351

IdentityContext::is_msad

int is_msad

Definition: vf_identity.c:45

AV_PIX_FMT_YUV440P

@ AV_PIX_FMT_YUV440P

planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)

Definition: pixfmt.h:99

AVDictionary

Definition: dict.c:32

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

AVFilter::name

const char * name

Filter name.

Definition: avfilter.h:165

FFFrameSync

Frame sync structure.

Definition: framesync.h:168

video.h

AVFilterLink

A link between two filters.

Definition: avfilter.h:522

av_strlcatf

size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)

Definition: avstring.c:104

AV_PIX_FMT_GRAY9

#define AV_PIX_FMT_GRAY9

Definition: pixfmt.h:439

formats.h

AV_PIX_FMT_GBRP14

#define AV_PIX_FMT_GBRP14

Definition: pixfmt.h:477

AV_PIX_FMT_GBRAP

@ AV_PIX_FMT_GBRAP

planar GBRA 4:4:4:4 32bpp

Definition: pixfmt.h:205

set_meta

static void set_meta(AVFilterContext *ctx, AVDictionary **metadata, const char *key, char comp, float d)

Definition: vf_identity.c:154

IdentityContext::filter_line

unsigned(* filter_line)(const uint8_t *buf, const uint8_t *ref, int w)

Definition: vf_identity.c:54

IdentityContext::comps

char comps[4]

Definition: vf_identity.c:48

AV_PIX_FMT_GBRP10

#define AV_PIX_FMT_GBRP10

Definition: pixfmt.h:475

AV_PIX_FMT_GRAY16

#define AV_PIX_FMT_GRAY16

Definition: pixfmt.h:443

IdentityContext

Definition: vf_identity.c:39

AVRational::num

int num

Numerator.

Definition: rational.h:59

AVFilterPad

A filter pad used for either input or output.

Definition: internal.h:49

identity_line_16bit

static unsigned identity_line_16bit(const uint8_t *mmain_line, const uint8_t *rref_line, int outw)

Definition: vf_identity.c:73

AV_PIX_FMT_YUVJ411P

@ AV_PIX_FMT_YUVJ411P

planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...

Definition: pixfmt.h:276

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

av_cold

#define av_cold

Definition: attributes.h:90

AV_PIX_FMT_YUVJ422P

@ AV_PIX_FMT_YUVJ422P

planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...

Definition: pixfmt.h:79

AV_PIX_FMT_GBRAP10

#define AV_PIX_FMT_GBRAP10

Definition: pixfmt.h:479

#define s(width, name)

Definition: cbs_vp9.c:256

AV_PIX_FMT_GBRAP12

#define AV_PIX_FMT_GBRAP12

Definition: pixfmt.h:480

AV_CEIL_RSHIFT

#define AV_CEIL_RSHIFT(a, b)

Definition: common.h:50

IdentityContext::max

int max[4]

Definition: vf_identity.c:47

identity_outputs

static const AVFilterPad identity_outputs[]

Definition: vf_identity.c:388

slice_end

static int slice_end(AVCodecContext *avctx, AVFrame *pict)

Handle slice ends.

Definition: mpeg12dec.c:2006

AVFilterLink::sample_aspect_ratio

AVRational sample_aspect_ratio

agreed upon sample aspect ratio

Definition: avfilter.h:534

AVFilterLink::frame_rate

AVRational frame_rate

Frame rate of the stream on the link, or 1/0 if unknown or variable; if left to 0/0,...

Definition: avfilter.h:617

ctx

AVFormatContext * ctx

Definition: movenc.c:48

IdentityContext::nb_frames

uint64_t nb_frames

Definition: vf_identity.c:43

AV_PIX_FMT_GRAY14

#define AV_PIX_FMT_GRAY14

Definition: pixfmt.h:442

key

const char * key

Definition: hwcontext_opencl.c:174

FILTER_INPUTS

#define FILTER_INPUTS(array)

Definition: internal.h:194

AV_PIX_FMT_YUVJ444P

@ AV_PIX_FMT_YUVJ444P

planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...

Definition: pixfmt.h:80

arg

const char * arg

Definition: jacosubdec.c:67

AV_PIX_FMT_GRAY10

#define AV_PIX_FMT_GRAY10

Definition: pixfmt.h:440

ff_scene_sad_get_fn

ff_scene_sad_fn ff_scene_sad_get_fn(int depth)

Definition: scene_sad.c:59

AV_PIX_FMT_GBRP16

#define AV_PIX_FMT_GBRP16

Definition: pixfmt.h:478

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

NULL

#define NULL

Definition: coverity.c:32

IdentityContext::filter_slice

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

Definition: vf_identity.c:55

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

Definition: cbs_vp9.c:258

IdentityContext::max_score

double max_score

Definition: vf_identity.c:42

AV_PIX_FMT_YUVJ420P

@ AV_PIX_FMT_YUVJ420P

planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...

Definition: pixfmt.h:78

ThreadData::planewidth

int planewidth[4]

Definition: vf_identity.c:90

AV_PIX_FMT_GRAY8

@ AV_PIX_FMT_GRAY8

Y , 8bpp.

Definition: pixfmt.h:74

AV_PIX_FMT_GBRP9

#define AV_PIX_FMT_GBRP9

Definition: pixfmt.h:474

IdentityContext::rgba_map

uint8_t rgba_map[4]

Definition: vf_identity.c:46

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

scene_sad.h

compute_images_identity

static int compute_images_identity(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

Definition: vf_identity.c:125

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

ff_framesync_init_dualinput

int ff_framesync_init_dualinput(FFFrameSync *fs, AVFilterContext *parent)

Initialize a frame sync structure for dualinput.

Definition: framesync.c:372

master

const char * master

Definition: vf_curves.c:129

#define P

for

for(k=2;k<=8;++k)

Definition: h264pred_template.c:425

pix_fmts

static enum AVPixelFormat pix_fmts[]

Definition: vf_identity.c:246

uninit

static av_cold void uninit(AVFilterContext *ctx)

Definition: vf_identity.c:350

ff_vf_msad

const AVFilter ff_vf_msad

ff_scene_sad_fn

void(* ff_scene_sad_fn)(SCENE_SAD_PARAMS)

Definition: scene_sad.h:34

AVFilterLink::src

AVFilterContext * src

source filter

Definition: avfilter.h:523

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:191

internal.h

ThreadData::score

uint64_t ** score

Definition: vf_identity.c:92

identity_line_8bit

static unsigned identity_line_8bit(const uint8_t *main_line, const uint8_t *ref_line, int outw)

Definition: vf_identity.c:63

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

Definition: cbs_h2645.c:269

options

static const AVOption options[]

Definition: vf_identity.c:396

AVFilterLink::w

int w

agreed upon image width

Definition: avfilter.h:532

AV_PIX_FMT_GBRP12

#define AV_PIX_FMT_GBRP12

Definition: pixfmt.h:476

ff_filter_get_nb_threads

int ff_filter_get_nb_threads(AVFilterContext *ctx)

Get number of threads for current filter instance.

Definition: avfilter.c:777

ThreadData

Used for passing data between threads.

Definition: dsddec.c:69

value

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 value

Definition: writing_filters.txt:86

IdentityContext::nb_threads

int nb_threads

Definition: vf_identity.c:50

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

AV_PIX_FMT_YUVJ440P

@ AV_PIX_FMT_YUVJ440P

planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range

Definition: pixfmt.h:100

AVFilterPad::name

const char * name

Pad name.

Definition: internal.h:55

av_calloc

void * av_calloc(size_t nmemb, size_t size)

Definition: mem.c:262

av_cmp_q

static int av_cmp_q(AVRational a, AVRational b)

Compare two rationals.

Definition: rational.h:89

AVFilter

Filter definition.

Definition: avfilter.h:161

ret

Definition: filter_design.txt:187

IdentityContext::min_score

double min_score

Definition: vf_identity.c:42

activate

static int activate(AVFilterContext *ctx)

Definition: vf_identity.c:344

init

static av_cold int init(AVFilterContext *ctx)

Definition: vf_identity.c:237

framesync.h

AVFilterLink::h

int h

agreed upon image height

Definition: avfilter.h:533

AVRational::den

int den

Denominator.

Definition: rational.h:60

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:65

avfilter.h

AVFILTER_FLAG_METADATA_ONLY

#define AVFILTER_FLAG_METADATA_ONLY

The filter is a "metadata" filter - it does not modify the frame data in any way.

Definition: avfilter.h:133

IdentityContext::scores

uint64_t ** scores

Definition: vf_identity.c:53

ref

static int ref[MAX_W *MAX_W]

Definition: jpeg2000dwt.c:112

ThreadData::main_linesize

int main_linesize[4]

Definition: vf_identity.c:88

identity_inputs

static const AVFilterPad identity_inputs[]

Definition: vf_identity.c:377

AVFilterLink::time_base

AVRational time_base

Define the time base used by the PTS of the frames/samples which will pass through this link.

Definition: avfilter.h:555

AVFilterContext

An instance of a filter.

Definition: avfilter.h:392

IdentityContext::planeheight

int planeheight[4]

Definition: vf_identity.c:52

AV_PIX_FMT_GBRP

@ AV_PIX_FMT_GBRP

planar GBR 4:4:4 24bpp

Definition: pixfmt.h:158

AVFILTER_FLAG_SLICE_THREADS

#define AVFILTER_FLAG_SLICE_THREADS

The filter supports multithreading by splitting frames into multiple parts and processing them concur...

Definition: avfilter.h:117

desc

const char * desc

Definition: libsvtav1.c:83

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

AVPixFmtDescriptor

Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...

Definition: pixdesc.h:69

IdentityContext::is_rgb

int is_rgb

Definition: vf_identity.c:44

ThreadData::nb_components

int nb_components

Definition: vf_identity.c:93

FILTER_OUTPUTS

#define FILTER_OUTPUTS(array)

Definition: internal.h:195

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

av_dict_set

int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)

Set the given entry in *pm, overwriting an existing entry.

Definition: dict.c:86

AV_PIX_FMT_YUV411P

@ AV_PIX_FMT_YUV411P

planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)

Definition: pixfmt.h:73

ff_fill_rgba_map

int ff_fill_rgba_map(uint8_t *rgba_map, enum AVPixelFormat pix_fmt)

Definition: drawutils.c:35

ThreadData::planeheight

int planeheight[4]

Definition: vf_identity.c:91

Definition: ffmpeg_filter.c:156

AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL

#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL

Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...

Definition: avfilter.h:150

AV_PIX_FMT_YUV410P

@ AV_PIX_FMT_YUV410P

planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)

Definition: pixfmt.h:72

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

#define PF(suf)

ff_framesync_activate

int ff_framesync_activate(FFFrameSync *fs)

Examine the frames in the filter's input and try to produce output.

Definition: framesync.c:355

avstring.h

compute_images_msad

static int compute_images_msad(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

Definition: vf_identity.c:97

ff_framesync_dualinput_get

int ff_framesync_dualinput_get(FFFrameSync *fs, AVFrame **f0, AVFrame **f1)

Definition: framesync.c:390

AV_PIX_FMT_GRAY12

#define AV_PIX_FMT_GRAY12

Definition: pixfmt.h:441

drawutils.h

IdentityContext::planewidth

int planewidth[4]

Definition: vf_identity.c:51

ff_filter_execute

static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)

Definition: internal.h:146

ThreadData::ref_data

const uint8_t * ref_data[4]

Definition: vf_identity.c:87

int

Definition: ffmpeg_filter.c:156

snprintf

#define snprintf

Definition: snprintf.h:34

config_output

static int config_output(AVFilterLink *outlink)

Definition: vf_identity.c:315

IdentityContext::score_comp

double score_comp[4]

Definition: vf_identity.c:42

ThreadData::main_data

const uint8_t * main_data[4]

Definition: vf_identity.c:86

Generated on Tue Feb 28 2023 21:33:56 for FFmpeg by doxygen 1.8.17