/*

 * Copyright (C) 2001-2011 Michael Niedermayer <michaelni@gmx.at>

 *

 * 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 <stdint.h>

#include <stdio.h>

#include <string.h>

#include "libavutil/avassert.h"

#include "libavutil/bswap.h"

#include "libavutil/common.h"

#include "libavutil/cpu.h"

#include "libavutil/emms.h"

#include "libavutil/intreadwrite.h"

#include "libavutil/mem.h"

#include "libavutil/mem_internal.h"

#include "libavutil/pixdesc.h"

#include "libavutil/hwcontext.h"

#include "config.h"

#include "swscale_internal.h"

#include "swscale.h"

#if CONFIG_VULKAN

#include "vulkan/ops.h"

#endif

DECLARE_ALIGNED(8, const uint8_t, ff_dither_8x8_128)[9][8] = {

    {  36, 68,  60, 92,  34, 66,  58, 90, },

    { 100,  4, 124, 28,  98,  2, 122, 26, },

    {  52, 84,  44, 76,  50, 82,  42, 74, },

    { 116, 20, 108, 12, 114, 18, 106, 10, },

    {  32, 64,  56, 88,  38, 70,  62, 94, },

    {  96,  0, 120, 24, 102,  6, 126, 30, },

    {  48, 80,  40, 72,  54, 86,  46, 78, },

    { 112, 16, 104,  8, 118, 22, 110, 14, },

    {  36, 68,  60, 92,  34, 66,  58, 90, },

};

DECLARE_ALIGNED(8, static const uint8_t, sws_pb_64)[8] = {

    64, 64, 64, 64, 64, 64, 64, 64

};

static av_always_inline void fillPlane(uint8_t *plane, int stride, int width,

                                       int height, int y, uint8_t val)

{

    int i;

    uint8_t *ptr = plane + stride * y;

    for (i = 0; i < height; i++) {

        memset(ptr, val, width);

        ptr += stride;

    }

}

static void hScale16To19_c(SwsInternal *c, int16_t *_dst, int dstW,

                           const uint8_t *_src, const int16_t *filter,

                           const int32_t *filterPos, int filterSize)

{

    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->opts.src_format);

    int i;

    int32_t *dst        = (int32_t *) _dst;

    const uint16_t *src = (const uint16_t *) _src;

    int bits            = desc->comp[0].depth - 1;

    int sh              = bits - 4;

    if ((isAnyRGB(c->opts.src_format) || c->opts.src_format==AV_PIX_FMT_PAL8) && desc->comp[0].depth<16) {

        sh = 9;

    } else if (desc->flags & AV_PIX_FMT_FLAG_FLOAT) { /* float input are process like uint 16bpc */

        sh = 16 - 1 - 4;

    }

    for (i = 0; i < dstW; i++) {

        int j;

        int srcPos = filterPos[i];

        int val    = 0;

        for (j = 0; j < filterSize; j++) {

            val += src[srcPos + j] * filter[filterSize * i + j];

        }

        // filter=14 bit, input=16 bit, output=30 bit, >> 11 makes 19 bit

        dst[i] = FFMIN(val >> sh, (1 << 19) - 1);

    }

}

static void hScale16To15_c(SwsInternal *c, int16_t *dst, int dstW,

                           const uint8_t *_src, const int16_t *filter,

                           const int32_t *filterPos, int filterSize)

{

    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->opts.src_format);

    int i;

    const uint16_t *src = (const uint16_t *) _src;

    int sh              = desc->comp[0].depth - 1;

    if (sh<15) {

        sh = isAnyRGB(c->opts.src_format) || c->opts.src_format==AV_PIX_FMT_PAL8 ? 13 : (desc->comp[0].depth - 1);

    } else if (desc->flags & AV_PIX_FMT_FLAG_FLOAT) { /* float input are process like uint 16bpc */

        sh = 16 - 1;

    }

    for (i = 0; i < dstW; i++) {

        int j;

        int srcPos = filterPos[i];

        int val    = 0;

        for (j = 0; j < filterSize; j++) {

            val += src[srcPos + j] * filter[filterSize * i + j];

        }

        // filter=14 bit, input=16 bit, output=30 bit, >> 15 makes 15 bit

        dst[i] = FFMIN(val >> sh, (1 << 15) - 1);

    }

}

// bilinear / bicubic scaling

static void hScale8To15_c(SwsInternal *c, int16_t *dst, int dstW,

                          const uint8_t *src, const int16_t *filter,

                          const int32_t *filterPos, int filterSize)

{

    int i;

    for (i = 0; i < dstW; i++) {

        int j;

        int srcPos = filterPos[i];

        int val    = 0;

        for (j = 0; j < filterSize; j++) {

            val += ((int)src[srcPos + j]) * filter[filterSize * i + j];

        }

        dst[i] = FFMIN(val >> 7, (1 << 15) - 1); // the cubic equation does overflow ...

    }

}

