70 #define OFFSET(x) offsetof(SignalstatsContext, x) 71 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM 100 s->
yuv_color[0] = (( 66*r + 129*g + 25*b + (1<<7)) >> 8) + 16;
101 s->
yuv_color[1] = ((-38*r + -74*g + 112*b + (1<<7)) >> 8) + 128;
102 s->
yuv_color[2] = ((112*r + -94*g + -18*b + (1<<7)) >> 8) + 128;
179 outlink->
w = inlink->
w;
180 outlink->
h = inlink->
h;
185 s->
fs = inlink->
w * inlink->
h;
203 const int chromax = x >> s->
hsub;
204 const int chromay = y >> s->
vsub;
212 const int chromax = x >> s->
hsub;
213 const int chromay = y >> s->
vsub;
228 const int slice_start = (h * jobnr ) / nb_jobs;
232 for (y = slice_start; y <
slice_end; y++) {
233 const int yc = y >> s->
vsub;
238 for (x = 0; x <
w; x++) {
239 const int xc = x >> s->
hsub;
240 const int luma = pluma[x];
241 const int chromau = pchromau[xc];
242 const int chromav = pchromav[xc];
243 const int filt = luma < 16 || luma > 235 ||
244 chromau < 16 || chromau > 240 ||
245 chromav < 16 || chromav > 240;
263 const int slice_start = (h * jobnr ) / nb_jobs;
267 for (y = slice_start; y <
slice_end; y++) {
268 const int yc = y >> s->
vsub;
269 const uint16_t *pluma = (uint16_t *)&in->
data[0][y * in->
linesize[0]];
270 const uint16_t *pchromau = (uint16_t *)&in->
data[1][yc * in->
linesize[1]];
271 const uint16_t *pchromav = (uint16_t *)&in->
data[2][yc * in->
linesize[2]];
273 for (x = 0; x <
w; x++) {
274 const int xc = x >> s->
hsub;
275 const int luma = pluma[x];
276 const int chromau = pchromau[xc];
277 const int chromav = pchromav[xc];
278 const int filt = luma < 16 * mult || luma > 235 * mult ||
279 chromau < 16 * mult || chromau > 240 * mult ||
280 chromav < 16 * mult || chromav > 240 *
mult;
291 return ((
abs(x - y) +
abs (z - y)) / 2) -
abs(z - x) > 4;
302 const int slice_start = (h * jobnr ) / nb_jobs;
306 int x, y, score = 0,
filt;
308 for (y = slice_start; y <
slice_end; y++) {
310 if (y - 1 < 0 || y + 1 >= h)
316 #define FILTER(i, j) \ 317 filter_tout_outlier(p[(y-j) * lw + x + i], \ 318 p[ y * lw + x + i], \ 319 p[(y+j) * lw + x + i]) 321 #define FILTER3(j) (FILTER(-1, j) && FILTER(0, j) && FILTER(1, j)) 323 if (y - 2 >= 0 && y + 2 < h) {
324 for (x = 1; x < w - 1; x++) {
331 for (x = 1; x < w - 1; x++) {
350 const int slice_start = (h * jobnr ) / nb_jobs;
352 const uint16_t *p = (uint16_t *)in->
data[0];
354 int x, y, score = 0,
filt;
358 if (y - 1 < 0 || y + 1 >= h)
364 if (y - 2 >= 0 && y + 2 < h) {
365 for (x = 1; x < w - 1; x++) {
372 for (x = 1; x < w - 1; x++) {
393 const int slice_start = (h * jobnr ) / nb_jobs;
399 for (y = slice_start; y <
slice_end; y++) {
401 const int ylw = y * lw;
402 int filt, totdiff = 0;
407 for (x = 0; x <
w; x++)
408 totdiff +=
abs(p[y2lw + x] - p[ylw + x]);
413 for (x = 0; x <
w; x++)
427 const int slice_start = (h * jobnr ) / nb_jobs;
429 const uint16_t *p = (uint16_t *)in->
data[0];
435 const int ylw = y * lw;
442 for (x = 0; x <
w; x++)
443 totdiff +=
abs(p[y2lw + x] - p[ylw + x]);
448 for (x = 0; x <
w; x++)
454 static const struct {
474 const int slice_start = (s->
chromah * jobnr ) / nb_jobs;
479 const uint8_t *p_u = src->
data[1] + slice_start * lsz_u;
480 const uint8_t *p_v = src->
data[2] + slice_start * lsz_v;
482 const int lsz_sat = dst_sat->
linesize[0];
483 const int lsz_hue = dst_hue->
linesize[0];
484 uint8_t *p_sat = dst_sat->
data[0] + slice_start * lsz_sat;
485 uint8_t *p_hue = dst_hue->
data[0] + slice_start * lsz_hue;
487 for (j = slice_start; j <
slice_end; j++) {
488 for (i = 0; i < s->
chromaw; i++) {
489 const int yuvu = p_u[
i];
490 const int yuvv = p_v[
i];
491 p_sat[
i] =
hypot(yuvu - 128, yuvv - 128);
492 ((int16_t*)p_hue)[
i] = fmod(
floor((180 /
M_PI) *
atan2f(yuvu-128, yuvv-128) + 180), 360.);
511 const int mid = 1 << (s->
depth - 1);
513 const int slice_start = (s->
chromah * jobnr ) / nb_jobs;
516 const int lsz_u = src->
linesize[1] / 2;
517 const int lsz_v = src->
linesize[2] / 2;
518 const uint16_t *p_u = (uint16_t*)src->
data[1] + slice_start * lsz_u;
519 const uint16_t *p_v = (uint16_t*)src->
data[2] + slice_start * lsz_v;
521 const int lsz_sat = dst_sat->
linesize[0] / 2;
522 const int lsz_hue = dst_hue->
linesize[0] / 2;
523 uint16_t *p_sat = (uint16_t*)dst_sat->
data[0] + slice_start * lsz_sat;
524 uint16_t *p_hue = (uint16_t*)dst_hue->
data[0] + slice_start * lsz_hue;
526 for (j = slice_start; j <
slice_end; j++) {
527 for (i = 0; i < s->
chromaw; i++) {
528 const int yuvu = p_u[
i];
529 const int yuvv = p_v[
i];
530 p_sat[
i] =
hypot(yuvu - mid, yuvv - mid);
531 ((int16_t*)p_hue)[
i] = fmod(
floor((180 /
M_PI) *
atan2f(yuvu-mid, yuvv-mid) + 180), 360.);
544 return av_popcount(mask);
563 int miny = -1, minu = -1, minv = -1;
564 int maxy = -1, maxu = -1, maxv = -1;
565 int lowy = -1, lowu = -1, lowv = -1;
566 int highy = -1, highu = -1, highv = -1;
567 int minsat = -1, maxsat = -1, lowsat = -1, highsat = -1;
568 int lowp, highp, clowp, chighp;
569 int accy, accu, accv;
570 int accsat, acchue = 0;
572 int toty = 0, totu = 0, totv = 0, totsat=0;
574 int dify = 0, difu = 0, difv = 0;
575 uint16_t masky = 0, masku = 0, maskv = 0;
584 const int lsz_sat = sat->
linesize[0];
585 const int lsz_hue = hue->
linesize[0];
607 for (j = 0; j < link->
h; j++) {
608 for (i = 0; i < link->
w; i++) {
609 const int yuv = in->
data[0][w +
i];
613 dify +=
abs(yuv - prev->
data[0][pw + i]);
623 for (j = 0; j < s->
chromah; j++) {
624 for (i = 0; i < s->
chromaw; i++) {
625 const int yuvu = in->
data[1][cw+
i];
626 const int yuvv = in->
data[2][cw+
i];
631 difu +=
abs(yuvu - prev->
data[1][cpw+i]);
633 difv +=
abs(yuvv - prev->
data[2][cpw+i]);
636 histhue[((int16_t*)p_hue)[
i]]++;
653 for (i = 0; i < s->
nb_jobs; i++)
661 lowp =
lrint(s->
fs * 10 / 100.);
662 highp =
lrint(s->
fs * 90 / 100.);
666 accy = accu = accv = accsat = 0;
667 for (fil = 0; fil < s->
maxsize; fil++) {
668 if (miny < 0 && histy[fil]) miny = fil;
669 if (minu < 0 &&
histu[fil]) minu = fil;
670 if (minv < 0 &&
histv[fil]) minv = fil;
671 if (minsat < 0 &&
histsat[fil]) minsat = fil;
673 if (histy[fil]) maxy = fil;
674 if (
histu[fil]) maxu = fil;
675 if (
histv[fil]) maxv = fil;
676 if (
histsat[fil]) maxsat = fil;
678 toty += histy[fil] * fil;
679 totu +=
histu[fil] * fil;
680 totv +=
histv[fil] * fil;
688 if (lowy == -1 && accy >= lowp) lowy = fil;
689 if (lowu == -1 && accu >= clowp) lowu = fil;
690 if (lowv == -1 && accv >= clowp) lowv = fil;
691 if (lowsat == -1 && accsat >= clowp) lowsat = fil;
693 if (highy == -1 && accy >= highp) highy = fil;
694 if (highu == -1 && accu >= chighp) highu = fil;
695 if (highv == -1 && accv >= chighp) highv = fil;
696 if (highsat == -1 && accsat >= chighp) highsat = fil;
701 for (fil = 0; fil < 360; fil++) {
702 tothue += histhue[fil] * fil;
703 acchue += histhue[fil];
705 if (medhue == -1 && acchue > s->
cfs / 2)
707 if (histhue[fil] > maxhue) {
708 maxhue = histhue[fil];
715 #define SET_META(key, fmt, val) do { \ 716 snprintf(metabuf, sizeof(metabuf), fmt, val); \ 717 av_dict_set(&out->metadata, "lavfi.signalstats." key, metabuf, 0); \ 758 snprintf(metabuf,
sizeof(metabuf),
"%g", 1.0 * filtot[fil] / s->
fs);
785 int miny = -1, minu = -1, minv = -1;
786 int maxy = -1, maxu = -1, maxv = -1;
787 int lowy = -1, lowu = -1, lowv = -1;
788 int highy = -1, highu = -1, highv = -1;
789 int minsat = -1, maxsat = -1, lowsat = -1, highsat = -1;
790 int lowp, highp, clowp, chighp;
791 int accy, accu, accv;
792 int accsat, acchue = 0;
794 int64_t toty = 0, totu = 0, totv = 0, totsat=0;
796 int64_t dify = 0, difu = 0, difv = 0;
797 uint16_t masky = 0, masku = 0, maskv = 0;
804 const uint16_t *p_sat = (uint16_t *)sat->
data[0];
805 const uint16_t *p_hue = (uint16_t *)hue->
data[0];
806 const int lsz_sat = sat->
linesize[0] / 2;
807 const int lsz_hue = hue->
linesize[0] / 2;
829 for (j = 0; j < link->
h; j++) {
830 for (i = 0; i < link->
w; i++) {
845 for (j = 0; j < s->
chromah; j++) {
846 for (i = 0; i < s->
chromaw; i++) {
847 const int yuvu =
AV_RN16(in->
data[1] + cw + i * 2);
848 const int yuvv =
AV_RN16(in->
data[2] + cw + i * 2);
858 histhue[((int16_t*)p_hue)[
i]]++;
875 for (i = 0; i < s->
nb_jobs; i++)
883 lowp =
lrint(s->
fs * 10 / 100.);
884 highp =
lrint(s->
fs * 90 / 100.);
888 accy = accu = accv = accsat = 0;
889 for (fil = 0; fil < s->
maxsize; fil++) {
890 if (miny < 0 && histy[fil]) miny = fil;
891 if (minu < 0 &&
histu[fil]) minu = fil;
892 if (minv < 0 &&
histv[fil]) minv = fil;
893 if (minsat < 0 &&
histsat[fil]) minsat = fil;
895 if (histy[fil]) maxy = fil;
896 if (
histu[fil]) maxu = fil;
897 if (
histv[fil]) maxv = fil;
898 if (
histsat[fil]) maxsat = fil;
900 toty += histy[fil] * fil;
901 totu +=
histu[fil] * fil;
902 totv +=
histv[fil] * fil;
910 if (lowy == -1 && accy >= lowp) lowy = fil;
911 if (lowu == -1 && accu >= clowp) lowu = fil;
912 if (lowv == -1 && accv >= clowp) lowv = fil;
913 if (lowsat == -1 && accsat >= clowp) lowsat = fil;
915 if (highy == -1 && accy >= highp) highy = fil;
916 if (highu == -1 && accu >= chighp) highu = fil;
917 if (highv == -1 && accv >= chighp) highv = fil;
918 if (highsat == -1 && accsat >= chighp) highsat = fil;
923 for (fil = 0; fil < 360; fil++) {
924 tothue += histhue[fil] * fil;
925 acchue += histhue[fil];
927 if (medhue == -1 && acchue > s->
cfs / 2)
929 if (histhue[fil] > maxhue) {
930 maxhue = histhue[fil];
975 snprintf(metabuf,
sizeof(metabuf),
"%g", 1.0 * filtot[fil] / s->
fs);
1016 .
name =
"signalstats",
1017 .description =
"Generate statistics from video analysis.",
1022 .
inputs = signalstats_inputs,
1023 .
outputs = signalstats_outputs,
1024 .priv_class = &signalstats_class,
#define AV_PIX_FMT_YUV440P10
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
static av_cold void uninit(AVFilterContext *ctx)
#define AV_PIX_FMT_YUV444P14
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
int h
agreed upon image height
static int compute_sat_hue_metrics16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
#define AV_PIX_FMT_YUV420P12
static int filter16_tout(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
static int compute_sat_hue_metrics8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static const AVFilterPad signalstats_outputs[]
static __device__ float floor(float a)
const char * name
Pad name.
static int filter_frame(AVFilterLink *link, AVFrame *in)
AVFilterLink ** inputs
array of pointers to input links
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
static void burn_frame8(const SignalstatsContext *s, AVFrame *f, int x, int y)
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range...
int(* process8)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
int(* process16)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
AVDictionary * metadata
metadata.
#define AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV422P12
A filter pad used for either input or output.
A link between two filters.
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
static const uint16_t mask[17]
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
void * priv
private data for use by the filter
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
AVFilter ff_vf_signalstats
#define AV_PIX_FMT_YUV444P10
static int filter16_brng(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
int w
agreed upon image width
#define AV_PIX_FMT_YUV422P9
static av_const double hypot(double x, double y)
static int filter16_vrep(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
static int16_t mult(Float11 *f1, Float11 *f2)
#define AV_PIX_FMT_GRAY16
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
static int filter_frame16(AVFilterLink *link, AVFrame *in)
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 SET_META(key, fmt, val)
AVFilterContext * src
source filter
#define AV_PIX_FMT_YUV444P9
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
static const AVFilterPad outputs[]
int format
agreed upon media format
#define AV_PIX_FMT_YUV420P16
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
static int filter8_vrep(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
#define AV_PIX_FMT_YUV420P14
Used for passing data between threads.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
static void burn_frame16(const SignalstatsContext *s, AVFrame *f, int x, int y)
static const AVFilterPad signalstats_inputs[]
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 inputs
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
#define AV_PIX_FMT_YUV420P10
static const struct @238 filters_def[]
Describe the class of an AVClass context structure.
const char * name
Filter name.
#define AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV420P9
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
static AVFrame * alloc_frame(enum AVPixelFormat pixfmt, int w, int h)
AVFilterLink ** outputs
array of pointers to output links
static enum AVPixelFormat pix_fmts[]
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
#define AV_PIX_FMT_YUV422P14
static int filter_tout_outlier(uint8_t x, uint8_t y, uint8_t z)
int av_frame_make_writable(AVFrame *frame)
Ensure that the frame data is writable, avoiding data copy if possible.
#define flags(name, subs,...)
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
#define AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV444P12
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
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
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
static const int8_t filt[NUMTAPS *2]
static unsigned compute_bit_depth(uint16_t mask)
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
avfilter_execute_func * execute
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
static int filter8_tout(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static int filter8_brng(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
AVFilterContext * dst
dest filter
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
enum AVPixelFormat pixfmt
static int filter_frame8(AVFilterLink *link, AVFrame *in)
static int query_formats(AVFilterContext *ctx)
AVFILTER_DEFINE_CLASS(signalstats)
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
#define av_malloc_array(a, b)
static av_cold int init(AVFilterContext *ctx)
static const AVOption signalstats_options[]
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
int depth
Number of bits in the component.
static int config_output(AVFilterLink *outlink)
AVPixelFormat
Pixel format.
#define AV_PIX_FMT_YUV422P16
#define AV_CEIL_RSHIFT(a, b)