mirror of
https://github.com/FFmpeg/FFmpeg.git
synced 2024-11-21 10:55:51 +02:00
avfilter/vf_waveform: add xflat mode
Also use macros for xflat and aflat mode. Signed-off-by: Paul B Mahol <onemda@gmail.com>
This commit is contained in:
Paul B Mahol
parent
7e0dc7210b
commit
caef95737e
@ -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.
|
||||
|
||||
|
||||
@ -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:
|
||||
|
||||
Loading…
Reference in New Issue
Block a user