FFmpeg: libavfilter/vf_decimate.c Source File

79 { "ppsrc", "mark main input as a pre-processed input and activate clean source input stream", OFFSET(ppsrc), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },

80 { "chroma", "set whether or not chroma is considered in the metric calculations", OFFSET(chroma), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },

81 { "mixed", "set whether or not the input only partially contains content to be decimated", OFFSET(mixed), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },

82 { NULL }

83 };

85 AVFILTER_DEFINE_CLASS(decimate);

87 static void calc_diffs(const DecimateContext *dm, struct qitem *q,

88 const AVFrame *f1, const AVFrame *f2)

89 {

90 int64_t maxdiff = -1;

91 int64_t *bdiffs = dm->bdiffs;

92 int plane, i, j;

94 memset(bdiffs, 0, dm->bdiffsize * sizeof(*bdiffs));

96 for (plane = 0; plane < (dm->chroma && f1->data[2] ? 3 : 1); plane++) {

97 int x, y, xl;

98 const int linesize1 = f1->linesize[plane];

99 const int linesize2 = f2->linesize[plane];

100 const uint8_t *f1p = f1->data[plane];

101 const uint8_t *f2p = f2->data[plane];

102 int width = plane ? AV_CEIL_RSHIFT(f1->width, dm->hsub) : f1->width;

103 int height = plane ? AV_CEIL_RSHIFT(f1->height, dm->vsub) : f1->height;

104 int hblockx = dm->blockx / 2;

105 int hblocky = dm->blocky / 2;

106

107 if (plane) {

108 hblockx >>= dm->hsub;

109 hblocky >>= dm->vsub;

110 }

111

112 for (y = 0; y < height; y++) {

113 int ydest = y / hblocky;

114 int xdest = 0;

115

116 #define CALC_DIFF(nbits) do { \

117 for (x = 0; x < width; x += hblockx) { \

118 int64_t acc = 0; \

119 int m = FFMIN(width, x + hblockx); \

120 for (xl = x; xl < m; xl++) \

121 acc += abs(((const uint##nbits##_t *)f1p)[xl] - \

122 ((const uint##nbits##_t *)f2p)[xl]); \

123 bdiffs[ydest * dm->nxblocks + xdest] += acc; \

124 xdest++; \

125 } \

126 } while (0)

127 if (dm->depth == 8) CALC_DIFF(8);

128 else CALC_DIFF(16);

129

130 f1p += linesize1;

131 f2p += linesize2;

132 }

133 }

134

135 for (i = 0; i < dm->nyblocks - 1; i++) {

136 for (j = 0; j < dm->nxblocks - 1; j++) {

137 int64_t tmp = bdiffs[ i * dm->nxblocks + j ]

138 + bdiffs[ i * dm->nxblocks + j + 1]

139 + bdiffs[(i + 1) * dm->nxblocks + j ]

140 + bdiffs[(i + 1) * dm->nxblocks + j + 1];

141 if (tmp > maxdiff)

142 maxdiff = tmp;

143 }

144 }

145

146 q->totdiff = 0;

147 for (i = 0; i < dm->bdiffsize; i++)

148 q->totdiff += bdiffs[i];

149 q->maxbdiff = maxdiff;

150 }

151

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

153 {

154 int scpos = -1, duppos = -1;

155 int drop = INT_MIN, i, lowest = 0, ret;

156 AVFilterContext *ctx = inlink->dst;

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

158 DecimateContext *dm = ctx->priv;

159 AVFrame *prv;

160

161 /* update frames queue(s) */

162 if (FF_INLINK_IDX(inlink) == INPUT_MAIN) {

163 dm->queue[dm->fid].frame = in;

164 dm->got_frame[INPUT_MAIN] = 1;

165 } else {

166 dm->clean_src[dm->fid] = in;

167 dm->got_frame[INPUT_CLEANSRC] = 1;

168 }

169 if (!dm->got_frame[INPUT_MAIN] || (dm->ppsrc && !dm->got_frame[INPUT_CLEANSRC]))

170 return 0;

171 dm->got_frame[INPUT_MAIN] = dm->got_frame[INPUT_CLEANSRC] = 0;

172

173 if (dm->ppsrc)

174 in = dm->queue[dm->fid].frame;

175

176 if (in) {

177 /* update frame metrics */

178 prv = dm->fid ? dm->queue[dm->fid - 1].frame : dm->last;

179 if (!prv) {

180 dm->queue[dm->fid].maxbdiff = INT64_MAX;

181 dm->queue[dm->fid].totdiff = INT64_MAX;

182 } else {

183 calc_diffs(dm, &dm->queue[dm->fid], prv, in);

184 }

185 if (++dm->fid != dm->cycle)

186 return 0;

187 av_frame_free(&dm->last);

188 dm->last = av_frame_clone(in);

189 dm->fid = 0;

190

191 /* we have a complete cycle, select the frame to drop */

192 lowest = 0;

193 for (i = 0; i < dm->cycle; i++) {

194 if (dm->queue[i].totdiff > dm->scthresh)

195 scpos = i;

196 if (dm->queue[i].maxbdiff < dm->queue[lowest].maxbdiff)

197 lowest = i;

198 }

199 if (dm->queue[lowest].maxbdiff < dm->dupthresh)

200 duppos = lowest;

201

202 if (dm->mixed && duppos < 0) {

203 drop = -1; // no drop if mixed content + no frame in cycle below threshold

204 } else {

205 drop = scpos >= 0 && duppos < 0 ? scpos : lowest;

206 }

207 }

208

209 /* metrics debug */

210 if (av_log_get_level() >= AV_LOG_DEBUG) {

211 av_log(ctx, AV_LOG_DEBUG, "1/%d frame drop:\n", dm->cycle);

212 for (i = 0; i < dm->cycle && dm->queue[i].frame; i++) {

213 av_log(ctx, AV_LOG_DEBUG," #%d: totdiff=%08"PRIx64" maxbdiff=%08"PRIx64"%s%s%s%s\n",

214 i + 1, dm->queue[i].totdiff, dm->queue[i].maxbdiff,

215 i == scpos ? " sc" : "",

216 i == duppos ? " dup" : "",

217 i == lowest ? " lowest" : "",

218 i == drop ? " [DROP]" : "");

219 }

220 }

221

222 /* push all frames except the drop */

223 ret = 0;

224 for (i = 0; i < dm->cycle && dm->queue[i].frame; i++) {

225 if (i == drop) {

226 if (dm->ppsrc)

227 av_frame_free(&dm->clean_src[i]);

228 av_frame_free(&dm->queue[i].frame);

229 } else {

230 AVFrame *frame = dm->queue[i].frame;

231 dm->queue[i].frame = NULL;

232 if (frame->pts != AV_NOPTS_VALUE && dm->start_pts == AV_NOPTS_VALUE)

233 dm->start_pts = av_rescale_q(frame->pts, dm->in_tb, outlink->time_base);

234

235 if (dm->ppsrc) {

236 av_frame_free(&frame);

237 frame = dm->clean_src[i];

238 if (!frame)

239 continue;

240 dm->clean_src[i] = NULL;

241 }

242

243 frame->pts = dm->last_duration ? dm->last_pts + dm->last_duration :

244 (dm->start_pts == AV_NOPTS_VALUE ? 0 : dm->start_pts);

245 frame->duration = dm->mixed ? av_div_q(drop < 0 ? dm->nondec_tb : dm->dec_tb, outlink->time_base).num : 1;

246 dm->last_duration = frame->duration;

247 dm->last_pts = frame->pts;

248 ret = ff_filter_frame(outlink, frame);

249 if (ret < 0)

250 break;

251 }

252 }

253

254 return ret;

255 }

256

257 static int activate(AVFilterContext *ctx)

258 {

259 DecimateContext *dm = ctx->priv;

260 AVFrame *frame = NULL;

261 int ret = 0, status;

262 int64_t pts;

263

264 FF_FILTER_FORWARD_STATUS_BACK_ALL(ctx->outputs[0], ctx);

265

266 if ((dm->got_frame[INPUT_MAIN] == 0) && !(dm->eof & (1 << INPUT_MAIN)) &&

267 (ret = ff_inlink_consume_frame(ctx->inputs[INPUT_MAIN], &frame)) > 0) {

268 ret = filter_frame(ctx->inputs[INPUT_MAIN], frame);

269 if (ret < 0)

270 return ret;

271 }

272 if (ret < 0)

273 return ret;

274 if (dm->ppsrc &&

275 (dm->got_frame[INPUT_CLEANSRC] == 0) && !(dm->eof & (1 << INPUT_CLEANSRC)) &&

276 (ret = ff_inlink_consume_frame(ctx->inputs[INPUT_CLEANSRC], &frame)) > 0) {

277 ret = filter_frame(ctx->inputs[INPUT_CLEANSRC], frame);

278 if (ret < 0)

279 return ret;

280 }

281 if (ret < 0) {

282 return ret;

283 } else if (dm->eof == ((1 << INPUT_MAIN) | (dm->ppsrc << INPUT_CLEANSRC))) {

284 ff_outlink_set_status(ctx->outputs[0], AVERROR_EOF, dm->last_pts);

285 return 0;

286 } else if (!(dm->eof & (1 << INPUT_MAIN)) && ff_inlink_acknowledge_status(ctx->inputs[INPUT_MAIN], &status, &pts)) {

287 if (status == AVERROR_EOF) { // flushing

288 dm->eof |= 1 << INPUT_MAIN;

289 if (dm->ppsrc)

290 filter_frame(ctx->inputs[INPUT_CLEANSRC], NULL);

291 filter_frame(ctx->inputs[INPUT_MAIN], NULL);

292 ff_outlink_set_status(ctx->outputs[0], AVERROR_EOF, dm->last_pts);

293 return 0;

294 }

295 } else if (dm->ppsrc && !(dm->eof & (1 << INPUT_CLEANSRC)) && ff_inlink_acknowledge_status(ctx->inputs[INPUT_CLEANSRC], &status, &pts)) {

296 if (status == AVERROR_EOF) { // flushing

297 dm->eof |= 1 << INPUT_CLEANSRC;

298 filter_frame(ctx->inputs[INPUT_MAIN], NULL);

299 filter_frame(ctx->inputs[INPUT_CLEANSRC], NULL);

300 ff_outlink_set_status(ctx->outputs[0], AVERROR_EOF, dm->last_pts);

301 return 0;

302 }

303 }

304

305 if (ff_inlink_queued_frames(ctx->inputs[INPUT_MAIN]) > 0 && (!dm->ppsrc ||

306 (dm->ppsrc && ff_inlink_queued_frames(ctx->inputs[INPUT_CLEANSRC]) > 0))) {

307 ff_filter_set_ready(ctx, 100);

308 } else if (ff_outlink_frame_wanted(ctx->outputs[0])) {

309 if (dm->got_frame[INPUT_MAIN] == 0)

310 ff_inlink_request_frame(ctx->inputs[INPUT_MAIN]);

311 if (dm->ppsrc && (dm->got_frame[INPUT_CLEANSRC] == 0))

312 ff_inlink_request_frame(ctx->inputs[INPUT_CLEANSRC]);

313 }

314 return 0;

315 }

316

317 static av_cold int decimate_init(AVFilterContext *ctx)

318 {

319 DecimateContext *dm = ctx->priv;

320 AVFilterPad pad = {

321 .name = "main",

322 .type = AVMEDIA_TYPE_VIDEO,

323 };

324 int ret;

325

326 if ((ret = ff_append_inpad(ctx, &pad)) < 0)

327 return ret;

328

329 if (dm->ppsrc) {

330 pad.name = "clean_src";

331 pad.config_props = NULL;

332 if ((ret = ff_append_inpad(ctx, &pad)) < 0)

333 return ret;

334 }

335

336 if ((dm->blockx & (dm->blockx - 1)) ||

337 (dm->blocky & (dm->blocky - 1))) {

338 av_log(ctx, AV_LOG_ERROR, "blockx and blocky settings must be power of two\n");

339 return AVERROR(EINVAL);

340 }

341

342 dm->start_pts = AV_NOPTS_VALUE;

343 dm->last_duration = 0;

344

345 return 0;

346 }

347

348 static av_cold void decimate_uninit(AVFilterContext *ctx)

349 {

350 int i;

351 DecimateContext *dm = ctx->priv;

352

353 av_frame_free(&dm->last);

354 av_freep(&dm->bdiffs);

355 if (dm->queue) {

356 for (i = 0; i < dm->cycle; i++)

357 av_frame_free(&dm->queue[i].frame);

358 }

359 av_freep(&dm->queue);

360 if (dm->clean_src) {

361 for (i = 0; i < dm->cycle; i++)

362 av_frame_free(&dm->clean_src[i]);

363 }

364 av_freep(&dm->clean_src);

365 }

366

367 static const enum AVPixelFormat pix_fmts[] = {

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

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

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

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

372 AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,

373 AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,

374 AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,

375 AV_PIX_FMT_YUVJ411P,

376 AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14,

377 AV_PIX_FMT_GRAY16,

378 AV_PIX_FMT_NONE

379 };

380

381 static int config_output(AVFilterLink *outlink)

382 {

383 FilterLink *outl = ff_filter_link(outlink);

384 AVFilterContext *ctx = outlink->src;

385 DecimateContext *dm = ctx->priv;

386 const AVFilterLink *inlink = ctx->inputs[INPUT_MAIN];

387 FilterLink *inl = ff_filter_link(ctx->inputs[INPUT_MAIN]);

388 AVRational fps = inl->frame_rate;

389 int max_value;

390 const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(inlink->format);

391 const int w = inlink->w;

392 const int h = inlink->h;

393

394 dm->hsub = pix_desc->log2_chroma_w;

395 dm->vsub = pix_desc->log2_chroma_h;

396 dm->depth = pix_desc->comp[0].depth;

397 max_value = (1 << dm->depth) - 1;

398 dm->scthresh = (int64_t)(((int64_t)max_value * w * h * dm->scthresh_flt) / 100);

399 dm->dupthresh = (int64_t)(((int64_t)max_value * dm->blockx * dm->blocky * dm->dupthresh_flt) / 100);

400 dm->nxblocks = (w + dm->blockx/2 - 1) / (dm->blockx/2);

401 dm->nyblocks = (h + dm->blocky/2 - 1) / (dm->blocky/2);

402 dm->bdiffsize = dm->nxblocks * dm->nyblocks;

403 dm->bdiffs = av_malloc_array(dm->bdiffsize, sizeof(*dm->bdiffs));

404 dm->queue = av_calloc(dm->cycle, sizeof(*dm->queue));

405 dm->in_tb = inlink->time_base;

406 dm->nondec_tb = av_inv_q(fps);

407 dm->dec_tb = av_mul_q(dm->nondec_tb, (AVRational){dm->cycle, dm->cycle - 1});

408

409 if (!dm->bdiffs || !dm->queue)

410 return AVERROR(ENOMEM);

411

412 if (dm->ppsrc) {

413 dm->clean_src = av_calloc(dm->cycle, sizeof(*dm->clean_src));

414 if (!dm->clean_src)

415 return AVERROR(ENOMEM);

416 }

417

418 if (!fps.num || !fps.den) {

419 av_log(ctx, AV_LOG_ERROR, "The input needs a constant frame rate; "

420 "current rate of %d/%d is invalid\n", fps.num, fps.den);

421 return AVERROR(EINVAL);

422 }

423

424 if (dm->mixed) {

425 outlink->time_base = av_gcd_q(dm->nondec_tb, dm->dec_tb, AV_TIME_BASE / 2, AV_TIME_BASE_Q);

426 av_log(ctx, AV_LOG_VERBOSE, "FPS: %d/%d -> VFR (use %d/%d if CFR required)\n",

427 fps.num, fps.den, outlink->time_base.den, outlink->time_base.num);

428 } else {

429 outlink->time_base = dm->dec_tb;

430 outl->frame_rate = av_inv_q(outlink->time_base);

431 av_log(ctx, AV_LOG_VERBOSE, "FPS: %d/%d -> %d/%d\n",

432 fps.num, fps.den, outl->frame_rate.num, outl->frame_rate.den);

433 }

434 outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;

435 if (dm->ppsrc) {

436 outlink->w = ctx->inputs[INPUT_CLEANSRC]->w;

437 outlink->h = ctx->inputs[INPUT_CLEANSRC]->h;

438 } else {

439 outlink->w = inlink->w;

440 outlink->h = inlink->h;

441 }

442 return 0;

443 }

444

445 static const AVFilterPad decimate_outputs[] = {

446 {

447 .name = "default",

448 .type = AVMEDIA_TYPE_VIDEO,

449 .config_props = config_output,

450 },

451 };

452

453 const FFFilter ff_vf_decimate = {

454 .p.name = "decimate",

455 .p.description = NULL_IF_CONFIG_SMALL("Decimate frames (post field matching filter)."),

456 .p.priv_class = &decimate_class,

457 .p.flags = AVFILTER_FLAG_DYNAMIC_INPUTS,

458 .init = decimate_init,

459 .activate = activate,

460 .uninit = decimate_uninit,

461 .priv_size = sizeof(DecimateContext),

462 FILTER_OUTPUTS(decimate_outputs),

463 FILTER_PIXFMTS_ARRAY(pix_fmts),

464 };

#define PF(suf)

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

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

DecimateContext::start_pts

int64_t start_pts

base for output timestamps

Definition: vf_decimate.c:47

DecimateContext::in_tb

AVRational in_tb

Definition: vf_decimate.c:54

FILTER_PIXFMTS_ARRAY

#define FILTER_PIXFMTS_ARRAY(array)

Definition: filters.h:243

DecimateContext::depth

int depth

Definition: vf_decimate.c:50

DecimateContext::queue

struct qitem * queue

window of cycle frames and the associated data diff

Definition: vf_decimate.c:39

qitem

Definition: vf_decimate.c:31

ff_filter_frame

int ff_filter_frame(AVFilterLink *link, AVFrame *frame)

Send a frame of data to the next filter.

Definition: avfilter.c:1067

av_pix_fmt_desc_get

const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:3456

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

av_div_q

AVRational av_div_q(AVRational b, AVRational c)

Divide one rational by another.

Definition: rational.c:88

pix_fmts

static enum AVPixelFormat pix_fmts[]

Definition: vf_decimate.c:367

AV_TIME_BASE_Q

#define AV_TIME_BASE_Q

Internal time base represented as fractional value.

Definition: avutil.h:263

int64_t

long long int64_t

Definition: coverity.c:34

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

AVFrame

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

Definition: frame.h:427

pixdesc.h

AVFrame::width

int width

Definition: frame.h:499

uint8_t w

Definition: llviddspenc.c:38

AVComponentDescriptor::depth

int depth

Number of bits in the component.

Definition: pixdesc.h:57

AVOption

AVOption.

Definition: opt.h:429

chroma

static av_always_inline void chroma(WaveformContext *s, AVFrame *in, AVFrame *out, int component, int intensity, int offset_y, int offset_x, int column, int mirror, int jobnr, int nb_jobs)

Definition: vf_waveform.c:1639

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:226

DecimateContext::vsub

int vsub

chroma subsampling values

Definition: vf_decimate.c:49

DecimateContext::scthresh_flt

double scthresh_flt

Definition: vf_decimate.c:61

AV_PIX_FMT_YUV440P

@ AV_PIX_FMT_YUV440P

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

Definition: pixfmt.h:106

DecimateContext::got_frame

int got_frame[2]

frame request flag for each input stream

Definition: vf_decimate.c:44

AVFilter::name

const char * name

Filter name.

Definition: avfilter.h:220

AVFilterLink

A link between two filters.

Definition: avfilter.h:395

PF_NOALPHA

#define PF_NOALPHA(suf)

DecimateContext::hsub

int hsub

Definition: vf_decimate.c:49

AV_PIX_FMT_GRAY9

#define AV_PIX_FMT_GRAY9

Definition: pixfmt.h:518

DecimateContext::blocky

int blocky

Definition: vf_decimate.c:64

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:448

qitem::frame

AVFrame * frame

Definition: vf_decimate.c:32

FilterLink

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

Definition: filters.h:128

filter_frame

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

Definition: vf_decimate.c:152

ff_inlink_consume_frame

int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)

Take a frame from the link's FIFO and update the link's stats.

Definition: avfilter.c:1517

FF_FILTER_FORWARD_STATUS_BACK_ALL

#define FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, filter)

Forward the status on an output link to all input links.

Definition: filters.h:651

ff_append_inpad

int ff_append_inpad(AVFilterContext *f, AVFilterPad *p)

Append a new input/output pad to the filter's list of such pads.

Definition: avfilter.c:127

pts

static int64_t pts

Definition: transcode_aac.c:644

AV_PIX_FMT_GRAY16

#define AV_PIX_FMT_GRAY16

Definition: pixfmt.h:522

AVFILTER_FLAG_DYNAMIC_INPUTS

#define AVFILTER_FLAG_DYNAMIC_INPUTS

The number of the filter inputs is not determined just by AVFilter.inputs.

Definition: avfilter.h:156

activate

static int activate(AVFilterContext *ctx)

Definition: vf_decimate.c:257

AVRational::num

int num

Numerator.

Definition: rational.h:59

calc_diffs

static void calc_diffs(const DecimateContext *dm, struct qitem *q, const AVFrame *f1, const AVFrame *f2)

Definition: vf_decimate.c:87

AVFilterPad

A filter pad used for either input or output.

Definition: filters.h:39

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

DecimateContext::bdiffsize

int bdiffsize

Definition: vf_decimate.c:52

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

av_cold

#define av_cold

Definition: attributes.h:106

FFFilter

Definition: filters.h:266

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

ff_outlink_set_status

static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)

Set the status field of a link from the source filter.

Definition: filters.h:628

ff_inlink_request_frame

void ff_inlink_request_frame(AVFilterLink *link)

Mark that a frame is wanted on the link.

Definition: avfilter.c:1620

CALC_DIFF

#define CALC_DIFF(nbits)

AV_CEIL_RSHIFT

#define AV_CEIL_RSHIFT(a, b)

Definition: common.h:60

AV_OPT_TYPE_DOUBLE

@ AV_OPT_TYPE_DOUBLE

Underlying C type is double.

Definition: opt.h:267

AVFilterLink::sample_aspect_ratio

AVRational sample_aspect_ratio

agreed upon sample aspect ratio

Definition: avfilter.h:409

filters.h

ff_vf_decimate

const FFFilter ff_vf_decimate

Definition: vf_decimate.c:453

decimate_options

static const AVOption decimate_options[]

Definition: vf_decimate.c:73

#define P

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:231

ctx

AVFormatContext * ctx

Definition: movenc.c:49

AV_PIX_FMT_GRAY14

#define AV_PIX_FMT_GRAY14

Definition: pixfmt.h:521

av_frame_clone

AVFrame * av_frame_clone(const AVFrame *src)

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

Definition: frame.c:483

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

OFFSET

#define OFFSET(x)

Definition: vf_decimate.c:70

AVPixFmtDescriptor::log2_chroma_w

uint8_t log2_chroma_w

Amount to shift the luma width right to find the chroma width.

Definition: pixdesc.h:80

DecimateContext::nondec_tb

AVRational nondec_tb

Definition: vf_decimate.c:55

FILTER_OUTPUTS

#define FILTER_OUTPUTS(array)

Definition: filters.h:264

DecimateContext::dupthresh

int64_t dupthresh

Definition: vf_decimate.c:62

tmp

static uint8_t tmp[40]

Definition: aes_ctr.c:52

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

DecimateContext::last_pts

int64_t last_pts

last output timestamp

Definition: vf_decimate.c:45

DecimateContext::nxblocks

int nxblocks

Definition: vf_decimate.c:51

AV_PIX_FMT_GRAY10

#define AV_PIX_FMT_GRAY10

Definition: pixfmt.h:519

DecimateContext::bdiffs

int64_t * bdiffs

Definition: vf_decimate.c:53

av_log_get_level

int av_log_get_level(void)

Get the current log level.

Definition: log.c:470

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:76

NULL

#define NULL

Definition: coverity.c:32

DecimateContext::ppsrc

int ppsrc

Definition: vf_decimate.c:65

INPUT_MAIN

#define INPUT_MAIN

Definition: vf_decimate.c:28

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

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

AV_PIX_FMT_YUV440P10

#define AV_PIX_FMT_YUV440P10

Definition: pixfmt.h:541

DecimateContext::eof

uint32_t eof

bitmask for end of stream

Definition: vf_decimate.c:48

AV_PIX_FMT_GRAY8

@ AV_PIX_FMT_GRAY8

Y , 8bpp.

Definition: pixfmt.h:81

ff_inlink_acknowledge_status

int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)

Test and acknowledge the change of status on the link.

Definition: avfilter.c:1464

DecimateContext::dupthresh_flt

double dupthresh_flt

Definition: vf_decimate.c:60

ff_inlink_queued_frames

size_t ff_inlink_queued_frames(AVFilterLink *link)

Get the number of frames available on the link.

Definition: avfilter.c:1480

ff_filter_link

static FilterLink * ff_filter_link(AVFilterLink *link)

Definition: filters.h:198

AVFilterPad::config_props

int(* config_props)(AVFilterLink *link)

Link configuration callback.

Definition: filters.h:119

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

height

#define height

Definition: dsp.h:89

qitem::totdiff

int64_t totdiff

Definition: vf_decimate.c:34

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:247

DecimateContext::chroma

int chroma

Definition: vf_decimate.c:66

AVFilterLink::src

AVFilterContext * src

source filter

Definition: avfilter.h:396

decimate_uninit

static av_cold void decimate_uninit(AVFilterContext *ctx)

Definition: vf_decimate.c:348

DecimateContext::clean_src

AVFrame ** clean_src

frame queue for the clean source

Definition: vf_decimate.c:43

INPUT_CLEANSRC

#define INPUT_CLEANSRC

Definition: vf_decimate.c:29

DecimateContext::blockx

int blockx

Definition: vf_decimate.c:64

DecimateContext::scthresh

int64_t scthresh

Definition: vf_decimate.c:63

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

Definition: cbs_h2645.c:256

FF_INLINK_IDX

#define FF_INLINK_IDX(link)

Find the index of a link.

Definition: filters.h:214

av_gcd_q

AVRational av_gcd_q(AVRational a, AVRational b, int max_den, AVRational def)

Return the best rational so that a and b are multiple of it.

Definition: rational.c:184

DecimateContext::mixed

int mixed

Definition: vf_decimate.c:67

AVFilterLink::w

int w

agreed upon image width

Definition: avfilter.h:407

AV_TIME_BASE

#define AV_TIME_BASE

Internal time base represented as integer.

Definition: avutil.h:253

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:32

decimate_init

static av_cold int decimate_init(AVFilterContext *ctx)

Definition: vf_decimate.c:317

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

av_inv_q

static av_always_inline AVRational av_inv_q(AVRational q)

Invert a rational.

Definition: rational.h:159

AVFilterPad::name

const char * name

Pad name.

Definition: filters.h:45

av_calloc

void * av_calloc(size_t nmemb, size_t size)

Definition: mem.c:264

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

DecimateContext::dec_tb

AVRational dec_tb

Definition: vf_decimate.c:56

DecimateContext::nyblocks

int nyblocks

Definition: vf_decimate.c:51

AVFrame::height

int height

Definition: frame.h:499

status

ov_status_e status

Definition: dnn_backend_openvino.c:100

AVFilterLink::h

int h

agreed upon image height

Definition: avfilter.h:408

AVRational::den

int den

Denominator.

Definition: rational.h:60

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:72

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Underlying C type is int.

Definition: opt.h:259

avfilter.h

AVFILTER_DEFINE_CLASS

AVFILTER_DEFINE_CLASS(decimate)

DecimateContext::fid

int fid

current frame id in the queue

Definition: vf_decimate.c:40

AVPixFmtDescriptor::comp

AVComponentDescriptor comp[4]

Parameters that describe how pixels are packed.

Definition: pixdesc.h:105

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

config_output

static int config_output(AVFilterLink *outlink)

Definition: vf_decimate.c:381

av_mul_q

AVRational av_mul_q(AVRational b, AVRational c)

Multiply two rationals.

Definition: rational.c:80

AVFilterContext

An instance of a filter.

Definition: avfilter.h:274

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:200

FFFilter::p

AVFilter p

The public AVFilter.

Definition: filters.h:270

mem.h

AVPixFmtDescriptor

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

Definition: pixdesc.h:69

AV_OPT_TYPE_BOOL

@ AV_OPT_TYPE_BOOL

Underlying C type is int.

Definition: opt.h:327

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

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

DecimateContext

Definition: vf_decimate.c:37

FLAGS

#define FLAGS

Definition: vf_decimate.c:71

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, a positive or negative value, which is typically indicating the size in bytes of each pict...

Definition: frame.h:472

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

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

AV_PIX_FMT_YUV440P12

#define AV_PIX_FMT_YUV440P12

Definition: pixfmt.h:545

Definition: vp9dsp_template.c:2070

ff_outlink_frame_wanted

the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted() function. If this function returns true

FilterLink::frame_rate

AVRational frame_rate

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

Definition: filters.h:187

width

#define width

Definition: dsp.h:89

AV_PIX_FMT_GRAY12

#define AV_PIX_FMT_GRAY12

Definition: pixfmt.h:520

DecimateContext::filled

int filled