/* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and /or associated documentation files

 * (the "Materials "), to deal in the Materials without restriction,

 * including without limitation the rights to use, copy, modify, merge,

 * publish, distribute, sublicense, and/or sell copies of the Materials,

 * and to permit persons to whom the Materials are furnished to do so,

 * subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included

 * in all copies or substantial portions of the Materials.

 *

 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR

 * THE USE OR OTHER DEALINGS IN THE MATERIALS.

 */

// This file contains the generated pixel-pipeline code and provides

// interface to compile and run them.

#ifndef __RIRASTERIZER_H

#   include "riRasterizer.h"

#endif

#ifndef __RIPIXELPIPE_H

#   include "riPixelPipe.h"

#endif

#ifndef __SFDYNAMICPIXELPIPE_H

#   include "sfDynamicPixelPipe.h"

#endif

#ifndef __RIUTILS_H

#   include "riUtils.h"

#endif

#ifndef __SFMASK_H

#   include "sfMask.h"

#endif

#ifndef __RIIMAGE_H

#   include "riImage.h"

#endif

#if defined(RI_DEBUG)

#   include <stdio.h>

#endif

namespace OpenVGRI {

RI_INLINE static bool alwaysLoadDst(const PixelPipe::SignatureState& state)

{

    if (!state.isRenderToMask)

    {

        if (state.hasImage)

            return true;

        VGBlendMode bm = state.blendMode;

        if (bm == VG_BLEND_SRC_IN ||

                bm == VG_BLEND_DST_OVER ||

                bm == VG_BLEND_DST_IN ||

                bm == VG_BLEND_ADDITIVE ||

                bm == VG_BLEND_MULTIPLY ||

                bm == VG_BLEND_SCREEN ||

                bm == VG_BLEND_DARKEN ||

                bm == VG_BLEND_LIGHTEN)

        {

            return true;

        } else

        {

            return false;

        }

    }

    else

    {

        switch (state.maskOperation)

        {

        case VG_SET_MASK:

            return false;

        default:

            return true;

        }

    }

}

RI_INLINE static bool canSolidFill(const PixelPipe::SignatureState& state)

{

    if (state.isRenderToMask)

    {

        if (state.maskOperation == VG_SET_MASK ||

            state.maskOperation == VG_UNION_MASK)

            return true;

        // \note SUBTRACT is also possible.

        return false;

    }

    if (state.paintType != VG_PAINT_TYPE_COLOR)

        return false;

    if (state.hasImage)

        return false;

    // Some blendmodes can use dst color even if coverage == 1.0

    if (state.blendMode != VG_BLEND_SRC && state.blendMode != VG_BLEND_SRC_OVER)

        return false;

    if (state.hasMasking)

        return false;

    if (state.fillColorTransparent)

        return false;

    if (state.hasColorTransform)

        return false; // \todo Trace solid color alpha -> 1.0

    return true;

}

RI_INLINE static int intReflectRepeat(int n, int bits)

{

    const int mask = (1<<bits)-1;

    return (n ^ (n << (31 - bits) >> 31)) & mask;

}

RI_INLINE static void applyGradientRepeat(int& sx0, int& sx1, PixelPipe::TilingMode sm)

{

    switch (sm)

    {

    case PixelPipe::TILING_MODE_PAD:

        sx0 = RI_INT_CLAMP(sx0, 0, PixelPipe::SAMPLE_MASK);

        sx1 = RI_INT_CLAMP(sx1, 0, PixelPipe::SAMPLE_MASK);

        break;

    case PixelPipe::TILING_MODE_REFLECT:

        sx0 = intReflectRepeat(sx0, PixelPipe::SAMPLE_BITS);

        sx1 = intReflectRepeat(sx1, PixelPipe::SAMPLE_BITS);

        break;

    default:

        RI_ASSERT(sm == PixelPipe::TILING_MODE_REPEAT);

        sx0 = sx0 & PixelPipe::SAMPLE_MASK;

        sx1 = sx1 & PixelPipe::SAMPLE_MASK;

        break;

    }

    RI_ASSERT(sx0 >= 0 && sx0 < (1<<Paint::GRADIENT_LUT_BITS));

    RI_ASSERT(sx1 >= 0 && sx1 < (1<<Paint::GRADIENT_LUT_BITS));

}

RI_INLINE static IntegerColor readLUTColor(const PixelPipe::PPUniforms& uniforms, int i)

{

    RI_ASSERT(i >= 0 && i <= Paint::GRADIENT_LUT_MASK);

    return uniforms.gradientLookup[i];

}

/**

 * \brief   Sample linear gradient using integer-arithmetic.

 * \note    The actual gradient computation is done piecewise within the

 *          pixel-pipeline.

 */

RI_INLINE static IntegerColor intLinearGradient(const PixelPipe::SignatureState& state, const PixelPipe::PPUniforms& u, const PixelPipe::PPVariants& v)

{

    RIint32 sx0 = v.sx >> (PixelPipe::GRADIENT_BITS - PixelPipe::SAMPLE_BITS);

    RIint32 sx1 = sx0 + 1;

    applyGradientRepeat(sx0, sx1, state.paintTilingMode);

    IntegerColor ic0 = readLUTColor(u, sx0 >> (PixelPipe::SAMPLE_BITS - Paint::GRADIENT_LUT_BITS));

    if (true)

    {

        return ic0;

    } else

    {

        // bilinear interpolation

        //RIint32 f1 = sx0; 

        readLUTColor(u, sx1 >> (PixelPipe::SAMPLE_BITS - Paint::GRADIENT_LUT_BITS));

        RI_ASSERT(false);

        return IntegerColor(0,0,0,0);

    }

} 

/**

 * \brief   Radial gradient implementation for the integer-pipeline. Will use float at least

 *          for the square-root. Will return integer-color always.

 */

RI_INLINE static IntegerColor intRadialGradient(const PixelPipe::SignatureState& state, const PixelPipe::PPUniforms& u, const PixelPipe::PPVariants& v)

{

    RGScalar a = (v.rx * u.rfxp) + (v.ry * u.rfyp);

    RGScalar b = u.rsqrp * (RI_SQR(v.rx) + RI_SQR(v.ry));

    RGScalar c = RI_SQR((v.rx * u.rfyp) - (v.ry * u.rfxp));

    RGScalar d = b - c;

    RI_ASSERT(!RI_ISNAN(d) ? d >= 0.0f : true);

    RGScalar g = (a + sqrtf(d));

    int sx0 = RI_FLOAT_TO_FX(g, PixelPipe::SAMPLE_BITS);

    int sx1 = sx0 + 1;

    applyGradientRepeat(sx0, sx1, state.paintTilingMode);

    IntegerColor ic0 = readLUTColor(u, sx0 >> (PixelPipe::SAMPLE_BITS - Paint::GRADIENT_LUT_BITS));

    RI_ASSERT(ic0.r <= 255);

    RI_ASSERT(ic0.g <= 255);

    RI_ASSERT(ic0.b <= 255);

    RI_ASSERT(ic0.a <= 255);

    if (false)

    {

        // Linear interpolation of 2 gradient samples.

        IntegerColor ic1 = readLUTColor(u, sx1 >> (PixelPipe::SAMPLE_BITS - Paint::GRADIENT_LUT_BITS));

        //int fx0 = sx0 & PixelPipe::SAMPLE_MASK;

        //int fx1 = PixelPipe::SAMPLE_MASK - fx0;

    }

    return ic0;

}

RI_INLINE static bool applyPatternRepeat(int &x, int &y, PixelPipe::TilingMode tilingMode)

{

    switch (tilingMode)

    {

    case PixelPipe::TILING_MODE_PAD:

        x = RI_INT_CLAMP(x, 0, PixelPipe::GRADIENT_MASK);

        y = RI_INT_CLAMP(y, 0, PixelPipe::GRADIENT_MASK);

        break; 

    case PixelPipe::TILING_MODE_REPEAT:

        x = x & PixelPipe::GRADIENT_MASK;

        y = y & PixelPipe::GRADIENT_MASK;

        break;

    case PixelPipe::TILING_MODE_REFLECT:

        x = intReflectRepeat(x, PixelPipe::GRADIENT_BITS);

        y = intReflectRepeat(y, PixelPipe::GRADIENT_BITS);

        break;

    default:

        RI_ASSERT(tilingMode == PixelPipe::TILING_MODE_FILL);

        // Do nothing -> Fill is checked on integer coordinates.

        break;

    }

    return false;

}

/**

 * \brief   Same as applyPatternRepeat, but with pattern-space integer coordinates without

 *          fractional part.

 * \note    Assumes that the coordinate is in range [0,width or height].

 */

RI_INLINE static bool applyPatternSampleRepeat(int &x, int &y, int w, int h, PixelPipe::TilingMode tilingMode)

{

    switch (tilingMode)

    {

    case PixelPipe::TILING_MODE_PAD:

        RI_ASSERT(x >= 0 && x <= w);

        RI_ASSERT(y >= 0 && y <= h);

        if (x >= w) x = w-1;

        if (y >= h) y = h-1;

        break;

    case PixelPipe::TILING_MODE_REPEAT:

        RI_ASSERT(x >= 0 && x <= w);

        RI_ASSERT(y >= 0 && y <= h);

        if (x >= w) x = 0;

        if (y >= h) y = 0;

        break;

    case PixelPipe::TILING_MODE_REFLECT:

        RI_ASSERT(x >= 0 && x <= w);

        RI_ASSERT(y >= 0 && y <= h);

        if (x >= w) x = w-1; // w-2?

        if (y >= h) y = h-1; // h-2?

        break;

    default:

        RI_ASSERT(tilingMode == PixelPipe::TILING_MODE_FILL);

        if (x < 0 || x >= w) return true;

        if (y < 0 || y >= h) return true;

        break;

    }

    return false;

}

RI_INLINE IntegerColor readPattern(const void* basePtr, int stride, const Color::Descriptor& desc, int ix, int iy, const IntegerColor* fillColor, bool fill)

{

    const void* ptr = Image::calculateAddress(basePtr, desc.bitsPerPixel, ix, iy, stride);

    if (!fill)

        return IntegerColor(Image::readPackedPixelFromAddress(ptr, desc.bitsPerPixel, ix), desc);

    else

    {

        RI_ASSERT(fillColor);

        return *fillColor; 

    }

}

/**

 * \brief   Rescale the result of bilinear interpolation.

 * \todo    See if this or individual shifts and rounds are faster on x86

 */

RI_INLINE static RIuint32 bilinearDiv(unsigned int c)

{

    RIuint32 rcp = 33026;

    RIuint64 m = (RIuint64)c * rcp;

    RIuint32 d = (RIuint32)(m >> 30);

    return (d >> 1) + (d & 1);

}

/**

 * \brief   Read an optionally filtered sample from an image. For multiple samples, apply repeat

 *          for all the generated sampling points. This only implements a simple sampling: nearest

 *          or Linear filtering and is much simpler than the original RI.

 * \param   image       Image to sample from

 * \param   sx0         Sample x in .8 fixed point. MUST be within the image except for FILL.

 * \param   sy0         Sample y in .8 fixed point. MUST be within the image except for FILL.

 * \param   samplerType Type of the sampler used.

 * \param   tilingMode  Tiling mode for generated sample points, if required.

 * \param   fillColor   Color to use for TILING_MODE_FILL

 * \todo Where should we determine if a NN-sample needs to be unpacked?

 *       -> It is also easy to just read that sample separately.

 */

RI_INLINE static IntegerColor intSampleImage(

    const void* ptr,

    int stride,

    int w,

    int h,

    const Color::Descriptor& desc,

    RIint32 sx0, 

    RIint32 sy0, 

    PixelPipe::SamplerType samplerType, 

    PixelPipe::TilingMode tilingMode, 

    const IntegerColor* fillColor)

{

    RI_ASSERT(fillColor || (tilingMode != PixelPipe::TILING_MODE_FILL));

    // \todo The following code is between low- and high-level representation of sampling.

    // It should probably be modified to appear fully as low-level, since we want as many

    // optimizations as possible.

    const bool bilinear = samplerType == PixelPipe::SAMPLER_TYPE_LINEAR;

    IntegerColor retColor;

    bool maybeFill = tilingMode == PixelPipe::TILING_MODE_FILL;

    bool fillSample = false;

    RIint32 ix, iy;

    IntegerColor ic00;

    RIint32 fx = sx0 & 0xff;

    RIint32 fy = sy0 & 0xff;

    ix = sx0 >> PixelPipe::SAMPLE_BITS;

    iy = sy0 >> PixelPipe::SAMPLE_BITS;

    if (maybeFill)

    {

        if (ix < 0 || ix >= w)

            fillSample = true;

        if (iy < 0 || iy >= h)

            fillSample = true;

    }

    ic00 = readPattern(ptr, stride, desc, ix, iy, fillColor, fillSample);

    if (!bilinear)

    {

        retColor = ic00;

        retColor.expandColor(desc); // \todo Handling of bilinear?

    }

    else

    {

        // Bilinear filtering.

        IntegerColor ic01, ic10, ic11;

        IntegerColor t0, t1;

        int xs = ix + 1;

        int ys = iy;

        fillSample = applyPatternSampleRepeat(xs, ys, w, h, tilingMode);

        ic01 = readPattern(ptr, stride, desc, xs, ys, fillColor, fillSample);

        t0 = IntegerColor::linearBlendNS(ic00, ic01, fx);

        xs = ix;

        ys = iy+1;

        fillSample = applyPatternSampleRepeat(xs, ys, w, h, tilingMode);

        ic10 = readPattern(ptr, stride, desc, xs, ys, fillColor, fillSample);

        xs = ix+1;

        ys = iy+1;

        fillSample = applyPatternSampleRepeat(xs, ys, w, h, tilingMode);

        ic11 = readPattern(ptr, stride, desc, xs, ys, fillColor, fillSample);

        t1 = IntegerColor::linearBlendNS(ic10, ic11, fx);

        retColor = IntegerColor::linearBlendNS(t0, t1, fy);

        retColor.r = bilinearDiv(retColor.r);

        retColor.g = bilinearDiv(retColor.g);

        retColor.b = bilinearDiv(retColor.b);

        retColor.a = bilinearDiv(retColor.a);

        return retColor;

    }

    return retColor;

}

RI_INLINE static RIint32 gradientToFixedCoords(RIint32 gradCoord, RIint32 dim)

{

    return (RIint32)(((RIint64)dim * gradCoord) >> (PixelPipe::GRADIENT_BITS - PixelPipe::SAMPLE_BITS));

}

RI_INLINE static IntegerColor intPattern(const PixelPipe::SignatureState &state, const PixelPipe::PPUniforms& u, const PixelPipe::PPVariants& v)

{

    // \todo The following code is between low- and high-level representation of sampling.

    // It should probably be modified to appear fully as low-level, since we want as many

    // optimizations as possible.

    // "External" variables

    const PixelPipe::TilingMode tilingMode = state.paintTilingMode;

    const IntegerColor fillColor = u.tileFillColor;

    const int w = u.paint_width;

    const int h = u.paint_height;

    IntegerColor retColor;

    RIint32 sx0 = v.sx;

    RIint32 sy0 = v.sy;

    IntegerColor ic00;

    applyPatternRepeat(sx0, sy0, tilingMode);

    sx0 = gradientToFixedCoords(sx0, w);

    sy0 = gradientToFixedCoords(sy0, h);

    //sx0 = (RIint32)(((RIint64)w * sx0) >> (PixelPipe::GRADIENT_BITS - PixelPipe::SAMPLE_BITS));

    //sy0 = (RIint32)(((RIint64)h * sy0) >> (PixelPipe::GRADIENT_BITS - PixelPipe::SAMPLE_BITS));

    const void* ptr = u.patternPtr;

    const int stride = u.patternStride;

    const Color::Descriptor& desc = state.patternDesc;

    return intSampleImage(ptr, stride, w, h, desc, sx0, sy0, state.paintSampler, tilingMode, &fillColor);

}

RI_INLINE static bool formatPremultipliedAfterSampling(const Color::Descriptor& desc, PixelPipe::SamplerType samplerType, PixelPipe::ImageGradientType gradientType)

{

    // Sampled at pixel centers -> no processing of colors -> does not get premultiplied

    if (gradientType == PixelPipe::GRADIENT_TYPE_INTEGER)

        return desc.isPremultiplied();

    if (samplerType != PixelPipe::SAMPLER_TYPE_NEAREST)

        return true;

    return desc.isPremultiplied();

}

RI_INLINE static bool imagePremultipliedAfterSampling(const PixelPipe::SignatureState& state)

{

    RI_ASSERT(state.hasImage);

    return formatPremultipliedAfterSampling(state.imageDesc, state.imageSampler, state.imageGradientType);

}

RI_INLINE static bool gradientPremultipliedAfterSampling(const PixelPipe::SignatureState& state)

{

    if (state.paintSampler != PixelPipe::SAMPLER_TYPE_NEAREST)

        return true;

    return true;

    // Otherwise, the gradient value is a single sample, and should be in the destination

    // color-space:

    //return state.dstDesc.isPremultiplied();

}

RI_INLINE static bool patternPremultipliedAfterSampling(const PixelPipe::SignatureState& state)

{

    RI_ASSERT(state.paintType == VG_PAINT_TYPE_PATTERN);

    return formatPremultipliedAfterSampling(state.patternDesc, state.paintSampler, PixelPipe::GRADIENT_TYPE_FIXED);

}

/**

 * \brief   Returns true if generated paint will be in RGB, false if luminance.

 */