static void hScale8To19_c(SwsInternal *c, int16_t *_dst, int dstW,

                          const uint8_t *src, const int16_t *filter,

                          const int32_t *filterPos, int filterSize)

{

    int i;

    int32_t *dst = (int32_t *) _dst;

    for (i = 0; i < dstW; i++) {

        int j;

        int srcPos = filterPos[i];

        int val    = 0;

        for (j = 0; j < filterSize; j++) {

            val += ((int)src[srcPos + j]) * filter[filterSize * i + j];

        }

        dst[i] = FFMIN(val >> 3, (1 << 19) - 1); // the cubic equation does overflow ...

    }

}

// FIXME all pal and rgb srcFormats could do this conversion as well

// FIXME all scalers more complex than bilinear could do half of this transform

static void chrRangeToJpeg_c(int16_t *dstU, int16_t *dstV, int width,

                             uint32_t _coeff, int64_t _offset)

{

    uint16_t coeff = _coeff;

    int32_t offset = _offset;

    int i;

    for (i = 0; i < width; i++) {

        int U = (dstU[i] * coeff + offset) >> 14;

        int V = (dstV[i] * coeff + offset) >> 14;

        dstU[i] = FFMIN(U, (1 << 15) - 1);

        dstV[i] = FFMIN(V, (1 << 15) - 1);

    }

}

static void chrRangeFromJpeg_c(int16_t *dstU, int16_t *dstV, int width,

                               uint32_t _coeff, int64_t _offset)

{

    uint16_t coeff = _coeff;

    int32_t offset = _offset;

    int i;

    for (i = 0; i < width; i++) {

        dstU[i] = (dstU[i] * coeff + offset) >> 14;

        dstV[i] = (dstV[i] * coeff + offset) >> 14;

    }

}

static void lumRangeToJpeg_c(int16_t *dst, int width,

                             uint32_t _coeff, int64_t _offset)

{

    uint16_t coeff = _coeff;

    int32_t offset = _offset;

    int i;

    for (i = 0; i < width; i++) {

        int Y = (dst[i] * coeff + offset) >> 14;

        dst[i] = FFMIN(Y, (1 << 15) - 1);

    }

}

static void lumRangeFromJpeg_c(int16_t *dst, int width,

                               uint32_t _coeff, int64_t _offset)

{

    uint16_t coeff = _coeff;

    int32_t offset = _offset;

    int i;

    for (i = 0; i < width; i++)

        dst[i] = (dst[i] * coeff + offset) >> 14;

}

static void chrRangeToJpeg16_c(int16_t *_dstU, int16_t *_dstV, int width,

                               uint32_t coeff, int64_t offset)

{

    int i;

    int32_t *dstU = (int32_t *) _dstU;

    int32_t *dstV = (int32_t *) _dstV;

    for (i = 0; i < width; i++) {

        int U = ((int64_t) dstU[i] * coeff + offset) >> 18;

        int V = ((int64_t) dstV[i] * coeff + offset) >> 18;

        dstU[i] = FFMIN(U, (1 << 19) - 1);

        dstV[i] = FFMIN(V, (1 << 19) - 1);

    }

}

static void chrRangeFromJpeg16_c(int16_t *_dstU, int16_t *_dstV, int width,

                                 uint32_t coeff, int64_t offset)

{

    int i;

    int32_t *dstU = (int32_t *) _dstU;

    int32_t *dstV = (int32_t *) _dstV;

    for (i = 0; i < width; i++) {

        dstU[i] = ((int64_t) dstU[i] * coeff + offset) >> 18;

        dstV[i] = ((int64_t) dstV[i] * coeff + offset) >> 18;

    }

}

static void lumRangeToJpeg16_c(int16_t *_dst, int width,

                               uint32_t coeff, int64_t offset)

{

    int i;

    int32_t *dst = (int32_t *) _dst;

    for (i = 0; i < width; i++) {

        int Y = ((int64_t) dst[i] * coeff + offset) >> 18;

        dst[i] = FFMIN(Y, (1 << 19) - 1);

    }

}

static void lumRangeFromJpeg16_c(int16_t *_dst, int width,

                                 uint32_t coeff, int64_t offset)

{

    int i;

    int32_t *dst = (int32_t *) _dst;

    for (i = 0; i < width; i++)

        dst[i] = ((int64_t) dst[i] * coeff + offset) >> 18;

}

#define DEBUG_SWSCALE_BUFFERS 0

#define DEBUG_BUFFERS(...)                      \

    if (DEBUG_SWSCALE_BUFFERS)                  \

        av_log(c, AV_LOG_DEBUG, __VA_ARGS__)

