[FFmpeg-devel] [PATCH 1/3] avfilter/vf_unsharp: add 10bit support
lance.lmwang at gmail.com
lance.lmwang at gmail.com
Fri Oct 30 03:18:30 EET 2020
On Thu, Oct 29, 2020 at 09:09:00PM +0800, Linjie Fu wrote:
> On Thu, Oct 29, 2020 at 7:16 PM <lance.lmwang at gmail.com> wrote:
>
> > From: Limin Wang <lance.lmwang at gmail.com>
> >
> > Signed-off-by: Limin Wang <lance.lmwang at gmail.com>
> > ---
> > libavfilter/unsharp.h | 3 +
> > libavfilter/vf_unsharp.c | 162
> > +++++++++++++++++++++++++----------------------
> > 2 files changed, 90 insertions(+), 75 deletions(-)
> >
> > diff --git a/libavfilter/unsharp.h b/libavfilter/unsharp.h
> > index a60b30f..253e32d 100644
> > --- a/libavfilter/unsharp.h
> > +++ b/libavfilter/unsharp.h
> > @@ -48,9 +48,12 @@ typedef struct UnsharpContext {
> > UnsharpFilterParam luma; ///< luma parameters (width, height,
> > amount)
> > UnsharpFilterParam chroma; ///< chroma parameters (width, height,
> > amount)
> > int hsub, vsub;
> > + int bitdepth;
> > + int bps;
> > int nb_threads;
> > int opencl;
> > int (* apply_unsharp)(AVFilterContext *ctx, AVFrame *in, AVFrame
> > *out);
> > + int (* unsharp_slice)(AVFilterContext *ctx, void *arg, int jobnr, int
> > nb_jobs);
> >
>
> Just curious:
> Any special reason for the function moving?
Sorry, I'm not clear about your question.
>
>
> > } UnsharpContext;
>
>
> > #endif /* AVFILTER_UNSHARP_H */
> > diff --git a/libavfilter/vf_unsharp.c b/libavfilter/vf_unsharp.c
> > index 7b430b6..416bf1c 100644
> > --- a/libavfilter/vf_unsharp.c
> > +++ b/libavfilter/vf_unsharp.c
> > @@ -57,81 +57,90 @@ typedef struct TheadData {
> > int height;
> > } ThreadData;
> >
> > -static int unsharp_slice(AVFilterContext *ctx, void *arg, int jobnr, int
> > nb_jobs)
> > -{
> > - ThreadData *td = arg;
> > - UnsharpFilterParam *fp = td->fp;
> > - uint32_t **sc = fp->sc;
> > - uint32_t *sr = fp->sr;
> > - const uint8_t *src2 = NULL; //silence a warning
> > - const int amount = fp->amount;
> > - const int steps_x = fp->steps_x;
> > - const int steps_y = fp->steps_y;
> > - const int scalebits = fp->scalebits;
> > - const int32_t halfscale = fp->halfscale;
> > -
> > - uint8_t *dst = td->dst;
> > - const uint8_t *src = td->src;
> > - const int dst_stride = td->dst_stride;
> > - const int src_stride = td->src_stride;
> > - const int width = td->width;
> > - const int height = td->height;
> > - const int sc_offset = jobnr * 2 * steps_y;
> > - const int sr_offset = jobnr * (MAX_MATRIX_SIZE - 1);
> > - const int slice_start = (height * jobnr) / nb_jobs;
> > - const int slice_end = (height * (jobnr+1)) / nb_jobs;
> > -
> > - int32_t res;
> > - int x, y, z;
> > - uint32_t tmp1, tmp2;
> > -
> > - if (!amount) {
> > - av_image_copy_plane(dst + slice_start * dst_stride, dst_stride,
> > - src + slice_start * src_stride, src_stride,
> > - width, slice_end - slice_start);
> > - return 0;
> > - }
> > -
> > - for (y = 0; y < 2 * steps_y; y++)
> > - memset(sc[sc_offset + y], 0, sizeof(sc[y][0]) * (width + 2 *
> > steps_x));
> > -
> > - // if this is not the first tile, we start from (slice_start -
> > steps_y),
> > - // so we can get smooth result at slice boundary
> > - if (slice_start > steps_y) {
> > - src += (slice_start - steps_y) * src_stride;
> > - dst += (slice_start - steps_y) * dst_stride;
> > - }
> > -
> > - for (y = -steps_y + slice_start; y < steps_y + slice_end; y++) {
> > - if (y < height)
> > - src2 = src;
> > -
> > - memset(sr + sr_offset, 0, sizeof(sr[0]) * (2 * steps_x - 1));
> > - for (x = -steps_x; x < width + steps_x; x++) {
> > - tmp1 = x <= 0 ? src2[0] : x >= width ? src2[width-1] :
> > src2[x];
> > - for (z = 0; z < steps_x * 2; z += 2) {
> > - tmp2 = sr[sr_offset + z + 0] + tmp1; sr[sr_offset + z +
> > 0] = tmp1;
> > - tmp1 = sr[sr_offset + z + 1] + tmp2; sr[sr_offset + z +
> > 1] = tmp2;
> > - }
> > - for (z = 0; z < steps_y * 2; z += 2) {
> > - tmp2 = sc[sc_offset + z + 0][x + steps_x] + tmp1;
> > sc[sc_offset + z + 0][x + steps_x] = tmp1;
> > - tmp1 = sc[sc_offset + z + 1][x + steps_x] + tmp2;
> > sc[sc_offset + z + 1][x + steps_x] = tmp2;
> > - }
> > - if (x >= steps_x && y >= (steps_y + slice_start)) {
> > - const uint8_t *srx = src - steps_y * src_stride + x -
> > steps_x;
> > - uint8_t *dsx = dst - steps_y * dst_stride + x -
> > steps_x;
> > -
> > - res = (int32_t)*srx + ((((int32_t) * srx -
> > (int32_t)((tmp1 + halfscale) >> scalebits)) * amount) >> 16);
> > - *dsx = av_clip_uint8(res);
> > - }
> > - }
> > - if (y >= 0) {
> > - dst += dst_stride;
> > - src += src_stride;
> > - }
> > - }
> > - return 0;
> > +#define DEF_UNSHARP_SLICE_FUNC(name, nbits)
> > \
> > +static int name##_##nbits(AVFilterContext *ctx, void *arg, int jobnr, int
> > nb_jobs) \
> > +{
> > \
> > + ThreadData *td = arg;
> > \
> > + UnsharpFilterParam *fp = td->fp;
> > \
> > + UnsharpContext *s = ctx->priv;
> > \
> > + uint32_t **sc = fp->sc;
> > \
> > + uint32_t *sr = fp->sr;
> > \
> > + const uint##nbits##_t *src2 = NULL;
> > \
> > + const int amount = fp->amount;
> > \
> > + const int steps_x = fp->steps_x;
> > \
> > + const int steps_y = fp->steps_y;
> > \
> > + const int scalebits = fp->scalebits;
> > \
> > + const int32_t halfscale = fp->halfscale;
> > \
> > +
> > \
> > + uint##nbits##_t *dst = (uint##nbits##_t*)td->dst;
> > \
> > + const uint##nbits##_t *src = (const uint##nbits##_t *)td->src;
> > \
> > + int dst_stride = td->dst_stride;
> > \
> > + int src_stride = td->src_stride;
> > \
> > + const int width = td->width;
> > \
> > + const int height = td->height;
> > \
> > + const int sc_offset = jobnr * 2 * steps_y;
> > \
> > + const int sr_offset = jobnr * (MAX_MATRIX_SIZE - 1);
> > \
> > + const int slice_start = (height * jobnr) / nb_jobs;
> > \
> > + const int slice_end = (height * (jobnr+1)) / nb_jobs;
> > \
> > +
> > \
> > + int32_t res;
> > \
> > + int x, y, z;
> > \
> > + uint32_t tmp1, tmp2;
> > \
> > +
> > \
> > + if (!amount) {
> > \
> > + av_image_copy_plane(td->dst + slice_start * dst_stride,
> > dst_stride, \
> > + td->src + slice_start * src_stride,
> > src_stride, \
> > + width * s->bps, slice_end - slice_start);
> > \
> > + return 0;
> > \
> > + }
> > \
> > +
> > \
> > + for (y = 0; y < 2 * steps_y; y++)
> > \
> > + memset(sc[sc_offset + y], 0, sizeof(sc[y][0]) * (width + 2 *
> > steps_x)); \
> > +
> > \
> > + dst_stride = dst_stride / s->bps;
> > \
> > + src_stride = src_stride / s->bps;
> > \
> > + /* if this is not the first tile, we start from (slice_start -
> > steps_y) */ \
> > + /* so we can get smooth result at slice boundary */
> > \
> > + if (slice_start > steps_y) {
> > \
> > + src += (slice_start - steps_y) * src_stride;
> > \
> > + dst += (slice_start - steps_y) * dst_stride;
> > \
> > + }
> > \
> > +
> > \
> > + for (y = -steps_y + slice_start; y < steps_y + slice_end; y++) {
> > \
> > + if (y < height)
> > \
> > + src2 = src;
> > \
> > +
> > \
> > + memset(sr + sr_offset, 0, sizeof(sr[0]) * (2 * steps_x - 1));
> > \
> > + for (x = -steps_x; x < width + steps_x; x++) {
> > \
> > + tmp1 = x <= 0 ? src2[0] : x >= width ? src2[width-1] :
> > src2[x]; \
> > + for (z = 0; z < steps_x * 2; z += 2) {
> > \
> > + tmp2 = sr[sr_offset + z + 0] + tmp1; sr[sr_offset + z +
> > 0] = tmp1; \
> > + tmp1 = sr[sr_offset + z + 1] + tmp2; sr[sr_offset + z +
> > 1] = tmp2; \
> > + }
> > \
> > + for (z = 0; z < steps_y * 2; z += 2) {
> > \
> > + tmp2 = sc[sc_offset + z + 0][x + steps_x] + tmp1;
> > \
> > + sc[sc_offset + z + 0][x + steps_x] = tmp1;
> > \
> > + tmp1 = sc[sc_offset + z + 1][x + steps_x] + tmp2;
> > \
> > + sc[sc_offset + z + 1][x + steps_x] = tmp2;
> > \
> > + }
> > \
> > + if (x >= steps_x && y >= (steps_y + slice_start)) {
> > \
> > + const uint##nbits##_t *srx = src - steps_y * src_stride +
> > x - steps_x; \
> > + uint##nbits##_t *dsx = dst - steps_y * dst_stride +
> > x - steps_x; \
> > +
> > \
> > + res = (int32_t)*srx + ((((int32_t) * srx -
> > \
> > + (int32_t)((tmp1 + halfscale) >> scalebits)) *
> > amount) >> (8+nbits)); \
> > + *dsx = av_clip_uint##nbits(res);
> > \
> > + }
> > \
> > + }
> > \
> > + if (y >= 0) {
> > \
> > + dst += dst_stride;
> > \
> > + src += src_stride;
> > \
> > + }
> > \
> > + }
> > \
> > + return 0;
> > \
> > }
> > +DEF_UNSHARP_SLICE_FUNC(unsharp_slice, 16);
> > +DEF_UNSHARP_SLICE_FUNC(unsharp_slice, 8);
> >
>
> Since the only difference is the bit depth of src/dst/srx/dsx, would it be
> better to use one function only,
> pass the bitdepth into the function and make the decision(uint8_t or
> uint16_t) internally?(than #define the whole funcion)
This is one general way to support more bit depth.
Use macro based funtion(vf_lut3d.c..) or template file(see
vf_phase.c).
So if you have better way for suggestion, please give
one example in the codebase. I'll study it.
>
> - Linjie
--
Thanks,
Limin Wang
More information about the ffmpeg-devel
mailing list