Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

avfilter/vf_waveform: add xflat mode

Browse Source 
Also use macros for xflat and aflat mode.

Signed-off-by: Paul B Mahol <onemda@gmail.com>
pull/283/head
Paul B Mahol 7 years ago
parent 7e0dc7210b
commit caef95737e
2 changed files with 307 additions and 254 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 3
      doc/filters.texi
  2. 558
      libavfilter/vf_waveform.c

3
doc/filters.texi
Unescape View File

@ -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.

558
libavfilter/vf_waveform.c
Unescape View File

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

Write Preview
Loading…
Cancel
Save