int ff_swscale(SwsInternal *c, const uint8_t *const src[], const int srcStride[],

               int srcSliceY, int srcSliceH, uint8_t *const dst[],

               const int dstStride[], int dstSliceY, int dstSliceH)

{

    const int scale_dst = dstSliceY > 0 || dstSliceH < c->opts.dst_h;

    /* load a few things into local vars to make the code more readable?

     * and faster */

    const int dstW                   = c->opts.dst_w;

    int dstH                         = c->opts.dst_h;

    const enum AVPixelFormat dstFormat = c->opts.dst_format;

    const int flags                  = c->opts.flags;

    int32_t *vLumFilterPos           = c->vLumFilterPos;

    int32_t *vChrFilterPos           = c->vChrFilterPos;

    const int vLumFilterSize         = c->vLumFilterSize;

    const int vChrFilterSize         = c->vChrFilterSize;

    yuv2planar1_fn yuv2plane1        = c->yuv2plane1;

    yuv2planarX_fn yuv2planeX        = c->yuv2planeX;

    yuv2interleavedX_fn yuv2nv12cX   = c->yuv2nv12cX;

    yuv2packed1_fn yuv2packed1       = c->yuv2packed1;

    yuv2packed2_fn yuv2packed2       = c->yuv2packed2;

    yuv2packedX_fn yuv2packedX       = c->yuv2packedX;

    yuv2anyX_fn yuv2anyX             = c->yuv2anyX;

    const int chrSrcSliceY           =                srcSliceY >> c->chrSrcVSubSample;

    const int chrSrcSliceH           = AV_CEIL_RSHIFT(srcSliceH,   c->chrSrcVSubSample);

    int should_dither                = isNBPS(c->opts.src_format) ||

                                       is16BPS(c->opts.src_format);

    int lastDstY;

    /* vars which will change and which we need to store back in the context */

    int dstY         = c->dstY;

    int lastInLumBuf = c->lastInLumBuf;

    int lastInChrBuf = c->lastInChrBuf;

    int lumStart = 0;

    int lumEnd = c->descIndex[0];

    int chrStart = lumEnd;

    int chrEnd = c->descIndex[1];

    int vStart = chrEnd;

    int vEnd = c->numDesc;

    SwsSlice *src_slice = &c->slice[lumStart];

    SwsSlice *hout_slice = &c->slice[c->numSlice-2];

    SwsSlice *vout_slice = &c->slice[c->numSlice-1];

    SwsFilterDescriptor *desc = c->desc;

    int needAlpha = c->needAlpha;

    int hasLumHoles = 1;

    int hasChrHoles = 1;

    const uint8_t *src2[4];

    int srcStride2[4];

    if (isPacked(c->opts.src_format)) {

        src2[0] =

        src2[1] =

        src2[2] =

        src2[3] = src[0];

        srcStride2[0] =

        srcStride2[1] =

        srcStride2[2] =

        srcStride2[3] = srcStride[0];

    } else {

        memcpy(src2, src, sizeof(src2));

        memcpy(srcStride2, srcStride, sizeof(srcStride2));

    }

    srcStride2[1] *= 1 << c->vChrDrop;

    srcStride2[2] *= 1 << c->vChrDrop;

    DEBUG_BUFFERS("swscale() %p[%d] %p[%d] %p[%d] %p[%d] -> %p[%d] %p[%d] %p[%d] %p[%d]\n",

                  src2[0], srcStride2[0], src2[1], srcStride2[1],

                  src2[2], srcStride2[2], src2[3], srcStride2[3],

                  dst[0], dstStride[0], dst[1], dstStride[1],

                  dst[2], dstStride[2], dst[3], dstStride[3]);

    DEBUG_BUFFERS("srcSliceY: %d srcSliceH: %d dstY: %d dstH: %d\n",

                  srcSliceY, srcSliceH, dstY, dstH);

    DEBUG_BUFFERS("vLumFilterSize: %d vChrFilterSize: %d\n",

                  vLumFilterSize, vChrFilterSize);

    if (dstStride[0]&15 || dstStride[1]&15 ||

        dstStride[2]&15 || dstStride[3]&15) {

        SwsInternal *const ctx = c->parent ? sws_internal(c->parent) : c;

        if (flags & SWS_PRINT_INFO &&

            !atomic_exchange_explicit(&ctx->stride_unaligned_warned, 1, memory_order_relaxed)) {

            av_log(c, AV_LOG_WARNING,

                   "Warning: dstStride is not aligned!\n"

                   "         ->cannot do aligned memory accesses anymore\n");

        }

    }

#if ARCH_X86

    if (   (uintptr_t) dst[0]&15 || (uintptr_t) dst[1]&15 || (uintptr_t) dst[2]&15

        || (uintptr_t)src2[0]&15 || (uintptr_t)src2[1]&15 || (uintptr_t)src2[2]&15

        ||  dstStride[0]&15 ||  dstStride[1]&15 ||  dstStride[2]&15 ||  dstStride[3]&15

        || srcStride2[0]&15 || srcStride2[1]&15 || srcStride2[2]&15 || srcStride2[3]&15

    ) {

        SwsInternal *const ctx = c->parent ? sws_internal(c->parent) : c;

        int cpu_flags = av_get_cpu_flags();

        if (flags & SWS_PRINT_INFO && HAVE_MMXEXT && (cpu_flags & AV_CPU_FLAG_SSE2) &&

            !atomic_exchange_explicit(&ctx->stride_unaligned_warned,1, memory_order_relaxed)) {

            av_log(c, AV_LOG_WARNING, "Warning: data is not aligned! This can lead to a speed loss\n");

        }

    }

#endif

    if (scale_dst) {

        dstY         = dstSliceY;

        dstH         = dstY + dstSliceH;

        lastInLumBuf = -1;

        lastInChrBuf = -1;

    } else if (srcSliceY == 0) {

        /* Note the user might start scaling the picture in the middle so this

         * will not get executed. This is not really intended but works

         * currently, so people might do it. */

        dstY         = 0;

        lastInLumBuf = -1;

        lastInChrBuf = -1;

    }

    if (!should_dither) {

        c->chrDither8 = c->lumDither8 = sws_pb_64;

    }

    lastDstY = dstY;

    ff_init_vscale_pfn(c, yuv2plane1, yuv2planeX, yuv2nv12cX,

                   yuv2packed1, yuv2packed2, yuv2packedX, yuv2anyX, c->use_mmx_vfilter);

    ff_init_slice_from_src(src_slice, (uint8_t**)src2, srcStride2, c->opts.src_w,

            srcSliceY, srcSliceH, chrSrcSliceY, chrSrcSliceH, 1);

    ff_init_slice_from_src(vout_slice, (uint8_t**)dst, dstStride, c->opts.dst_w,

            dstY, dstSliceH, dstY >> c->chrDstVSubSample,

            AV_CEIL_RSHIFT(dstSliceH, c->chrDstVSubSample), scale_dst);

    if (srcSliceY == 0) {

        hout_slice->plane[0].sliceY = lastInLumBuf + 1;

        hout_slice->plane[1].sliceY = lastInChrBuf + 1;

        hout_slice->plane[2].sliceY = lastInChrBuf + 1;

        hout_slice->plane[3].sliceY = lastInLumBuf + 1;

        hout_slice->plane[0].sliceH =

        hout_slice->plane[1].sliceH =

        hout_slice->plane[2].sliceH =

        hout_slice->plane[3].sliceH = 0;

        hout_slice->width = dstW;

    }

    for (; dstY < dstH; dstY++) {

        const int chrDstY = dstY >> c->chrDstVSubSample;

        int use_mmx_vfilter= c->use_mmx_vfilter;

        // First line needed as input

        const int firstLumSrcY  = FFMAX(1 - vLumFilterSize, vLumFilterPos[dstY]);

        const int firstLumSrcY2 = FFMAX(1 - vLumFilterSize, vLumFilterPos[FFMIN(dstY | ((1 << c->chrDstVSubSample) - 1), c->opts.dst_h - 1)]);

        // First line needed as input

        const int firstChrSrcY  = FFMAX(1 - vChrFilterSize, vChrFilterPos[chrDstY]);

        // Last line needed as input

        int lastLumSrcY  = FFMIN(c->opts.src_h,    firstLumSrcY  + vLumFilterSize) - 1;

        int lastLumSrcY2 = FFMIN(c->opts.src_h,    firstLumSrcY2 + vLumFilterSize) - 1;

        int lastChrSrcY  = FFMIN(c->chrSrcH, firstChrSrcY  + vChrFilterSize) - 1;

        int enough_lines;

        int i;

        int posY, cPosY, firstPosY, lastPosY, firstCPosY, lastCPosY;

        // handle holes (FAST_BILINEAR & weird filters)

        if (firstLumSrcY > lastInLumBuf) {

            hasLumHoles = lastInLumBuf != firstLumSrcY - 1;

            if (hasLumHoles) {

                hout_slice->plane[0].sliceY = firstLumSrcY;

                hout_slice->plane[3].sliceY = firstLumSrcY;

                hout_slice->plane[0].sliceH =

                hout_slice->plane[3].sliceH = 0;

            }

            lastInLumBuf = firstLumSrcY - 1;

        }

        if (firstChrSrcY > lastInChrBuf) {

            hasChrHoles = lastInChrBuf != firstChrSrcY - 1;

            if (hasChrHoles) {

                hout_slice->plane[1].sliceY = firstChrSrcY;

                hout_slice->plane[2].sliceY = firstChrSrcY;

                hout_slice->plane[1].sliceH =

                hout_slice->plane[2].sliceH = 0;

            }

            lastInChrBuf = firstChrSrcY - 1;

        }

        DEBUG_BUFFERS("dstY: %d\n", dstY);

        DEBUG_BUFFERS("\tfirstLumSrcY: %d lastLumSrcY: %d lastInLumBuf: %d\n",

                      firstLumSrcY, lastLumSrcY, lastInLumBuf);

        DEBUG_BUFFERS("\tfirstChrSrcY: %d lastChrSrcY: %d lastInChrBuf: %d\n",

                      firstChrSrcY, lastChrSrcY, lastInChrBuf);

        // Do we have enough lines in this slice to output the dstY line

        enough_lines = lastLumSrcY2 < srcSliceY + srcSliceH &&

                       lastChrSrcY < AV_CEIL_RSHIFT(srcSliceY + srcSliceH, c->chrSrcVSubSample);

        if (!enough_lines) {

            lastLumSrcY = srcSliceY + srcSliceH - 1;

            lastChrSrcY = chrSrcSliceY + chrSrcSliceH - 1;

            DEBUG_BUFFERS("buffering slice: lastLumSrcY %d lastChrSrcY %d\n",

                          lastLumSrcY, lastChrSrcY);

        }

        av_assert0((lastLumSrcY - firstLumSrcY + 1) <= hout_slice->plane[0].available_lines);

        av_assert0((lastChrSrcY - firstChrSrcY + 1) <= hout_slice->plane[1].available_lines);

        posY = hout_slice->plane[0].sliceY + hout_slice->plane[0].sliceH;

        if (posY <= lastLumSrcY && !hasLumHoles) {

            firstPosY = FFMAX(firstLumSrcY, posY);

            lastPosY = FFMIN(firstLumSrcY + hout_slice->plane[0].available_lines - 1, srcSliceY + srcSliceH - 1);

        } else {

            firstPosY = posY;

            lastPosY = lastLumSrcY;

        }

        cPosY = hout_slice->plane[1].sliceY + hout_slice->plane[1].sliceH;

        if (cPosY <= lastChrSrcY && !hasChrHoles) {

            firstCPosY = FFMAX(firstChrSrcY, cPosY);

            lastCPosY = FFMIN(firstChrSrcY + hout_slice->plane[1].available_lines - 1, AV_CEIL_RSHIFT(srcSliceY + srcSliceH, c->chrSrcVSubSample) - 1);

        } else {

            firstCPosY = cPosY;

            lastCPosY = lastChrSrcY;

        }

        ff_rotate_slice(hout_slice, lastPosY, lastCPosY);

        if (posY < lastLumSrcY + 1) {

            for (i = lumStart; i < lumEnd; ++i)

                desc[i].process(c, &desc[i], firstPosY, lastPosY - firstPosY + 1);

        }

        lastInLumBuf = lastLumSrcY;

        if (cPosY < lastChrSrcY + 1) {

            for (i = chrStart; i < chrEnd; ++i)

                desc[i].process(c, &desc[i], firstCPosY, lastCPosY - firstCPosY + 1);

        }

        lastInChrBuf = lastChrSrcY;

        if (!enough_lines)

            break;  // we can't output a dstY line so let's try with the next slice

#if HAVE_MMX_INLINE

        ff_updateMMXDitherTables(c, dstY);

        c->dstW_mmx = c->opts.dst_w;

#endif

        if (should_dither) {

            c->chrDither8 = ff_dither_8x8_128[chrDstY & 7];

            c->lumDither8 = ff_dither_8x8_128[dstY    & 7];

        }

        if (dstY >= c->opts.dst_h - 2) {

            /* hmm looks like we can't use MMX here without overwriting

             * this array's tail */

            ff_sws_init_output_funcs(c, &yuv2plane1, &yuv2planeX, &yuv2nv12cX,

                                     &yuv2packed1, &yuv2packed2, &yuv2packedX, &yuv2anyX);

            use_mmx_vfilter= 0;

            ff_init_vscale_pfn(c, yuv2plane1, yuv2planeX, yuv2nv12cX,

                           yuv2packed1, yuv2packed2, yuv2packedX, yuv2anyX, use_mmx_vfilter);

        }

        for (i = vStart; i < vEnd; ++i)

            desc[i].process(c, &desc[i], dstY, 1);

    }

    if (isPlanar(dstFormat) && isALPHA(dstFormat) && !needAlpha) {

        int offset = lastDstY - dstSliceY;

        int length = dstW;

        int height = dstY - lastDstY;

        if (is16BPS(dstFormat) || isNBPS(dstFormat)) {

            const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(dstFormat);

            fillPlane16(dst[3], dstStride[3], length, height, offset,

                    1, desc->comp[3].depth,

                    isBE(dstFormat));

        } else if (is32BPS(dstFormat)) {

            const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(dstFormat);

            fillPlane32(dst[3], dstStride[3], length, height, offset,

                    1, desc->comp[3].depth,

                    isBE(dstFormat), desc->flags & AV_PIX_FMT_FLAG_FLOAT);

        } else

            fillPlane(dst[3], dstStride[3], length, height, offset, 255);

    }

#if HAVE_MMXEXT_INLINE

    if (av_get_cpu_flags() & AV_CPU_FLAG_MMXEXT)

        __asm__ volatile ("sfence" ::: "memory");

#endif

    emms_c();

    /* store changed local vars back in the context */

    c->dstY         = dstY;

    c->lastInLumBuf = lastInLumBuf;

    c->lastInChrBuf = lastInChrBuf;

    return dstY - lastDstY;

}

/*

 * Solve for coeff and offset:

 * dst = ((src << src_shift) * coeff + offset) >> (mult_shift + src_shift)

 *

 * If SwsInternal->dstBpc is > 14, coeff is uint16_t and offset is int32_t,

 * otherwise (SwsInternal->dstBpc is <= 14) coeff is uint32_t and offset is

 * int64_t.

 */

static void solve_range_convert(uint16_t src_min, uint16_t src_max,

                                uint16_t dst_min, uint16_t dst_max,

                                int src_bits, int src_shift, int mult_shift,

                                uint32_t *coeff, int64_t *offset)

{

    uint16_t src_range = src_max - src_min;

    uint16_t dst_range = dst_max - dst_min;

    int total_shift = mult_shift + src_shift;

    *coeff = AV_CEIL_RSHIFT(((uint64_t) dst_range << total_shift) / src_range, src_shift);

    *offset = ((int64_t) dst_max << total_shift) -

              ((int64_t) src_max << src_shift) * *coeff +

              (1U << (mult_shift - 1));

}

static void init_range_convert_constants(SwsInternal *c)

{

    const int bit_depth = c->dstBpc ? FFMIN(c->dstBpc, 16) : 8;

    const int src_bits = bit_depth <= 14 ? 15 : 19;

    const int src_shift = src_bits - bit_depth;

    const int mult_shift = bit_depth <= 14 ? 14 : 18;

    const uint16_t mpeg_min = 16U << (bit_depth - 8);

    const uint16_t mpeg_max_lum = 235U << (bit_depth - 8);

    const uint16_t mpeg_max_chr = 240U << (bit_depth - 8);

    const uint16_t jpeg_max = (1U << bit_depth) - 1;

    uint16_t src_min, src_max_lum, src_max_chr;

    uint16_t dst_min, dst_max_lum, dst_max_chr;

    if (c->opts.src_range) {

        src_min     = 0;

        src_max_lum = jpeg_max;

        src_max_chr = jpeg_max;

        dst_min     = mpeg_min;

        dst_max_lum = mpeg_max_lum;

        dst_max_chr = mpeg_max_chr;

    } else {

        src_min     = mpeg_min;

        src_max_lum = mpeg_max_lum;

        src_max_chr = mpeg_max_chr;

        dst_min     = 0;

        dst_max_lum = jpeg_max;

        dst_max_chr = jpeg_max;

    }

    solve_range_convert(src_min, src_max_lum, dst_min, dst_max_lum,

                        src_bits, src_shift, mult_shift,

                        &c->lumConvertRange_coeff, &c->lumConvertRange_offset);

    solve_range_convert(src_min, src_max_chr, dst_min, dst_max_chr,

                        src_bits, src_shift, mult_shift,

                        &c->chrConvertRange_coeff, &c->chrConvertRange_offset);

}

