From caef95737e20039c4e5654e3b3f006fa3ed8aa4d Mon Sep 17 00:00:00 2001 From: Paul B Mahol Date: Wed, 21 Mar 2018 11:34:11 +0100 Subject: [PATCH] avfilter/vf_waveform: add xflat mode Also use macros for xflat and aflat mode. Signed-off-by: Paul B Mahol --- doc/filters.texi | 3 + libavfilter/vf_waveform.c | 558 +++++++++++++++++++++----------------- 2 files changed, 307 insertions(+), 254 deletions(-) diff --git a/doc/filters.texi b/doc/filters.texi index bd43a7ac6e..a3ccb218b2 100644 --- a/doc/filters.texi +++ b/doc/filters.texi @@ -16491,6 +16491,9 @@ Luma and chroma combined together. @item aflat Similar as above, but shows difference between blue and red chroma. +@item xflat +Similar as above, but use different colors. + @item chroma Displays only chroma. diff --git a/libavfilter/vf_waveform.c b/libavfilter/vf_waveform.c index 02a7046f33..44c787fb3d 100644 --- a/libavfilter/vf_waveform.c +++ b/libavfilter/vf_waveform.c @@ -36,6 +36,7 @@ enum FilterType { CHROMA, COLOR, ACOLOR, + XFLAT, NB_FILTERS }; @@ -135,6 +136,7 @@ static const AVOption waveform_options[] = { { "chroma", NULL, 0, AV_OPT_TYPE_CONST, {.i64=CHROMA}, 0, 0, FLAGS, "filter" }, { "color", NULL, 0, AV_OPT_TYPE_CONST, {.i64=COLOR}, 0, 0, FLAGS, "filter" }, { "acolor", NULL, 0, AV_OPT_TYPE_CONST, {.i64=ACOLOR}, 0, 0, FLAGS, "filter" }, + { "xflat", NULL, 0, AV_OPT_TYPE_CONST, {.i64=XFLAT}, 0, 0, FLAGS, "filter" }, { "graticule", "set graticule", OFFSET(graticule), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "graticule" }, { "g", "set graticule", OFFSET(graticule), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "graticule" }, { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "graticule" }, @@ -291,6 +293,7 @@ static int query_formats(AVFilterContext *ctx) switch (s->filter) { case LOWPASS: in_pix_fmts = in_lowpass_pix_fmts; break; case CHROMA: + case XFLAT: case AFLAT: case FLAT: in_pix_fmts = in_flat_pix_fmts; break; case ACOLOR: @@ -619,6 +622,22 @@ static void update(uint8_t *target, int max, int intensity) *target = 255; } +static void update_cr(uint8_t *target, int unused, int intensity) +{ + if (*target - intensity > 0) + *target -= intensity; + else + *target = 0; +} + +static void update16_cr(uint16_t *target, int unused, int intensity, int limit) +{ + if (*target - intensity > 0) + *target -= intensity; + else + *target = 0; +} + static av_always_inline void lowpass16(WaveformContext *s, AVFrame *in, AVFrame *out, int component, int intensity, @@ -1014,256 +1033,276 @@ static av_always_inline void flat(WaveformContext *s, envelope(s, out, plane, (plane + 1) % s->ncomp, column ? offset_x : offset_y); } -static av_always_inline void aflat16(WaveformContext *s, - AVFrame *in, AVFrame *out, - int component, int intensity, - int offset_y, int offset_x, - int column, int mirror) -{ - const int plane = s->desc->comp[component].plane; - const int c0_linesize = in->linesize[ plane + 0 ] / 2; - const int c1_linesize = in->linesize[(plane + 1) % s->ncomp] / 2; - const int c2_linesize = in->linesize[(plane + 2) % s->ncomp] / 2; - const int c0_shift_w = s->shift_w[ component + 0 ]; - const int c1_shift_w = s->shift_w[(component + 1) % s->ncomp]; - const int c2_shift_w = s->shift_w[(component + 2) % s->ncomp]; - const int c0_shift_h = s->shift_h[ component + 0 ]; - const int c1_shift_h = s->shift_h[(component + 1) % s->ncomp]; - const int c2_shift_h = s->shift_h[(component + 2) % s->ncomp]; - const int d0_linesize = out->linesize[ plane + 0 ] / 2; - const int d1_linesize = out->linesize[(plane + 1) % s->ncomp] / 2; - const int d2_linesize = out->linesize[(plane + 2) % s->ncomp] / 2; - const int limit = s->max - 1; - const int max = limit - intensity; - const int mid = s->max / 2; - const int src_h = in->height; - const int src_w = in->width; - int x, y; - - if (column) { - const int d0_signed_linesize = d0_linesize * (mirror == 1 ? -1 : 1); - const int d1_signed_linesize = d1_linesize * (mirror == 1 ? -1 : 1); - const int d2_signed_linesize = d2_linesize * (mirror == 1 ? -1 : 1); - - for (x = 0; x < src_w; x++) { - const uint16_t *c0_data = (uint16_t *)in->data[plane + 0]; - const uint16_t *c1_data = (uint16_t *)in->data[(plane + 1) % s->ncomp]; - const uint16_t *c2_data = (uint16_t *)in->data[(plane + 2) % s->ncomp]; - uint16_t *d0_data = (uint16_t *)out->data[plane] + offset_y * d0_linesize + offset_x; - uint16_t *d1_data = (uint16_t *)out->data[(plane + 1) % s->ncomp] + offset_y * d1_linesize + offset_x; - uint16_t *d2_data = (uint16_t *)out->data[(plane + 2) % s->ncomp] + offset_y * d2_linesize + offset_x; - uint16_t * const d0_bottom_line = d0_data + d0_linesize * (s->size - 1); - uint16_t * const d0 = (mirror ? d0_bottom_line : d0_data); - uint16_t * const d1_bottom_line = d1_data + d1_linesize * (s->size - 1); - uint16_t * const d1 = (mirror ? d1_bottom_line : d1_data); - uint16_t * const d2_bottom_line = d2_data + d2_linesize * (s->size - 1); - uint16_t * const d2 = (mirror ? d2_bottom_line : d2_data); - - for (y = 0; y < src_h; y++) { - const int c0 = FFMIN(c0_data[x >> c0_shift_w], limit) + mid; - const int c1 = FFMIN(c1_data[x >> c1_shift_w], limit) - mid; - const int c2 = FFMIN(c2_data[x >> c2_shift_w], limit) - mid; - uint16_t *target; - - target = d0 + x + d0_signed_linesize * c0; - update16(target, max, intensity, limit); - - target = d1 + x + d1_signed_linesize * (c0 + c1); - update16(target, max, intensity, limit); - - target = d2 + x + d2_signed_linesize * (c0 + c2); - update16(target, max, intensity, limit); - - if (!c0_shift_h || (y & c0_shift_h)) - c0_data += c0_linesize; - if (!c1_shift_h || (y & c1_shift_h)) - c1_data += c1_linesize; - if (!c2_shift_h || (y & c2_shift_h)) - c2_data += c2_linesize; - d0_data += d0_linesize; - d1_data += d1_linesize; - d2_data += d2_linesize; - } - } - } else { - const uint16_t *c0_data = (uint16_t *)in->data[plane]; - const uint16_t *c1_data = (uint16_t *)in->data[(plane + 1) % s->ncomp]; - const uint16_t *c2_data = (uint16_t *)in->data[(plane + 2) % s->ncomp]; - uint16_t *d0_data = (uint16_t *)out->data[plane] + offset_y * d0_linesize + offset_x; - uint16_t *d1_data = (uint16_t *)out->data[(plane + 1) % s->ncomp] + offset_y * d1_linesize + offset_x; - uint16_t *d2_data = (uint16_t *)out->data[(plane + 2) % s->ncomp] + offset_y * d2_linesize + offset_x; - - if (mirror) { - d0_data += s->size - 1; - d1_data += s->size - 1; - d2_data += s->size - 1; - } - - for (y = 0; y < src_h; y++) { - for (x = 0; x < src_w; x++) { - const int c0 = FFMIN(c0_data[x >> c0_shift_w], limit) + mid; - const int c1 = FFMIN(c1_data[x >> c1_shift_w], limit) - mid; - const int c2 = FFMIN(c2_data[x >> c2_shift_w], limit) - mid; - uint16_t *target; - - if (mirror) { - target = d0_data - c0; - update16(target, max, intensity, limit); - target = d1_data - (c0 + c1); - update16(target, max, intensity, limit); - target = d2_data - (c0 + c2); - update16(target, max, intensity, limit); - } else { - target = d0_data + c0; - update16(target, max, intensity, limit); - target = d1_data + (c0 + c1); - update16(target, max, intensity, limit); - target = d2_data + (c0 + c2); - update16(target, max, intensity, limit); - } - } - - if (!c0_shift_h || (y & c0_shift_h)) - c0_data += c0_linesize; - if (!c1_shift_h || (y & c1_shift_h)) - c1_data += c1_linesize; - if (!c2_shift_h || (y & c2_shift_h)) - c2_data += c2_linesize; - d0_data += d0_linesize; - d1_data += d1_linesize; - d2_data += d2_linesize; - } - } - - envelope16(s, out, plane, (plane + 0) % s->ncomp, column ? offset_x : offset_y); - envelope16(s, out, plane, (plane + 1) % s->ncomp, column ? offset_x : offset_y); - envelope16(s, out, plane, (plane + 2) % s->ncomp, column ? offset_x : offset_y); +#define AFLAT16(name, update_cr, column, mirror) \ +static av_always_inline void name (WaveformContext *s, \ + AVFrame *in, AVFrame *out, \ + int component, int intensity, \ + int offset_y, int offset_x, \ + int unused1, int unused2) \ +{ \ + const int plane = s->desc->comp[component].plane; \ + const int c0_linesize = in->linesize[ plane + 0 ] / 2; \ + const int c1_linesize = in->linesize[(plane + 1) % s->ncomp] / 2; \ + const int c2_linesize = in->linesize[(plane + 2) % s->ncomp] / 2; \ + const int c0_shift_w = s->shift_w[ component + 0 ]; \ + const int c1_shift_w = s->shift_w[(component + 1) % s->ncomp]; \ + const int c2_shift_w = s->shift_w[(component + 2) % s->ncomp]; \ + const int c0_shift_h = s->shift_h[ component + 0 ]; \ + const int c1_shift_h = s->shift_h[(component + 1) % s->ncomp]; \ + const int c2_shift_h = s->shift_h[(component + 2) % s->ncomp]; \ + const int d0_linesize = out->linesize[ plane + 0 ] / 2; \ + const int d1_linesize = out->linesize[(plane + 1) % s->ncomp] / 2; \ + const int d2_linesize = out->linesize[(plane + 2) % s->ncomp] / 2; \ + const int limit = s->max - 1; \ + const int max = limit - intensity; \ + const int mid = s->max / 2; \ + const int src_h = in->height; \ + const int src_w = in->width; \ + int x, y; \ + \ + if (column) { \ + const int d0_signed_linesize = d0_linesize * (mirror == 1 ? -1 : 1); \ + const int d1_signed_linesize = d1_linesize * (mirror == 1 ? -1 : 1); \ + const int d2_signed_linesize = d2_linesize * (mirror == 1 ? -1 : 1); \ + \ + for (x = 0; x < src_w; x++) { \ + const uint16_t *c0_data = (uint16_t *)in->data[plane + 0]; \ + const uint16_t *c1_data = (uint16_t *)in->data[(plane + 1) % s->ncomp]; \ + const uint16_t *c2_data = (uint16_t *)in->data[(plane + 2) % s->ncomp]; \ + uint16_t *d0_data = (uint16_t *)out->data[plane] + offset_y * d0_linesize + offset_x; \ + uint16_t *d1_data = (uint16_t *)out->data[(plane + 1) % s->ncomp] + offset_y * d1_linesize + offset_x; \ + uint16_t *d2_data = (uint16_t *)out->data[(plane + 2) % s->ncomp] + offset_y * d2_linesize + offset_x; \ + uint16_t * const d0_bottom_line = d0_data + d0_linesize * (s->size - 1); \ + uint16_t * const d0 = (mirror ? d0_bottom_line : d0_data); \ + uint16_t * const d1_bottom_line = d1_data + d1_linesize * (s->size - 1); \ + uint16_t * const d1 = (mirror ? d1_bottom_line : d1_data); \ + uint16_t * const d2_bottom_line = d2_data + d2_linesize * (s->size - 1); \ + uint16_t * const d2 = (mirror ? d2_bottom_line : d2_data); \ + \ + for (y = 0; y < src_h; y++) { \ + const int c0 = FFMIN(c0_data[x >> c0_shift_w], limit) + mid; \ + const int c1 = FFMIN(c1_data[x >> c1_shift_w], limit) - mid; \ + const int c2 = FFMIN(c2_data[x >> c2_shift_w], limit) - mid; \ + uint16_t *target; \ + \ + target = d0 + x + d0_signed_linesize * c0; \ + update16(target, max, intensity, limit); \ + \ + target = d1 + x + d1_signed_linesize * (c0 + c1); \ + update16(target, max, intensity, limit); \ + \ + target = d2 + x + d2_signed_linesize * (c0 + c2); \ + update_cr(target, max, intensity, limit); \ + \ + if (!c0_shift_h || (y & c0_shift_h)) \ + c0_data += c0_linesize; \ + if (!c1_shift_h || (y & c1_shift_h)) \ + c1_data += c1_linesize; \ + if (!c2_shift_h || (y & c2_shift_h)) \ + c2_data += c2_linesize; \ + d0_data += d0_linesize; \ + d1_data += d1_linesize; \ + d2_data += d2_linesize; \ + } \ + } \ + } else { \ + const uint16_t *c0_data = (uint16_t *)in->data[plane]; \ + const uint16_t *c1_data = (uint16_t *)in->data[(plane + 1) % s->ncomp]; \ + const uint16_t *c2_data = (uint16_t *)in->data[(plane + 2) % s->ncomp]; \ + uint16_t *d0_data = (uint16_t *)out->data[plane] + offset_y * d0_linesize + offset_x; \ + uint16_t *d1_data = (uint16_t *)out->data[(plane + 1) % s->ncomp] + offset_y * d1_linesize + offset_x; \ + uint16_t *d2_data = (uint16_t *)out->data[(plane + 2) % s->ncomp] + offset_y * d2_linesize + offset_x; \ + \ + if (mirror) { \ + d0_data += s->size - 1; \ + d1_data += s->size - 1; \ + d2_data += s->size - 1; \ + } \ + \ + for (y = 0; y < src_h; y++) { \ + for (x = 0; x < src_w; x++) { \ + const int c0 = FFMIN(c0_data[x >> c0_shift_w], limit) + mid; \ + const int c1 = FFMIN(c1_data[x >> c1_shift_w], limit) - mid; \ + const int c2 = FFMIN(c2_data[x >> c2_shift_w], limit) - mid; \ + uint16_t *target; \ + \ + if (mirror) { \ + target = d0_data - c0; \ + update16(target, max, intensity, limit); \ + target = d1_data - (c0 + c1); \ + update16(target, max, intensity, limit); \ + target = d2_data - (c0 + c2); \ + update_cr(target, max, intensity, limit); \ + } else { \ + target = d0_data + c0; \ + update16(target, max, intensity, limit); \ + target = d1_data + (c0 + c1); \ + update16(target, max, intensity, limit); \ + target = d2_data + (c0 + c2); \ + update_cr(target, max, intensity, limit); \ + } \ + } \ + \ + if (!c0_shift_h || (y & c0_shift_h)) \ + c0_data += c0_linesize; \ + if (!c1_shift_h || (y & c1_shift_h)) \ + c1_data += c1_linesize; \ + if (!c2_shift_h || (y & c2_shift_h)) \ + c2_data += c2_linesize; \ + d0_data += d0_linesize; \ + d1_data += d1_linesize; \ + d2_data += d2_linesize; \ + } \ + } \ + \ + envelope16(s, out, plane, (plane + 0) % s->ncomp, column ? offset_x : offset_y); \ + envelope16(s, out, plane, (plane + 1) % s->ncomp, column ? offset_x : offset_y); \ + envelope16(s, out, plane, (plane + 2) % s->ncomp, column ? offset_x : offset_y); \ } -static av_always_inline void aflat(WaveformContext *s, - AVFrame *in, AVFrame *out, - int component, int intensity, - int offset_y, int offset_x, - int column, int mirror) -{ - const int plane = s->desc->comp[component].plane; - const int c0_linesize = in->linesize[ plane + 0 ]; - const int c1_linesize = in->linesize[(plane + 1) % s->ncomp]; - const int c2_linesize = in->linesize[(plane + 2) % s->ncomp]; - const int c0_shift_w = s->shift_w[ component + 0 ]; - const int c1_shift_w = s->shift_w[(component + 1) % s->ncomp]; - const int c2_shift_w = s->shift_w[(component + 2) % s->ncomp]; - const int c0_shift_h = s->shift_h[ component + 0 ]; - const int c1_shift_h = s->shift_h[(component + 1) % s->ncomp]; - const int c2_shift_h = s->shift_h[(component + 2) % s->ncomp]; - const int d0_linesize = out->linesize[ plane + 0 ]; - const int d1_linesize = out->linesize[(plane + 1) % s->ncomp]; - const int d2_linesize = out->linesize[(plane + 2) % s->ncomp]; - const int max = 255 - intensity; - const int src_h = in->height; - const int src_w = in->width; - int x, y; - - if (column) { - const int d0_signed_linesize = d0_linesize * (mirror == 1 ? -1 : 1); - const int d1_signed_linesize = d1_linesize * (mirror == 1 ? -1 : 1); - const int d2_signed_linesize = d2_linesize * (mirror == 1 ? -1 : 1); - - for (x = 0; x < src_w; x++) { - const uint8_t *c0_data = in->data[plane + 0]; - const uint8_t *c1_data = in->data[(plane + 1) % s->ncomp]; - const uint8_t *c2_data = in->data[(plane + 2) % s->ncomp]; - uint8_t *d0_data = out->data[plane] + offset_y * d0_linesize + offset_x; - uint8_t *d1_data = out->data[(plane + 1) % s->ncomp] + offset_y * d1_linesize + offset_x; - uint8_t *d2_data = out->data[(plane + 2) % s->ncomp] + offset_y * d2_linesize + offset_x; - uint8_t * const d0_bottom_line = d0_data + d0_linesize * (s->size - 1); - uint8_t * const d0 = (mirror ? d0_bottom_line : d0_data); - uint8_t * const d1_bottom_line = d1_data + d1_linesize * (s->size - 1); - uint8_t * const d1 = (mirror ? d1_bottom_line : d1_data); - uint8_t * const d2_bottom_line = d2_data + d2_linesize * (s->size - 1); - uint8_t * const d2 = (mirror ? d2_bottom_line : d2_data); - - for (y = 0; y < src_h; y++) { - const int c0 = c0_data[x >> c0_shift_w] + 128; - const int c1 = c1_data[x >> c1_shift_w] - 128; - const int c2 = c2_data[x >> c2_shift_w] - 128; - uint8_t *target; - - target = d0 + x + d0_signed_linesize * c0; - update(target, max, intensity); - - target = d1 + x + d1_signed_linesize * (c0 + c1); - update(target, max, intensity); - - target = d2 + x + d2_signed_linesize * (c0 + c2); - update(target, max, intensity); - - if (!c0_shift_h || (y & c0_shift_h)) - c0_data += c0_linesize; - if (!c1_shift_h || (y & c1_shift_h)) - c1_data += c1_linesize; - if (!c1_shift_h || (y & c1_shift_h)) - c2_data += c1_linesize; - d0_data += d0_linesize; - d1_data += d1_linesize; - d2_data += d2_linesize; - } - } - } else { - const uint8_t *c0_data = in->data[plane]; - const uint8_t *c1_data = in->data[(plane + 1) % s->ncomp]; - const uint8_t *c2_data = in->data[(plane + 2) % s->ncomp]; - uint8_t *d0_data = out->data[plane] + offset_y * d0_linesize + offset_x; - uint8_t *d1_data = out->data[(plane + 1) % s->ncomp] + offset_y * d1_linesize + offset_x; - uint8_t *d2_data = out->data[(plane + 2) % s->ncomp] + offset_y * d2_linesize + offset_x; - - if (mirror) { - d0_data += s->size - 1; - d1_data += s->size - 1; - d2_data += s->size - 1; - } - - for (y = 0; y < src_h; y++) { - for (x = 0; x < src_w; x++) { - const int c0 = c0_data[x >> c0_shift_w] + 128; - const int c1 = c1_data[x >> c1_shift_w] - 128; - const int c2 = c2_data[x >> c2_shift_w] - 128; - uint8_t *target; - - if (mirror) { - target = d0_data - c0; - update(target, max, intensity); - target = d1_data - (c0 + c1); - update(target, max, intensity); - target = d2_data - (c0 + c2); - update(target, max, intensity); - } else { - target = d0_data + c0; - update(target, max, intensity); - target = d1_data + (c0 + c1); - update(target, max, intensity); - target = d2_data + (c0 + c2); - update(target, max, intensity); - } - } - - if (!c0_shift_h || (y & c0_shift_h)) - c0_data += c0_linesize; - if (!c1_shift_h || (y & c1_shift_h)) - c1_data += c1_linesize; - if (!c2_shift_h || (y & c2_shift_h)) - c2_data += c2_linesize; - d0_data += d0_linesize; - d1_data += d1_linesize; - d2_data += d2_linesize; - } - } - - envelope(s, out, plane, (plane + 0) % s->ncomp, column ? offset_x : offset_y); - envelope(s, out, plane, (plane + 1) % s->ncomp, column ? offset_x : offset_y); - envelope(s, out, plane, (plane + 2) % s->ncomp, column ? offset_x : offset_y); +#define AFLAT(name, update_cr, column, mirror) \ +static av_always_inline void name(WaveformContext *s, \ + AVFrame *in, AVFrame *out, \ + int component, int intensity, \ + int offset_y, int offset_x, \ + int unused1, int unused2) \ +{ \ + const int plane = s->desc->comp[component].plane; \ + const int c0_linesize = in->linesize[ plane + 0 ]; \ + const int c1_linesize = in->linesize[(plane + 1) % s->ncomp]; \ + const int c2_linesize = in->linesize[(plane + 2) % s->ncomp]; \ + const int c0_shift_w = s->shift_w[ component + 0 ]; \ + const int c1_shift_w = s->shift_w[(component + 1) % s->ncomp]; \ + const int c2_shift_w = s->shift_w[(component + 2) % s->ncomp]; \ + const int c0_shift_h = s->shift_h[ component + 0 ]; \ + const int c1_shift_h = s->shift_h[(component + 1) % s->ncomp]; \ + const int c2_shift_h = s->shift_h[(component + 2) % s->ncomp]; \ + const int d0_linesize = out->linesize[ plane + 0 ]; \ + const int d1_linesize = out->linesize[(plane + 1) % s->ncomp]; \ + const int d2_linesize = out->linesize[(plane + 2) % s->ncomp]; \ + const int max = 255 - intensity; \ + const int src_h = in->height; \ + const int src_w = in->width; \ + int x, y; \ + \ + if (column) { \ + const int d0_signed_linesize = d0_linesize * (mirror == 1 ? -1 : 1); \ + const int d1_signed_linesize = d1_linesize * (mirror == 1 ? -1 : 1); \ + const int d2_signed_linesize = d2_linesize * (mirror == 1 ? -1 : 1); \ + \ + for (x = 0; x < src_w; x++) { \ + const uint8_t *c0_data = in->data[plane + 0]; \ + const uint8_t *c1_data = in->data[(plane + 1) % s->ncomp]; \ + const uint8_t *c2_data = in->data[(plane + 2) % s->ncomp]; \ + uint8_t *d0_data = out->data[plane] + offset_y * d0_linesize + offset_x; \ + uint8_t *d1_data = out->data[(plane + 1) % s->ncomp] + offset_y * d1_linesize + offset_x; \ + uint8_t *d2_data = out->data[(plane + 2) % s->ncomp] + offset_y * d2_linesize + offset_x; \ + uint8_t * const d0_bottom_line = d0_data + d0_linesize * (s->size - 1); \ + uint8_t * const d0 = (mirror ? d0_bottom_line : d0_data); \ + uint8_t * const d1_bottom_line = d1_data + d1_linesize * (s->size - 1); \ + uint8_t * const d1 = (mirror ? d1_bottom_line : d1_data); \ + uint8_t * const d2_bottom_line = d2_data + d2_linesize * (s->size - 1); \ + uint8_t * const d2 = (mirror ? d2_bottom_line : d2_data); \ + \ + for (y = 0; y < src_h; y++) { \ + const int c0 = c0_data[x >> c0_shift_w] + 128; \ + const int c1 = c1_data[x >> c1_shift_w] - 128; \ + const int c2 = c2_data[x >> c2_shift_w] - 128; \ + uint8_t *target; \ + \ + target = d0 + x + d0_signed_linesize * c0; \ + update(target, max, intensity); \ + \ + target = d1 + x + d1_signed_linesize * (c0 + c1); \ + update(target, max, intensity); \ + \ + target = d2 + x + d2_signed_linesize * (c0 + c2); \ + update_cr(target, max, intensity); \ + \ + if (!c0_shift_h || (y & c0_shift_h)) \ + c0_data += c0_linesize; \ + if (!c1_shift_h || (y & c1_shift_h)) \ + c1_data += c1_linesize; \ + if (!c1_shift_h || (y & c1_shift_h)) \ + c2_data += c1_linesize; \ + d0_data += d0_linesize; \ + d1_data += d1_linesize; \ + d2_data += d2_linesize; \ + } \ + } \ + } else { \ + const uint8_t *c0_data = in->data[plane]; \ + const uint8_t *c1_data = in->data[(plane + 1) % s->ncomp]; \ + const uint8_t *c2_data = in->data[(plane + 2) % s->ncomp]; \ + uint8_t *d0_data = out->data[plane] + offset_y * d0_linesize + offset_x; \ + uint8_t *d1_data = out->data[(plane + 1) % s->ncomp] + offset_y * d1_linesize + offset_x; \ + uint8_t *d2_data = out->data[(plane + 2) % s->ncomp] + offset_y * d2_linesize + offset_x; \ + \ + if (mirror) { \ + d0_data += s->size - 1; \ + d1_data += s->size - 1; \ + d2_data += s->size - 1; \ + } \ + \ + for (y = 0; y < src_h; y++) { \ + for (x = 0; x < src_w; x++) { \ + const int c0 = c0_data[x >> c0_shift_w] + 128; \ + const int c1 = c1_data[x >> c1_shift_w] - 128; \ + const int c2 = c2_data[x >> c2_shift_w] - 128; \ + uint8_t *target; \ + \ + if (mirror) { \ + target = d0_data - c0; \ + update(target, max, intensity); \ + target = d1_data - (c0 + c1); \ + update(target, max, intensity); \ + target = d2_data - (c0 + c2); \ + update_cr(target, max, intensity); \ + } else { \ + target = d0_data + c0; \ + update(target, max, intensity); \ + target = d1_data + (c0 + c1); \ + update(target, max, intensity); \ + target = d2_data + (c0 + c2); \ + update_cr(target, max, intensity); \ + } \ + } \ + \ + if (!c0_shift_h || (y & c0_shift_h)) \ + c0_data += c0_linesize; \ + if (!c1_shift_h || (y & c1_shift_h)) \ + c1_data += c1_linesize; \ + if (!c2_shift_h || (y & c2_shift_h)) \ + c2_data += c2_linesize; \ + d0_data += d0_linesize; \ + d1_data += d1_linesize; \ + d2_data += d2_linesize; \ + } \ + } \ + \ + envelope(s, out, plane, (plane + 0) % s->ncomp, column ? offset_x : offset_y); \ + envelope(s, out, plane, (plane + 1) % s->ncomp, column ? offset_x : offset_y); \ + envelope(s, out, plane, (plane + 2) % s->ncomp, column ? offset_x : offset_y); \ } +AFLAT16(aflat16_row, update16, 0, 0) +AFLAT16(aflat16_row_mirror, update16, 0, 1) +AFLAT16(aflat16_column, update16, 1, 0) +AFLAT16(aflat16_column_mirror, update16, 1, 1) +AFLAT16(xflat16_row, update16_cr, 0, 0) +AFLAT16(xflat16_row_mirror, update16_cr, 0, 1) +AFLAT16(xflat16_column, update16_cr, 1, 0) +AFLAT16(xflat16_column_mirror, update16_cr, 1, 1) + +AFLAT(aflat_row, update, 0, 0) +AFLAT(aflat_row_mirror, update, 0, 1) +AFLAT(aflat_column, update, 1, 0) +AFLAT(aflat_column_mirror, update, 1, 1) +AFLAT(xflat_row, update_cr, 0, 0) +AFLAT(xflat_row_mirror, update_cr, 0, 1) +AFLAT(xflat_column, update_cr, 1, 0) +AFLAT(xflat_column_mirror, update_cr, 1, 1) + static av_always_inline void chroma16(WaveformContext *s, AVFrame *in, AVFrame *out, int component, int intensity, @@ -2481,6 +2520,7 @@ static int config_input(AVFilterLink *inlink) s->graticulef = graticule_none; switch (s->filter) { + case XFLAT: case AFLAT: s->size = 256 * 2; break; case FLAT: s->size = 256 * 3; break; default: s->size = 256; break; @@ -2504,14 +2544,14 @@ static int config_input(AVFilterLink *inlink) case 0x1011: case 0x0111: case 0x0011: s->waveform = flat16; break; - case 0x1102: - case 0x1002: - case 0x0102: - case 0x0002: s->waveform = aflat; break; - case 0x1112: - case 0x1012: - case 0x0112: - case 0x0012: s->waveform = aflat16; break; + case 0x1102: s->waveform = aflat_column_mirror; break; + case 0x1002: s->waveform = aflat_row_mirror; break; + case 0x0102: s->waveform = aflat_column; break; + case 0x0002: s->waveform = aflat_row; break; + case 0x1112: s->waveform = aflat16_column_mirror; break; + case 0x1012: s->waveform = aflat16_row_mirror; break; + case 0x0112: s->waveform = aflat16_column; break; + case 0x0012: s->waveform = aflat16_row; break; case 0x1103: case 0x1003: case 0x0103: @@ -2536,6 +2576,14 @@ static int config_input(AVFilterLink *inlink) case 0x1015: case 0x0115: case 0x0015: s->waveform = acolor16; break; + case 0x1106: s->waveform = xflat_column_mirror; break; + case 0x1006: s->waveform = xflat_row_mirror; break; + case 0x0106: s->waveform = xflat_column; break; + case 0x0006: s->waveform = xflat_row; break; + case 0x1116: s->waveform = xflat16_column_mirror; break; + case 0x1016: s->waveform = xflat16_row_mirror; break; + case 0x0116: s->waveform = xflat16_column; break; + case 0x0016: s->waveform = xflat16_row; break; } switch (s->filter) { @@ -2544,6 +2592,7 @@ static int config_input(AVFilterLink *inlink) case ACOLOR: case CHROMA: case AFLAT: + case XFLAT: case FLAT: if (s->graticule && s->mode == 1) s->graticulef = s->bits > 8 ? graticule16_green_column : graticule_green_column; @@ -2611,6 +2660,7 @@ static int config_input(AVFilterLink *inlink) break; } break; + case XFLAT: case AFLAT: switch (s->scale) { case DIGITAL: