Go to the documentation of this file.
72 #define OFFSET(x) offsetof(SignalstatsContext, x)
73 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
97 s->filters |= 1 <<
s->outfilter;
100 g =
s->rgba_color[1];
101 b =
s->rgba_color[2];
102 s->yuv_color[0] = (( 66*
r + 129*
g + 25*
b + (1<<7)) >> 8) + 16;
103 s->yuv_color[1] = ((-38*
r + -74*
g + 112*
b + (1<<7)) >> 8) + 128;
104 s->yuv_color[2] = ((112*
r + -94*
g + -18*
b + (1<<7)) >> 8) + 128;
161 s->hsub =
desc->log2_chroma_w;
162 s->vsub =
desc->log2_chroma_h;
163 s->depth =
desc->comp[0].depth;
164 s->maxsize = 1 <<
s->depth;
170 if (!
s->histy || !
s->histu || !
s->histv || !
s->histsat)
180 s->cfs =
s->chromaw *
s->chromah;
189 if (!
s->frame_sat || !
s->frame_hue)
197 const int chromax = x >>
s->hsub;
198 const int chromay = y >>
s->vsub;
199 f->data[0][y *
f->linesize[0] + x] =
s->yuv_color[0];
200 f->data[1][chromay *
f->linesize[1] + chromax] =
s->yuv_color[1];
201 f->data[2][chromay *
f->linesize[2] + chromax] =
s->yuv_color[2];
206 const int chromax = x >>
s->hsub;
207 const int chromay = y >>
s->vsub;
208 const int mult = 1 << (
s->depth - 8);
209 AV_WN16(
f->data[0] + y *
f->linesize[0] + x * 2,
s->yuv_color[0] *
mult);
210 AV_WN16(
f->data[1] + chromay *
f->linesize[1] + chromax * 2,
s->yuv_color[1] *
mult);
211 AV_WN16(
f->data[2] + chromay *
f->linesize[2] + chromax * 2,
s->yuv_color[2] *
mult);
223 const int slice_end = (
h * (jobnr+1)) / nb_jobs;
227 const int yc = y >>
s->vsub;
228 const uint8_t *pluma = &in->
data[0][y * in->
linesize[0]];
229 const uint8_t *pchromau = &in->
data[1][yc * in->
linesize[1]];
230 const uint8_t *pchromav = &in->
data[2][yc * in->
linesize[2]];
232 for (x = 0; x <
w; x++) {
233 const int xc = x >>
s->hsub;
234 const int luma = pluma[x];
235 const int chromau = pchromau[xc];
236 const int chromav = pchromav[xc];
237 const int filt = luma < 16 || luma > 235 ||
238 chromau < 16 || chromau > 240 ||
239 chromav < 16 || chromav > 240;
254 const int mult = 1 << (
s->depth - 8);
258 const int slice_end = (
h * (jobnr+1)) / nb_jobs;
262 const int yc = y >>
s->vsub;
263 const uint16_t *pluma = (uint16_t *)&in->
data[0][y * in->
linesize[0]];
264 const uint16_t *pchromau = (uint16_t *)&in->
data[1][yc * in->
linesize[1]];
265 const uint16_t *pchromav = (uint16_t *)&in->
data[2][yc * in->
linesize[2]];
267 for (x = 0; x <
w; x++) {
268 const int xc = x >>
s->hsub;
269 const int luma = pluma[x];
270 const int chromau = pchromau[xc];
271 const int chromav = pchromav[xc];
272 const int filt = luma < 16 * mult || luma > 235 *
mult ||
273 chromau < 16 * mult || chromau > 240 *
mult ||
274 chromav < 16 * mult || chromav > 240 *
mult;
285 return ((
abs(x - y) +
abs (z - y)) / 2) -
abs(z - x) > 4;
297 const int slice_end = (
h * (jobnr+1)) / nb_jobs;
298 const uint8_t *p = in->
data[0];
300 int x, y, score = 0,
filt;
304 if (y - 1 < 0 || y + 1 >=
h)
310 #define FILTER(i, j) \
311 filter_tout_outlier(p[(y-j) * lw + x + i], \
312 p[ y * lw + x + i], \
313 p[(y+j) * lw + x + i])
315 #define FILTER3(j) (FILTER(-1, j) && FILTER(0, j) && FILTER(1, j))
317 if (y - 2 >= 0 && y + 2 <
h) {
318 for (x = 1; x <
w - 1; x++) {
325 for (x = 1; x <
w - 1; x++) {
345 const int slice_end = (
h * (jobnr+1)) / nb_jobs;
346 const uint16_t *p = (uint16_t *)in->
data[0];
348 int x, y, score = 0,
filt;
352 if (y - 1 < 0 || y + 1 >=
h)
358 if (y - 2 >= 0 && y + 2 <
h) {
359 for (x = 1; x <
w - 1; x++) {
366 for (x = 1; x <
w - 1; x++) {
388 const int slice_end = (
h * (jobnr+1)) / nb_jobs;
389 const uint8_t *p = in->
data[0];
395 const int ylw = y * lw;
396 int filt, totdiff = 0;
401 for (x = 0; x <
w; x++)
402 totdiff +=
abs(p[y2lw + x] - p[ylw + x]);
407 for (x = 0; x <
w; x++)
422 const int slice_end = (
h * (jobnr+1)) / nb_jobs;
423 const uint16_t *p = (uint16_t *)in->
data[0];
429 const int ylw = y * lw;
436 for (x = 0; x <
w; x++)
437 totdiff +=
abs(p[y2lw + x] - p[ylw + x]);
442 for (x = 0; x <
w; x++)
448 static const struct {
468 const int slice_start = (
s->chromah * jobnr ) / nb_jobs;
469 const int slice_end = (
s->chromah * (jobnr+1)) / nb_jobs;
471 const int lsz_u =
src->linesize[1];
472 const int lsz_v =
src->linesize[2];
476 const int lsz_sat = dst_sat->
linesize[0];
477 const int lsz_hue = dst_hue->
linesize[0];
482 for (
i = 0;
i <
s->chromaw;
i++) {
483 const int yuvu = p_u[
i];
484 const int yuvv = p_v[
i];
485 p_sat[
i] = hypotf(yuvu - 128, yuvv - 128);
486 ((int16_t*)p_hue)[
i] = fmodf(
floorf((180.
f /
M_PI) *
atan2f(yuvu-128, yuvv-128) + 180.
f), 360.
f);
505 const int mid = 1 << (
s->depth - 1);
507 const int slice_start = (
s->chromah * jobnr ) / nb_jobs;
508 const int slice_end = (
s->chromah * (jobnr+1)) / nb_jobs;
510 const int lsz_u =
src->linesize[1] / 2;
511 const int lsz_v =
src->linesize[2] / 2;
512 const uint16_t *p_u = (uint16_t*)
src->data[1] +
slice_start * lsz_u;
513 const uint16_t *p_v = (uint16_t*)
src->data[2] +
slice_start * lsz_v;
515 const int lsz_sat = dst_sat->
linesize[0] / 2;
516 const int lsz_hue = dst_hue->
linesize[0] / 2;
521 for (
i = 0;
i <
s->chromaw;
i++) {
522 const int yuvu = p_u[
i];
523 const int yuvv = p_v[
i];
524 p_sat[
i] = hypotf(yuvu - mid, yuvv - mid);
525 ((int16_t*)p_hue)[
i] = fmodf(
floorf((180.
f /
M_PI) *
atan2f(yuvu-mid, yuvv-mid) + 180.
f), 360.
f);
552 unsigned int *histy =
s->histy,
556 *histsat =
s->histsat;
557 int miny = -1, minu = -1, minv = -1;
558 int maxy = -1, maxu = -1, maxv = -1;
559 int lowy = -1, lowu = -1, lowv = -1;
560 int highy = -1, highu = -1, highv = -1;
561 int minsat = -1, maxsat = -1, lowsat = -1, highsat = -1;
562 int lowp, highp, clowp, chighp;
563 int accy, accu, accv;
564 int accsat, acchue = 0;
566 int toty = 0, totu = 0, totv = 0, totsat=0;
568 int dify = 0, difu = 0, difv = 0;
569 uint16_t masky = 0, masku = 0, maskv = 0;
576 const uint8_t *p_sat = sat->
data[0];
577 const uint8_t *p_hue = hue->
data[0];
578 const int lsz_sat = sat->
linesize[0];
579 const int lsz_hue = hue->
linesize[0];
589 prev =
s->frame_prev;
609 memset(
s->histy, 0,
s->maxsize *
sizeof(*
s->histy));
610 for (j = 0; j <
link->h; j++) {
611 for (
i = 0;
i <
link->w;
i++) {
612 const int yuv = in->
data[0][
w +
i];
616 dify +=
abs(yuv - prev->
data[0][pw +
i]);
623 memset(
s->histu, 0,
s->maxsize *
sizeof(*
s->histu));
624 memset(
s->histv, 0,
s->maxsize *
sizeof(*
s->histv));
625 memset(
s->histsat, 0,
s->maxsize *
sizeof(*
s->histsat));
626 for (j = 0; j <
s->chromah; j++) {
627 for (
i = 0;
i <
s->chromaw;
i++) {
628 const int yuvu = in->
data[1][cw+
i];
629 const int yuvv = in->
data[2][cw+
i];
634 difu +=
abs(yuvu - prev->
data[1][cpw+
i]);
636 difv +=
abs(yuvv - prev->
data[2][cpw+
i]);
639 histhue[((int16_t*)p_hue)[
i]]++;
648 if (
s->filters & 1<<fil) {
651 .out =
out != in &&
s->outfilter == fil ?
out :
NULL,
653 memset(
s->jobs_rets, 0,
s->nb_jobs *
sizeof(*
s->jobs_rets));
655 &
td,
s->jobs_rets,
s->nb_jobs);
656 for (
i = 0;
i <
s->nb_jobs;
i++)
657 filtot[fil] +=
s->jobs_rets[
i];
664 lowp =
lrint(
s->fs * 10 / 100.);
665 highp =
lrint(
s->fs * 90 / 100.);
666 clowp =
lrint(
s->cfs * 10 / 100.);
667 chighp =
lrint(
s->cfs * 90 / 100.);
669 accy = accu = accv = accsat = 0;
670 for (fil = 0; fil <
s->maxsize; fil++) {
671 if (miny < 0 && histy[fil]) miny = fil;
672 if (minu < 0 && histu[fil]) minu = fil;
673 if (minv < 0 && histv[fil]) minv = fil;
674 if (minsat < 0 && histsat[fil]) minsat = fil;
676 if (histy[fil]) maxy = fil;
677 if (histu[fil]) maxu = fil;
678 if (histv[fil]) maxv = fil;
679 if (histsat[fil]) maxsat = fil;
681 toty += histy[fil] * fil;
682 totu += histu[fil] * fil;
683 totv += histv[fil] * fil;
684 totsat += histsat[fil] * fil;
689 accsat += histsat[fil];
691 if (lowy == -1 && accy >= lowp) lowy = fil;
692 if (lowu == -1 && accu >= clowp) lowu = fil;
693 if (lowv == -1 && accv >= clowp) lowv = fil;
694 if (lowsat == -1 && accsat >= clowp) lowsat = fil;
696 if (highy == -1 && accy >= highp) highy = fil;
697 if (highu == -1 && accu >= chighp) highu = fil;
698 if (highv == -1 && accv >= chighp) highv = fil;
699 if (highsat == -1 && accsat >= chighp) highsat = fil;
704 for (fil = 0; fil < 360; fil++) {
705 tothue += histhue[fil] * fil;
706 acchue += histhue[fil];
708 if (medhue == -1 && acchue >
s->cfs / 2)
710 if (histhue[fil] > maxhue) {
711 maxhue = histhue[fil];
718 #define SET_META(key, fmt, val) do { \
719 snprintf(metabuf, sizeof(metabuf), fmt, val); \
720 av_dict_set(&out->metadata, "lavfi.signalstats." key, metabuf, 0); \
725 SET_META(
"YAVG",
"%g", 1.0 * toty /
s->fs);
731 SET_META(
"UAVG",
"%g", 1.0 * totu /
s->cfs);
737 SET_META(
"VAVG",
"%g", 1.0 * totv /
s->cfs);
743 SET_META(
"SATAVG",
"%g", 1.0 * totsat /
s->cfs);
748 SET_META(
"HUEAVG",
"%g", 1.0 * tothue /
s->cfs);
750 SET_META(
"YDIF",
"%g", 1.0 * dify /
s->fs);
751 SET_META(
"UDIF",
"%g", 1.0 * difu /
s->cfs);
752 SET_META(
"VDIF",
"%g", 1.0 * difv /
s->cfs);
759 if (
s->filters & 1<<fil) {
761 snprintf(metabuf,
sizeof(metabuf),
"%g", 1.0 * filtot[fil] /
s->fs);
783 unsigned int *histy =
s->histy,
787 *histsat =
s->histsat;
788 int miny = -1, minu = -1, minv = -1;
789 int maxy = -1, maxu = -1, maxv = -1;
790 int lowy = -1, lowu = -1, lowv = -1;
791 int highy = -1, highu = -1, highv = -1;
792 int minsat = -1, maxsat = -1, lowsat = -1, highsat = -1;
793 int lowp, highp, clowp, chighp;
794 int accy, accu, accv;
795 int accsat, acchue = 0;
797 int64_t toty = 0, totu = 0, totv = 0, totsat=0;
799 int64_t dify = 0, difu = 0, difv = 0;
800 uint16_t masky = 0, masku = 0, maskv = 0;
807 const uint16_t *p_sat = (uint16_t *)sat->
data[0];
808 const uint16_t *p_hue = (uint16_t *)hue->
data[0];
809 const int lsz_sat = sat->
linesize[0] / 2;
810 const int lsz_hue = hue->
linesize[0] / 2;
820 prev =
s->frame_prev;
840 memset(
s->histy, 0,
s->maxsize *
sizeof(*
s->histy));
841 for (j = 0; j <
link->h; j++) {
842 for (
i = 0;
i <
link->w;
i++) {
854 memset(
s->histu, 0,
s->maxsize *
sizeof(*
s->histu));
855 memset(
s->histv, 0,
s->maxsize *
sizeof(*
s->histv));
856 memset(
s->histsat, 0,
s->maxsize *
sizeof(*
s->histsat));
857 for (j = 0; j <
s->chromah; j++) {
858 for (
i = 0;
i <
s->chromaw;
i++) {
870 histhue[((int16_t*)p_hue)[
i]]++;
879 if (
s->filters & 1<<fil) {
882 .out =
out != in &&
s->outfilter == fil ?
out :
NULL,
884 memset(
s->jobs_rets, 0,
s->nb_jobs *
sizeof(*
s->jobs_rets));
886 &
td,
s->jobs_rets,
s->nb_jobs);
887 for (
i = 0;
i <
s->nb_jobs;
i++)
888 filtot[fil] +=
s->jobs_rets[
i];
895 lowp =
lrint(
s->fs * 10 / 100.);
896 highp =
lrint(
s->fs * 90 / 100.);
897 clowp =
lrint(
s->cfs * 10 / 100.);
898 chighp =
lrint(
s->cfs * 90 / 100.);
900 accy = accu = accv = accsat = 0;
901 for (fil = 0; fil <
s->maxsize; fil++) {
902 if (miny < 0 && histy[fil]) miny = fil;
903 if (minu < 0 && histu[fil]) minu = fil;
904 if (minv < 0 && histv[fil]) minv = fil;
905 if (minsat < 0 && histsat[fil]) minsat = fil;
907 if (histy[fil]) maxy = fil;
908 if (histu[fil]) maxu = fil;
909 if (histv[fil]) maxv = fil;
910 if (histsat[fil]) maxsat = fil;
912 toty += histy[fil] * fil;
913 totu += histu[fil] * fil;
914 totv += histv[fil] * fil;
915 totsat += histsat[fil] * fil;
920 accsat += histsat[fil];
922 if (lowy == -1 && accy >= lowp) lowy = fil;
923 if (lowu == -1 && accu >= clowp) lowu = fil;
924 if (lowv == -1 && accv >= clowp) lowv = fil;
925 if (lowsat == -1 && accsat >= clowp) lowsat = fil;
927 if (highy == -1 && accy >= highp) highy = fil;
928 if (highu == -1 && accu >= chighp) highu = fil;
929 if (highv == -1 && accv >= chighp) highv = fil;
930 if (highsat == -1 && accsat >= chighp) highsat = fil;
935 for (fil = 0; fil < 360; fil++) {
936 tothue += histhue[fil] * fil;
937 acchue += histhue[fil];
939 if (medhue == -1 && acchue >
s->cfs / 2)
941 if (histhue[fil] > maxhue) {
942 maxhue = histhue[fil];
951 SET_META(
"YAVG",
"%g", 1.0 * toty /
s->fs);
957 SET_META(
"UAVG",
"%g", 1.0 * totu /
s->cfs);
963 SET_META(
"VAVG",
"%g", 1.0 * totv /
s->cfs);
969 SET_META(
"SATAVG",
"%g", 1.0 * totsat /
s->cfs);
974 SET_META(
"HUEAVG",
"%g", 1.0 * tothue /
s->cfs);
976 SET_META(
"YDIF",
"%g", 1.0 * dify /
s->fs);
977 SET_META(
"UDIF",
"%g", 1.0 * difu /
s->cfs);
978 SET_META(
"VDIF",
"%g", 1.0 * difv /
s->cfs);
985 if (
s->filters & 1<<fil) {
987 snprintf(metabuf,
sizeof(metabuf),
"%g", 1.0 * filtot[fil] /
s->fs);
1026 .
name =
"signalstats",
1027 .description =
"Generate statistics from video analysis.",
1034 .priv_class = &signalstats_class,
static const struct @314 filters_def[]
AVPixelFormat
Pixel format.
static int filter_frame8(AVFilterLink *link, AVFrame *in)
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
static int compute_sat_hue_metrics16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
static av_cold int init(AVFilterContext *ctx)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
#define SET_META(key, fmt, val)
#define FILTER_PIXFMTS_ARRAY(array)
static __device__ float floorf(float a)
static int filter8_brng(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
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
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
This structure describes decoded (raw) audio or video data.
#define AV_PIX_FMT_YUV420P10
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
AVFILTER_DEFINE_CLASS(signalstats)
const char * name
Filter name.
A link between two filters.
static int filter_frame16(AVFilterLink *link, AVFrame *in)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
#define AV_PIX_FMT_YUV422P9
static int filter16_tout(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
#define AV_PIX_FMT_GRAY16
static int filter_tout_outlier(uint8_t x, uint8_t y, uint8_t z)
static enum AVPixelFormat pix_fmts[]
A filter pad used for either input or output.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define AV_PIX_FMT_YUV444P10
@ AV_PIX_FMT_YUVJ411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
static av_cold void uninit(AVFilterContext *ctx)
static int16_t mult(Float11 *f1, Float11 *f2)
#define AV_PIX_FMT_YUV422P16
static const uint16_t mask[17]
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
static AVFrame * alloc_frame(enum AVPixelFormat pixfmt, int w, int h)
#define AV_PIX_FMT_YUV444P16
#define AV_CEIL_RSHIFT(a, b)
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
#define filters(fmt, type, inverse, clp, inverset, clip, one, clip_fn, packed)
#define AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P16
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
#define FILTER_INPUTS(array)
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 link
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
Make sure a frame is writable.
Describe the class of an AVClass context structure.
static void burn_frame16(const SignalstatsContext *s, AVFrame *f, int x, int y)
static int filter8_tout(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
AVFilterLink ** inputs
array of pointers to input links
#define AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV422P10
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
const AVFilter ff_vf_signalstats
static const AVFilterPad signalstats_inputs[]
static void burn_frame8(const SignalstatsContext *s, AVFrame *f, int x, int y)
static int filter_frame(AVFilterLink *link, AVFrame *in)
int format
agreed upon media format
#define AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV444P12
static const AVFilterPad signalstats_outputs[]
AVFilterContext * src
source filter
static int compute_sat_hue_metrics8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
#define i(width, name, range_min, range_max)
int(* process8)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
int w
agreed upon image width
#define av_malloc_array(a, b)
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
static int config_output(AVFilterLink *outlink)
Used for passing data between threads.
int(* process16)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
static const int8_t filt[NUMTAPS *2]
const char * name
Pad name.
#define AV_PIX_FMT_YUV444P9
enum AVPixelFormat pixfmt
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
#define AV_PIX_FMT_YUV420P12
static int filter16_brng(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
#define AV_PIX_FMT_YUV422P14
int h
agreed upon image height
static const AVOption signalstats_options[]
static int filter8_vrep(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static int slice_start(SliceContext *sc, VVCContext *s, VVCFrameContext *fc, const CodedBitstreamUnit *unit, const int is_first_slice)
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
static int filter16_vrep(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
#define FILTER_OUTPUTS(array)
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
#define AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV444P14
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
static unsigned compute_bit_depth(uint16_t mask)
#define AV_PIX_FMT_YUV420P14