av_cold void ff_sws_init_range_convert(SwsInternal *c)

{

    c->lumConvertRange = NULL;

    c->chrConvertRange = NULL;

    if (c->opts.src_range != c->opts.dst_range && !isAnyRGB(c->opts.dst_format) && c->dstBpc < 32) {

        init_range_convert_constants(c);

        if (c->dstBpc <= 14) {

            if (c->opts.src_range) {

                c->lumConvertRange = lumRangeFromJpeg_c;

                c->chrConvertRange = chrRangeFromJpeg_c;

            } else {

                c->lumConvertRange = lumRangeToJpeg_c;

                c->chrConvertRange = chrRangeToJpeg_c;

            }

        } else {

            if (c->opts.src_range) {

                c->lumConvertRange = lumRangeFromJpeg16_c;

                c->chrConvertRange = chrRangeFromJpeg16_c;

            } else {

                c->lumConvertRange = lumRangeToJpeg16_c;

                c->chrConvertRange = chrRangeToJpeg16_c;

            }

        }

#if ARCH_AARCH64

        ff_sws_init_range_convert_aarch64(c);

#elif ARCH_LOONGARCH64

        ff_sws_init_range_convert_loongarch(c);

#elif ARCH_RISCV

        ff_sws_init_range_convert_riscv(c);

#elif ARCH_X86

        ff_sws_init_range_convert_x86(c);

#endif

    }

}

