/*
 * Copyright (c) 2013 Paul B Mahol
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <float.h>

#undef pixel
#undef cpixel
#undef ROUND
#if DEPTH == 8
#define pixel uint8_t
#define cpixel int
#define ROUND lrintf
#elif DEPTH == 16
#define pixel uint16_t
#define cpixel int
#define ROUND lrintf
#else
#define NOP(x) (x)
#define pixel float
#define cpixel float
#define ROUND NOP
#endif

#undef fn
#undef fn2
#undef fn3
#define fn3(a,b)   a##_##b
#define fn2(a,b)   fn3(a,b)
#define fn(a)      fn2(a, DEPTH)

static av_always_inline int fn(filter_slice_rgba_planar)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs,
                                                         int have_alpha, int depth, int pc)
{
    ColorChannelMixerContext *s = ctx->priv;
    ThreadData *td = arg;
    AVFrame *in = td->in;
    AVFrame *out = td->out;
    const float pa = s->preserve_amount;
    const float max = (1 << depth) - 1;
    const int slice_start = (out->height * jobnr) / nb_jobs;
    const int slice_end = (out->height * (jobnr+1)) / nb_jobs;
    const pixel *srcg = (const pixel *)(in->data[0] + slice_start * in->linesize[0]);
    const pixel *srcb = (const pixel *)(in->data[1] + slice_start * in->linesize[1]);
    const pixel *srcr = (const pixel *)(in->data[2] + slice_start * in->linesize[2]);
    const pixel *srca = (const pixel *)(in->data[3] + slice_start * in->linesize[3]);
    pixel *dstg = (pixel *)(out->data[0] + slice_start * out->linesize[0]);
    pixel *dstb = (pixel *)(out->data[1] + slice_start * out->linesize[1]);
    pixel *dstr = (pixel *)(out->data[2] + slice_start * out->linesize[2]);
    pixel *dsta = (pixel *)(out->data[3] + slice_start * out->linesize[3]);

    for (int i = slice_start; i < slice_end; i++) {
        for (int j = 0; j < out->width; j++) {
            const pixel rin = srcr[j];
            const pixel gin = srcg[j];
            const pixel bin = srcb[j];
            const pixel ain = have_alpha ? srca[j] : 0;
            cpixel rout, gout, bout;

#if DEPTH == 32
            rout = s->rr * rin +
                   s->rg * gin +
                   s->rb * bin +
                   (have_alpha == 1 ? s->ra * ain : 0);
            gout = s->gr * rin +
                   s->gg * gin +
                   s->gb * bin +
                   (have_alpha == 1 ? s->ga * ain : 0);
            bout = s->br * rin +
                   s->bg * gin +
                   s->bb * bin +
                   (have_alpha == 1 ? s->ba * ain : 0);
#else
            rout = s->lut[R][R][rin] +
                   s->lut[R][G][gin] +
                   s->lut[R][B][bin] +
                   (have_alpha == 1 ? s->lut[R][A][ain] : 0);
            gout = s->lut[G][R][rin] +
                   s->lut[G][G][gin] +
                   s->lut[G][B][bin] +
                   (have_alpha == 1 ? s->lut[G][A][ain] : 0);
            bout = s->lut[B][R][rin] +
                   s->lut[B][G][gin] +
                   s->lut[B][B][bin] +
                   (have_alpha == 1 ? s->lut[B][A][ain] : 0);
#endif

            if (pc) {
                float frout, fgout, fbout, lin, lout;

#if DEPTH < 32
                frout = av_clipf(rout, 0.f, max);
                fgout = av_clipf(gout, 0.f, max);
                fbout = av_clipf(bout, 0.f, max);
#else
                frout = rout;
                fgout = gout;
                fbout = bout;
#endif

                preserve_color(s->preserve_color, rin, gin, bin,
                               rout, gout, bout, max, &lin, &lout);
                preservel(&frout, &fgout, &fbout, lin, lout, max);

                rout = ROUND(lerpf(rout, frout, pa));
                gout = ROUND(lerpf(gout, fgout, pa));
                bout = ROUND(lerpf(bout, fbout, pa));
            }

#if DEPTH < 32
            dstr[j] = av_clip_uintp2(rout, depth);
            dstg[j] = av_clip_uintp2(gout, depth);
            dstb[j] = av_clip_uintp2(bout, depth);
#else
            dstr[j] = rout;
            dstg[j] = gout;
            dstb[j] = bout;
#endif

            if (have_alpha == 1) {
#if DEPTH < 32
                dsta[j] = av_clip_uintp2(s->lut[A][R][rin] +
                                         s->lut[A][G][gin] +
                                         s->lut[A][B][bin] +
                                         s->lut[A][A][ain], depth);
#else
                dsta[j] = s->ar * rin +
                          s->ag * gin +
                          s->ab * bin +
                          s->aa * ain;
#endif
            }
        }

        srcg += in->linesize[0] / sizeof(pixel);
        srcb += in->linesize[1] / sizeof(pixel);
        srcr += in->linesize[2] / sizeof(pixel);
        srca += in->linesize[3] / sizeof(pixel);
        dstg += out->linesize[0] / sizeof(pixel);
        dstb += out->linesize[1] / sizeof(pixel);
        dstr += out->linesize[2] / sizeof(pixel);
        dsta += out->linesize[3] / sizeof(pixel);
    }

    return 0;
}

#if DEPTH < 32

static av_always_inline int fn(filter_slice_rgba_packed)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs,
                                                         int have_alpha, int step, int pc, int depth)
{
    ColorChannelMixerContext *s = ctx->priv;
    ThreadData *td = arg;
    AVFrame *in = td->in;
    AVFrame *out = td->out;
    const float pa = s->preserve_amount;
    const float max = (1 << depth) - 1;
    const int slice_start = (out->height * jobnr) / nb_jobs;
    const int slice_end = (out->height * (jobnr+1)) / nb_jobs;
    const uint8_t roffset = s->rgba_map[R];
    const uint8_t goffset = s->rgba_map[G];
    const uint8_t boffset = s->rgba_map[B];
    const uint8_t aoffset = s->rgba_map[A];
    const uint8_t *srcrow = in->data[0] + slice_start * in->linesize[0];
    uint8_t *dstrow = out->data[0] + slice_start * out->linesize[0];
    int i, j;

    for (i = slice_start; i < slice_end; i++) {
        const pixel *src = (const pixel *)srcrow;
        pixel *dst = (pixel *)dstrow;

        for (j = 0; j < out->width * step; j += step) {
            const pixel rin = src[j + roffset];
            const pixel gin = src[j + goffset];
            const pixel bin = src[j + boffset];
            const pixel ain = src[j + aoffset];
            int rout, gout, bout;

            rout = s->lut[R][R][rin] +
                   s->lut[R][G][gin] +
                   s->lut[R][B][bin] +
                   (have_alpha == 1 ? s->lut[R][A][ain] : 0);
            gout = s->lut[G][R][rin] +
                   s->lut[G][G][gin] +
                   s->lut[G][B][bin] +
                   (have_alpha == 1 ? s->lut[G][A][ain] : 0);
            bout = s->lut[B][R][rin] +
                   s->lut[B][G][gin] +
                   s->lut[B][B][bin] +
                   (have_alpha == 1 ? s->lut[B][A][ain] : 0);

            if (pc) {
                float frout = av_clipf(rout, 0.f, max);
                float fgout = av_clipf(gout, 0.f, max);
                float fbout = av_clipf(bout, 0.f, max);
                float lin, lout;

                preserve_color(s->preserve_color, rin, gin, bin,
                               rout, gout, bout, max, &lin, &lout);
                preservel(&frout, &fgout, &fbout, lin, lout, max);

                rout = lrintf(lerpf(rout, frout, pa));
                gout = lrintf(lerpf(gout, fgout, pa));
                bout = lrintf(lerpf(bout, fbout, pa));
            }

            dst[j + roffset] = av_clip_uintp2(rout, depth);
            dst[j + goffset] = av_clip_uintp2(gout, depth);
            dst[j + boffset] = av_clip_uintp2(bout, depth);

            if (have_alpha == 1) {
                dst[j + aoffset] = av_clip_uintp2(s->lut[A][R][rin] +
                                                  s->lut[A][G][gin] +
                                                  s->lut[A][B][bin] +
                                                  s->lut[A][A][ain], depth);
            }
        }

        srcrow += in->linesize[0];
        dstrow += out->linesize[0];
    }

    return 0;
}

#endif