static av_cold void sws_init_swscale(SwsInternal *c)

{

    enum AVPixelFormat srcFormat = c->opts.src_format;

    ff_sws_init_xyzdsp(c);

    ff_sws_init_output_funcs(c, &c->yuv2plane1, &c->yuv2planeX,

                             &c->yuv2nv12cX, &c->yuv2packed1,

                             &c->yuv2packed2, &c->yuv2packedX, &c->yuv2anyX);

    ff_sws_init_input_funcs(c, &c->lumToYV12, &c->alpToYV12, &c->chrToYV12,

                            &c->readLumPlanar, &c->readAlpPlanar, &c->readChrPlanar);

    if (c->srcBpc == 8) {

        if (c->dstBpc <= 14) {

            c->hyScale = c->hcScale = hScale8To15_c;

            if (c->opts.flags & SWS_FAST_BILINEAR) {

                c->hyscale_fast = ff_hyscale_fast_c;

                c->hcscale_fast = ff_hcscale_fast_c;

            }

        } else {

            c->hyScale = c->hcScale = hScale8To19_c;

        }

    } else {

        c->hyScale = c->hcScale = c->dstBpc > 14 ? hScale16To19_c

                                                 : hScale16To15_c;

    }

    ff_sws_init_range_convert(c);

    if (!(isGray(srcFormat) || isGray(c->opts.dst_format) ||

          srcFormat == AV_PIX_FMT_MONOBLACK || srcFormat == AV_PIX_FMT_MONOWHITE))

        c->needs_hcscale = 1;

}

void ff_sws_init_scale(SwsInternal *c)

{

    sws_init_swscale(c);

#if ARCH_PPC

    ff_sws_init_swscale_ppc(c);

#elif ARCH_X86

    ff_sws_init_swscale_x86(c);

#elif ARCH_AARCH64

    ff_sws_init_swscale_aarch64(c);

#elif ARCH_ARM

    ff_sws_init_swscale_arm(c);

#elif ARCH_LOONGARCH64

    ff_sws_init_swscale_loongarch(c);

#elif ARCH_RISCV

    ff_sws_init_swscale_riscv(c);

#endif

}

static void reset_ptr(const uint8_t *src[], enum AVPixelFormat format)

{

    if (!isALPHA(format))

        src[3] = NULL;

    if (!isPlanar(format)) {

        src[3] = src[2] = NULL;

        if (!usePal(format))

            src[1] = NULL;

    }

}

static int check_image_pointers(const uint8_t * const data[4], enum AVPixelFormat pix_fmt,

                                const int linesizes[4])

{

    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

    int i;

    av_assert2(desc);

    for (i = 0; i < 4; i++) {

        int plane = desc->comp[i].plane;

        if (!data[plane] || !linesizes[plane])

            return 0;

    }

    return 1;

}

static void xyz12Torgb48_c(const SwsInternal *c, uint8_t *dst, int dst_stride,

                           const uint8_t *src, int src_stride, int w, int h)

{

    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->opts.src_format);

    for (int yp = 0; yp < h; yp++) {

        const uint16_t *src16 = (const uint16_t *) src;

        uint16_t *dst16 = (uint16_t *) dst;

        for (int xp = 0; xp < 3 * w; xp += 3) {

            int x, y, z, r, g, b;

            if (desc->flags & AV_PIX_FMT_FLAG_BE) {

                x = AV_RB16(src16 + xp + 0);

                y = AV_RB16(src16 + xp + 1);

                z = AV_RB16(src16 + xp + 2);

            } else {

                x = AV_RL16(src16 + xp + 0);

                y = AV_RL16(src16 + xp + 1);

                z = AV_RL16(src16 + xp + 2);

            }

            x = c->xyz2rgb.gamma.in[x >> 4];

            y = c->xyz2rgb.gamma.in[y >> 4];

            z = c->xyz2rgb.gamma.in[z >> 4];

            // convert from XYZlinear to sRGBlinear

            r = c->xyz2rgb.mat[0][0] * x +

                c->xyz2rgb.mat[0][1] * y +

                c->xyz2rgb.mat[0][2] * z >> 12;

            g = c->xyz2rgb.mat[1][0] * x +

                c->xyz2rgb.mat[1][1] * y +

                c->xyz2rgb.mat[1][2] * z >> 12;

            b = c->xyz2rgb.mat[2][0] * x +

                c->xyz2rgb.mat[2][1] * y +

                c->xyz2rgb.mat[2][2] * z >> 12;

            // limit values to 16-bit depth

            r = av_clip_uint16(r);

            g = av_clip_uint16(g);

            b = av_clip_uint16(b);

            // convert from sRGBlinear to RGB and scale from 12bit to 16bit

            if (desc->flags & AV_PIX_FMT_FLAG_BE) {

                AV_WB16(dst16 + xp + 0, c->xyz2rgb.gamma.out[r] << 4);

                AV_WB16(dst16 + xp + 1, c->xyz2rgb.gamma.out[g] << 4);

                AV_WB16(dst16 + xp + 2, c->xyz2rgb.gamma.out[b] << 4);

            } else {

                AV_WL16(dst16 + xp + 0, c->xyz2rgb.gamma.out[r] << 4);

                AV_WL16(dst16 + xp + 1, c->xyz2rgb.gamma.out[g] << 4);

                AV_WL16(dst16 + xp + 2, c->xyz2rgb.gamma.out[b] << 4);

            }

        }

        src += src_stride;

        dst += dst_stride;

    }

}

static void rgb48Toxyz12_c(const SwsInternal *c, uint8_t *dst, int dst_stride,

                           const uint8_t *src, int src_stride, int w, int h)

{

    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->opts.dst_format);

    for (int yp = 0; yp < h; yp++) {

        uint16_t *src16 = (uint16_t *) src;

        uint16_t *dst16 = (uint16_t *) dst;

        for (int xp = 0; xp < 3 * w; xp += 3) {

            int x, y, z, r, g, b;

            if (desc->flags & AV_PIX_FMT_FLAG_BE) {

                r = AV_RB16(src16 + xp + 0);

                g = AV_RB16(src16 + xp + 1);

                b = AV_RB16(src16 + xp + 2);

            } else {

                r = AV_RL16(src16 + xp + 0);

                g = AV_RL16(src16 + xp + 1);

                b = AV_RL16(src16 + xp + 2);

            }

            r = c->rgb2xyz.gamma.in[r >> 4];

            g = c->rgb2xyz.gamma.in[g >> 4];

            b = c->rgb2xyz.gamma.in[b >> 4];

            // convert from sRGBlinear to XYZlinear

            x = c->rgb2xyz.mat[0][0] * r +

                c->rgb2xyz.mat[0][1] * g +

                c->rgb2xyz.mat[0][2] * b >> 12;

            y = c->rgb2xyz.mat[1][0] * r +

                c->rgb2xyz.mat[1][1] * g +

                c->rgb2xyz.mat[1][2] * b >> 12;

            z = c->rgb2xyz.mat[2][0] * r +

                c->rgb2xyz.mat[2][1] * g +

                c->rgb2xyz.mat[2][2] * b >> 12;

            // limit values to 16-bit depth

            x = av_clip_uint16(x);

            y = av_clip_uint16(y);

            z = av_clip_uint16(z);

            // convert from XYZlinear to X'Y'Z' and scale from 12bit to 16bit

            if (desc->flags & AV_PIX_FMT_FLAG_BE) {

                AV_WB16(dst16 + xp + 0, c->rgb2xyz.gamma.out[x] << 4);

                AV_WB16(dst16 + xp + 1, c->rgb2xyz.gamma.out[y] << 4);

                AV_WB16(dst16 + xp + 2, c->rgb2xyz.gamma.out[z] << 4);

            } else {

                AV_WL16(dst16 + xp + 0, c->rgb2xyz.gamma.out[x] << 4);

                AV_WL16(dst16 + xp + 1, c->rgb2xyz.gamma.out[y] << 4);

                AV_WL16(dst16 + xp + 2, c->rgb2xyz.gamma.out[z] << 4);

            }

        }

        src += src_stride;

        dst += dst_stride;

    }

}

av_cold void ff_sws_init_xyzdsp(SwsInternal *c)

{

    c->xyz12Torgb48 = xyz12Torgb48_c;

    c->rgb48Toxyz12 = rgb48Toxyz12_c;

#if ARCH_AARCH64

    ff_sws_init_xyzdsp_aarch64(c);

#endif

}

void ff_update_palette(SwsInternal *c, const uint32_t *pal)

{

    uint32_t *rgb2yuv = c->input_rgb2yuv_table;

    int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];

    int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];

    int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];