/* Copyright 2006, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License"); 
** you may not use this file except in compliance with the License. 
** You may obtain a copy of the License at 
**
**     http://www.apache.org/licenses/LICENSE-2.0 
**
** Unless required by applicable law or agreed to in writing, software 
** distributed under the License is distributed on an "AS IS" BASIS, 
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
** See the License for the specific language governing permissions and 
** limitations under the License.
*/

#if 0

#include "SkBitmapShader.h"
#include "SkBitmapSampler.h"

#ifdef SK_SUPPORT_MIPMAP
static SkFixed find_mip_level(SkFixed dx, SkFixed dy)
{
    dx = SkAbs32(dx);
    dy = SkAbs32(dy);
    if (dx < dy)
        dx = dy;
    
    if (dx < SK_Fixed1)
        return 0;
    
    int clz = SkCLZ(dx);
    SkASSERT(clz >= 1 && clz <= 15);
    return SkIntToFixed(15 - clz) + ((unsigned)(dx << (clz + 1)) >> 16);
}
#endif

SkBitmapShader::SkBitmapShader(const SkBitmap& src, bool doFilter,
                               TileMode tmx, TileMode tmy)
    :
#ifdef SK_SUPPORT_MIPMAP
    fMipLevel(0), fMipSrcBitmap(src),
#endif
    fOrigSrcBitmap(src)
    
{
    fFilterBitmap = doFilter;
    fTileModeX = SkToU8(tmx);
    fTileModeY = SkToU8(tmy);
}

SkBitmapShader::SkBitmapShader(SkFlattenableReadBuffer& buffer) :
    INHERITED(buffer)
{
    Bitmap src;
    buffer.readBitmap(&src); 
#ifdef SK_SUPPORT_MIPMAP
    fMipLevel = 0;
    fMipSrcBitmap = src;
#endif
    fOrigSrcBitmap = src;
    fFilterBitmap = buffer.readU8();
    fTileModeX = buffer.readU8();
    fTileModeY = buffer.readU8();
}

void SkBitmapShader::flatten(SkFlattenableWriteBuffer& buffer)
{
    this->INHERITED::flatten(buffer);
    buffer.writeBitmap(&fOrigSrcBitmap);
    buffer.write8(fFilterBitmap);
    buffer.write8(fTileModeX);
    buffer.write8(fTileModeY);
}

bool SkBitmapShader::setContext(const SkBitmap& device, const SkPaint& paint, const SkMatrix& matrix)
{
    // do this first, so we have a correct inverse matrix
    if (!this->INHERITED::setContext(device, paint, matrix))
        return false;

    if (fOrigSrcBitmap.getConfig() == SkBitmap::kNo_Config ||
        fOrigSrcBitmap.width() == 0 ||
        fOrigSrcBitmap.height() == 0)
        return false;

    SkBitmap& bm = fOrigSrcBitmap;

#ifdef SK_SUPPORT_MIPMAP
    if (fOrigSrcBitmap.countMipLevels())
    {
        const SkMatrix& inv = this->getTotalInverse();

        fMipLevel = SkMin32(find_mip_level( SkScalarToFixed(inv.getScaleX()),
                                            SkScalarToFixed(inv.getSkewY())),
                            SkIntToFixed(fOrigSrcBitmap.countMipLevels() - 1));

//        SkDEBUGF(("BitmapShader miplevel=%x\n", fMipLevel));

        const SkBitmap::MipLevel* mm = fOrigSrcBitmap.getMipLevel(fMipLevel >> 16);
        
        fMipSrcBitmap.setConfig(fOrigSrcBitmap.getConfig(),
                                mm->fWidth,
                                mm->fHeight,
                                mm->fRowBytes);
        fMipSrcBitmap.setPixels(mm->fPixels);
        bm = fMipSrcBitmap;
    }
    else
    {
        fMipLevel = 0;
        fMipSrcBitmap = fOrigSrcBitmap;
    }
#endif

    fFlags = 0;
    if (paint.getAlpha() == 255 && bm.isOpaque())
        fFlags |= kOpaqueAlpha_Flag;

    return true;
}

///////////////////////////////////////////////////////////////////////////

#include "SkColorPriv.h"
#include "SkBitmapSampler.h"
#include "SkPerspIter.h"

class Sampler_BitmapShader : public SkBitmapShader {
public:
    Sampler_BitmapShader(const SkBitmap& src, bool doFilter,
                         TileMode tmx, TileMode tmy)
        : SkBitmapShader(src, doFilter, tmx, tmy)
    {
        // make sure to pass our copy of the src bitmap to the sampler, and not the
        // original parameter (which might go away).
        fSampler = NULL;
    }

    virtual ~Sampler_BitmapShader()
    {
        SkDELETE(fSampler);
    }
    
    virtual bool setContext(const SkBitmap& device, const SkPaint& paint, const SkMatrix& matrix)
    {
        if (this->INHERITED::setContext(device, paint, matrix))
        {
            SkDELETE(fSampler);
            fSampler = SkBitmapSampler::Create(this->getSrcBitmap(), this->getFilterBitmap(),
                                               this->getTileModeX(), this->getTileModeY());
            fSampler->setPaint(paint);
            return true;
        }
        return false;
    }
    
    enum {
        kMaxPointStorageCount = 32
    };

    virtual void shadeSpan(int x, int y, SkPMColor dstC[], int count)
    {
        unsigned            scale = SkAlpha255To256(this->getPaintAlpha());
        const SkMatrix&     inv = this->getTotalInverse();
        SkMatrix::MapPtProc proc = this->getInverseMapPtProc();
        SkBitmapSampler*     sampler = fSampler;
        MatrixClass         mc = this->getInverseClass();

        SkPoint srcPt;

        if (mc != kPerspective_MatrixClass)
        {
            proc(inv, SkIntToScalar(x) + SK_ScalarHalf,
                      SkIntToScalar(y) + SK_ScalarHalf, &srcPt);

            SkFixed fx = SkScalarToFixed(srcPt.fX);
            SkFixed fy = SkScalarToFixed(srcPt.fY);
            SkFixed dx, dy;

            if (mc == kLinear_MatrixClass)
            {
                dx = SkScalarToFixed(inv.getScaleX());
                dy = SkScalarToFixed(inv.getSkewY());
            }
            else
                (void)inv.fixedStepInX(SkIntToScalar(y), &dx, &dy);

#if defined(SK_SUPPORT_MIPMAP)
            {   int level = this->getMipLevel() >> 16;
                fx >>= level;
                fy >>= level;
                dx >>= level;
                dy >>= level;
            }
#endif
            if (scale == 256)
            {
                for (int i = 0; i < count; i++)
                {
                    dstC[i] = sampler->sample(fx, fy);
                    fx += dx;
                    fy += dy;
                }
            }
            else
            {
                for (int i = 0; i < count; i++)
                {
                    uint32_t    c = sampler->sample(fx, fy);
                    dstC[i] = SkAlphaMulQ(c, scale);
                    fx += dx;
                    fy += dy;
                }
            }
        }
        else
        {
            SkPerspIter   iter(inv, SkIntToScalar(x) + SK_ScalarHalf,
                                    SkIntToScalar(y) + SK_ScalarHalf, count);
            if (scale == 256)
            {
                while ((count = iter.next()) != 0)
                {
                    const SkFixed* src = iter.getXY();
                    for (int i = 0; i < count; i++)
                    {
                        *dstC++ = sampler->sample(src[0], src[1]);
                        src += 2;
                    }
                }
            }
            else
            {
                while ((count = iter.next()) != 0)
                {
                    const SkFixed* src = iter.getXY();
                    for (int i = 0; i < count; i++)
                    {
                        uint32_t c = sampler->sample(src[0] - SK_FixedHalf, src[1] - SK_FixedHalf);
                        *dstC++ = SkAlphaMulQ(c, scale);
                        src += 2;
                    }
                }
            }
        }
    }

protected:

    const SkMatrix& getUnitInverse() const { return fUnitInverse; }
    SkMatrix::MapPtProc getUnitInverseProc() const { return fUnitInverseProc; }

    /* takes computed inverse (from setContext) and computes fUnitInverse,
        taking srcBitmap width/height into account, so that fUnitInverse
        walks 0...1, allowing the tile modes to all operate in a fast 16bit
        space (no need for mod). The resulting coords need to be scaled by
        width/height to get back into src space (coord * width >> 16).
    */
    void computeUnitInverse()
    {
        const SkBitmap& src = getSrcBitmap();
        fUnitInverse = this->getTotalInverse();
        fUnitInverse.postIDiv(src.width(), src.height());
        fUnitInverseProc = fUnitInverse.getMapPtProc();
    }

private:
    SkBitmapSampler*    fSampler;
    SkMatrix            fUnitInverse;
    SkMatrix::MapPtProc fUnitInverseProc;
    
    typedef SkBitmapShader INHERITED;
};

///////////////////////////////////////////////////////////////////////////

class HasSpan16_Sampler_BitmapShader : public Sampler_BitmapShader {
public:
    HasSpan16_Sampler_BitmapShader(const SkBitmap& src, bool doFilter,
                                   TileMode tmx, TileMode tmy)
        : Sampler_BitmapShader(src, doFilter, tmx, tmy)
    {
    }

    virtual uint32_t getFlags()
    {
        uint32_t flags = this->INHERITED::getFlags();
        
        switch (this->getSrcBitmap().getConfig()) {
        case SkBitmap::kRGB_565_Config:
            flags |= kHasSpan16_Flag;
            break;
        case SkBitmap::kIndex8_Config:
        case SkBitmap::kARGB_8888_Config:
            if (this->getSrcBitmap().isOpaque())
                flags |= kHasSpan16_Flag;
            break;
        default:
            break;
        }
        return flags;
    }
    
    const SkBitmap& revealSrcBitmap() const { return this->getSrcBitmap(); }
    uint8_t         revealPaintAlpha() const { return this->getPaintAlpha(); }
    const SkMatrix& revealTotalInverse() const { return this->getTotalInverse(); }

private:
    typedef Sampler_BitmapShader INHERITED;
};

///////////////////////////////////////////////////////////////////////////

static void Index8_RepeatTile_Sprite16(HasSpan16_Sampler_BitmapShader* shader,
                                       int x, int y, uint16_t dstC[], int count)
{
    const SkMatrix& inv = shader->revealTotalInverse();
    const SkBitmap& srcBitmap = shader->revealSrcBitmap();
    int             width = srcBitmap.width();
    int             height = srcBitmap.height();

    SkColorTable* ctable = srcBitmap.getColorTable();
    const uint16_t* colors = ctable->lock16BitCache();

    x += SkScalarRound(inv[SkMatrix::kMTransX]);
    y += SkScalarRound(inv[SkMatrix::kMTransY]);
    
    x = do_repeat_mod(x, width - 1);
    y = do_repeat_mod(y, height - 1);
    const uint8_t* row = srcBitmap.getAddr8(0, y);
    const uint8_t* src = row + x;

    // do the first partial run
    int n = width - x;
    if (n > count) n = count;
    count -= n;
    SkASSERT(n > 0);
    do {
        *dstC++ = colors[*src++];
    } while (--n > 0);

    // do 1 complete run
    if (count >= width)
    {
        uint16_t* baseDstC = dstC;  // remember the first complete run start
        n = width;
        count -= width;
        src = row;
        do {
            *dstC++ = colors[*src++];
        } while (--n > 0);

        // do the rest of the complete runs
        while (count >= width)
        {
            count -= width;
            memcpy(dstC, baseDstC, width << 1);
            dstC += width;
        }
        // do final partial run
        if (count > 0)
            memcpy(dstC, baseDstC, count << 1);
    }
    else // do final partial
    {
        if (count > 0)
        {
            src = row;
            do {
                *dstC++ = colors[*src++];
            } while (--count > 0);
        }
    }
    
    ctable->unlock16BitCache();
}

static void Index8_RepeatTile_Sprite32(HasSpan16_Sampler_BitmapShader* shader,
                                       int x, int y, SkPMColor dstC[], int count)
{
    const SkMatrix& inv = shader->revealTotalInverse();
    const SkBitmap& srcBitmap = shader->revealSrcBitmap();
    int             width = srcBitmap.width();
    int             height = srcBitmap.height();

    SkColorTable* ctable = srcBitmap.getColorTable();
    const SkPMColor* colors = ctable->lockColors();

    x += SkScalarRound(inv[SkMatrix::kMTransX]);
    y += SkScalarRound(inv[SkMatrix::kMTransY]);
    
    x = do_repeat_mod(x, width - 1);
    y = do_repeat_mod(y, height - 1);

    const uint8_t* row = srcBitmap.getAddr8(0, y);
    const uint8_t* src = row + x;

    // do the first partial run
    int n = width - x;
    if (n > count) n = count;
    count -= n;
    SkASSERT(n > 0);
    do {
        *dstC++ = colors[*src++];
    } while (--n > 0);

    // do 1 complete run
    if (count >= width)
    {
        SkPMColor* baseDstC = dstC;  // remember the first complete run start
        n = width;
        count -= width;
        src = row;
        do {
            *dstC++ = colors[*src++];
        } while (--n > 0);

        // do the rest of the complete runs
        while (count >= width)
        {
            count -= width;
            memcpy(dstC, baseDstC, width << 2);
            dstC += width;
        }
        // do final partial run
        if (count > 0)
            memcpy(dstC, baseDstC, count << 2);
    }
    else // do final partial
    {
        if (count > 0)
        {
            src = row;
            do {
                *dstC++ = colors[*src++];
            } while (--count > 0);
        }
    }
    
    ctable->unlockColors(false);
}

static void RGB16_RepeatTile_Sprite16(HasSpan16_Sampler_BitmapShader* shader,
                                       int x, int y, uint16_t dstC[], int count)
{
    SkASSERT(count > 0);

    const SkMatrix& inv = shader->revealTotalInverse();
    const SkBitmap& srcBitmap = shader->revealSrcBitmap();
    int             width = srcBitmap.width();
    int             height = srcBitmap.height();
    
    SkASSERT(width > 0 && height > 0);

    x += SkScalarRound(inv[SkMatrix::kMTransX]);
    y += SkScalarRound(inv[SkMatrix::kMTransY]);
    
    x = do_repeat_mod(x, width - 1);
    y = do_repeat_mod(y, height - 1);

    const uint16_t* row = srcBitmap.getAddr16(0, y);
    const uint16_t* src = row + x;

    int n = SkMin32(width - x, count);

    for (;;)
    {
        SkASSERT(n > 0 && count >= n);
        memcpy(dstC, src, n << 1);
        count -= n;
        if (count == 0)
            break;
        dstC += n;
        src = row;
        n = SkMin32(width, count);
    }
}

static void RGB16_RepeatTile_Sprite32(HasSpan16_Sampler_BitmapShader* shader,
                                       int x, int y, SkPMColor dstC[], int count)
{
    SkASSERT(count > 0);

    const SkMatrix& inv = shader->revealTotalInverse();
    const SkBitmap& srcBitmap = shader->revealSrcBitmap();
    int             width = srcBitmap.width();
    int             height = srcBitmap.height();
    
    SkASSERT(width > 0 && height > 0);

    x += SkScalarRound(inv[SkMatrix::kMTransX]);
    y += SkScalarRound(inv[SkMatrix::kMTransY]);
    
    x = do_repeat_mod(x, width - 1);
    y = do_repeat_mod(y, height - 1);

    const uint16_t* row = srcBitmap.getAddr16(0, y);
    const uint16_t* src = row + x;

    int n = SkMin32(width - x, count);

    // do the first partial run
    count -= n;
    SkASSERT(n > 0);
    do {
        *dstC++ = SkPixel16ToPixel32(*src++);
    } while (--n > 0);

    // do 1 complete run
    if (count >= width)
    {
        SkPMColor* baseDstC = dstC;  // remember the first complete run start
        n = width;
        count -= width;
        src = row;
        do {
            *dstC++ = SkPixel16ToPixel32(*src++);
        } while (--n > 0);

        // do the rest of the complete runs
        while (count >= width)
        {
            count -= width;
            memcpy(dstC, baseDstC, width << 2);
            dstC += width;
        }
        // do final partial run
        if (count > 0)
            memcpy(dstC, baseDstC, count << 2);
    }
    else // do final partial
    {
        if (count > 0)
        {
            src = row;
            do {
                *dstC++ = SkPixel16ToPixel32(*src++);;
            } while (--count > 0);
        }
    }
}

static void ARGB32_RepeatTile_Sprite16(HasSpan16_Sampler_BitmapShader* shader,
                                       int x, int y, uint16_t dstC[], int count)
{
    SkASSERT(count > 0);

    const SkMatrix& inv = shader->revealTotalInverse();
    const SkBitmap& srcBitmap = shader->revealSrcBitmap();
    int             width = srcBitmap.width();
    int             height = srcBitmap.height();
    
    SkASSERT(width > 0 && height > 0);

    x += SkScalarRound(inv[SkMatrix::kMTransX]);
    y += SkScalarRound(inv[SkMatrix::kMTransY]);
    
    x = do_repeat_mod(x, width - 1);
    y = do_repeat_mod(y, height - 1);

    const SkPMColor* row = srcBitmap.getAddr32(0, y);
    const SkPMColor* src = row + x;

    int n = SkMin32(width - x, count);

    // do the first partial run
    count -= n;
    SkASSERT(n > 0);
    do {
        *dstC++ = SkPixel32ToPixel16(*src++);
    } while (--n > 0);

    // do 1 complete run
    if (count >= width)
    {
        uint16_t* baseDstC = dstC;  // remember the first complete run start
        n = width;
        count -= width;
        src = row;
        do {
            *dstC++ = SkPixel32ToPixel16(*src++);
        } while (--n > 0);

        // do the rest of the complete runs
        while (count >= width)
        {
            count -= width;
            memcpy(dstC, baseDstC, width << 1);
            dstC += width;
        }
        // do final partial run
        if (count > 0)
            memcpy(dstC, baseDstC, count << 1);
    }
    else // do final partial
    {
        if (count > 0)
        {
            src = row;
            do {
                *dstC++ = SkPixel32ToPixel16(*src++);;
            } while (--count > 0);
        }
    }
}

static void ARGB32_RepeatTile_Sprite32(HasSpan16_Sampler_BitmapShader* shader,
                                       int x, int y, SkPMColor dstC[], int count)
{
    SkASSERT(count > 0);

    const SkMatrix& inv = shader->revealTotalInverse();
    const SkBitmap& srcBitmap = shader->revealSrcBitmap();
    int             width = srcBitmap.width();
    int             height = srcBitmap.height();
    
    SkASSERT(width > 0 && height > 0);

    x += SkScalarRound(inv[SkMatrix::kMTransX]);
    y += SkScalarRound(inv[SkMatrix::kMTransY]);
    
    x = do_repeat_mod(x, width - 1);
    y = do_repeat_mod(y, height - 1);

    const SkPMColor* row = srcBitmap.getAddr32(0, y);
    const SkPMColor* src = row + x;

    int n = SkMin32(width - x, count);

    for (;;)
    {
        SkASSERT(n > 0 && count >= n);
        memcpy(dstC, src, n << 2);
        count -= n;
        if (count == 0)
            break;
        dstC += n;
        src = row;
        n = SkMin32(width, count);
    }
}

///////////////////////////////////////////////////////////////////////////

#define NOFILTER_BITMAP_SHADER_CLASS                    Index8_NoFilter_RepeatTile_BitmapShader
#define NOFILTER_BITMAP_SHADER_TILEMODE                 SkShader::kRepeat_TileMode
#define NOFILTER_BITMAP_SHADER_TILEPROC(x, max)         (fixed_repeat(x) * (max + 1) >> 16)
#define NOFILTER_BITMAP_SHADER_TYPE                     uint8_t
#define NOFILTER_BITMAP_SHADER_SAMPLE_X(p, x)           colors32[p[x]]
#define NOFILTER_BITMAP_SHADER_SAMPLE_XY(p, x, y, rb)   colors32[p[x + y * rb]]
#define NOFILTER_BITMAP_SHADER_PREAMBLE(bitmap, rb)     const SkPMColor* colors32 = bitmap.getColorTable()->lockColors()
#define NOFILTER_BITMAP_SHADER_POSTAMBLE(bitmap)        bitmap.getColorTable()->unlockColors(false)
#define NOFILTER_BITMAP_SHADER_SAMPLE_X16(p, x)         colors16[p[x]]
#define NOFILTER_BITMAP_SHADER_SAMPLE_XY16(p, x, y, rb) colors16[p[x + y * rb]]
#define NOFILTER_BITMAP_SHADER_PREAMBLE16(bitmap, rb)   const uint16_t* colors16 = bitmap.getColorTable()->lock16BitCache()
#define NOFILTER_BITMAP_SHADER_POSTAMBLE16(bitmap)      bitmap.getColorTable()->unlock16BitCache()
#define NOFILTER_BITMAP_SHADER_USE_UNITINVERSE
#define NOFILTER_BITMAP_SHADER_SPRITEPROC16             Index8_RepeatTile_Sprite16
#define NOFILTER_BITMAP_SHADER_SPRITEPROC32             Index8_RepeatTile_Sprite32
#include "SkBitmapShaderTemplate.h"

#define NOFILTER_BITMAP_SHADER_CLASS                    U16_NoFilter_RepeatTile_BitmapShader
#define NOFILTER_BITMAP_SHADER_TILEMODE                 SkShader::kRepeat_TileMode
#define NOFILTER_BITMAP_SHADER_TILEPROC(x, max)         (fixed_repeat(x) * (max + 1) >> 16)
#define NOFILTER_BITMAP_SHADER_TYPE                     uint16_t
#define NOFILTER_BITMAP_SHADER_SAMPLE_X(p, x)           SkPixel16ToPixel32(p[x])
#define NOFILTER_BITMAP_SHADER_SAMPLE_XY(p, x, y, rb)   SkPixel16ToPixel32(*(const uint16_t*)((const char*)p + y * rb + (x << 1)))
#define NOFILTER_BITMAP_SHADER_SAMPLE_X16(p, x)         p[x]
#define NOFILTER_BITMAP_SHADER_SAMPLE_XY16(p, x, y, rb) *(const uint16_t*)((const char*)p + y * rb + (x << 1))
#define NOFILTER_BITMAP_SHADER_USE_UNITINVERSE
#define NOFILTER_BITMAP_SHADER_SPRITEPROC16             RGB16_RepeatTile_Sprite16
#define NOFILTER_BITMAP_SHADER_SPRITEPROC32             RGB16_RepeatTile_Sprite32
#include "SkBitmapShaderTemplate.h"

#define NOFILTER_BITMAP_SHADER_CLASS                    U32_NoFilter_RepeatTile_BitmapShader
#define NOFILTER_BITMAP_SHADER_TILEMODE                 SkShader::kRepeat_TileMode
#define NOFILTER_BITMAP_SHADER_TILEPROC(x, max)         (fixed_repeat(x) * (max + 1) >> 16)
#define NOFILTER_BITMAP_SHADER_TYPE                     uint32_t
#define NOFILTER_BITMAP_SHADER_SAMPLE_X(p, x)           p[x]
#define NOFILTER_BITMAP_SHADER_SAMPLE_XY(p, x, y, rb)   *(const uint32_t*)((const char*)p + y * rb + (x << 2))
#define NOFILTER_BITMAP_SHADER_SAMPLE_X16(p, x)         SkPixel32ToPixel16_ToU16(p[x])
#define NOFILTER_BITMAP_SHADER_SAMPLE_XY16(p, x, y, rb) SkPixel32ToPixel16_ToU16(*(const uint32_t*)((const char*)p + y * rb + (x << 2)))
#define NOFILTER_BITMAP_SHADER_USE_UNITINVERSE
#define NOFILTER_BITMAP_SHADER_SPRITEPROC16             ARGB32_RepeatTile_Sprite16
#define NOFILTER_BITMAP_SHADER_SPRITEPROC32             ARGB32_RepeatTile_Sprite32
#include "SkBitmapShaderTemplate.h"

///////////////////////////////////////////////////////////////////////////////////////////////////////

static inline SkPMColor expanded_rgb16_to_8888(uint32_t c, U8CPU alpha)
{
//    GGGG Gggg gggR RRRR rrrr r|BB BBBb bbbb
    SkASSERT(alpha <= 255);

#if 1
    int scale = SkAlpha255To256(alpha);
    int r = (c & 0xF800) * scale >> 16;
    int g = ((c >> 21) & 0x3F) * scale >> 6;
    int b = (c & 0x1F) * scale >> 5;
    return SkPackARGB32(alpha, r, g, b);
#else
    int scale = SkAlpha255To256(alpha) >> 3;
    c &= 0x07E0F81F;
    c = c * scale;
    int r = (c >> 13) & 0xFF;
    int g = (c >> 24) & 0xFF;
    int b = (c >> 2) & 0xFF;
    return SkPackARGB32(alpha, r, g, b);
#endif
}

#define BILERP_BITMAP16_SHADER_CLASS            U16_Bilerp_BitmapShader
#define BILERP_BITMAP16_SHADER_TYPE             uint16_t
#define BILERP_BITMAP16_SHADER_PREAMBLE(bm)
#define BILERP_BITMAP16_SHADER_PIXEL(c)         (c)
#define BILERP_BITMAP16_SHADER_POSTAMBLE(bm)
#include "SkBitmapShader16BilerpTemplate.h"

#define BILERP_BITMAP16_SHADER_CLASS            Index8_Bilerp_BitmapShader
#define BILERP_BITMAP16_SHADER_TYPE             uint8_t
#define BILERP_BITMAP16_SHADER_PREAMBLE(bm)     SkColorTable* ctable = (bm).getColorTable(); const uint16_t* colors16 = ctable->lock16BitCache()
#define BILERP_BITMAP16_SHADER_PIXEL(c)         colors16[c]
#define BILERP_BITMAP16_SHADER_POSTAMBLE(bm)    ctable->unlock16BitCache()
#include "SkBitmapShader16BilerpTemplate.h"

#include "ARGB32_Clamp_Bilinear_BitmapShader.h"

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

#include "SkBitmapProcShader.h"

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

#include "SkTemplatesPriv.h"

SkShader* SkShader::CreateBitmapShader(const SkBitmap& src,
                                       bool doFilter,
                                       TileMode tmx, TileMode tmy,
                                       void* storage, size_t storageSize)
{
#if 1
    
    SkShader* shader;
    SK_PLACEMENT_NEW_ARGS(shader, SkBitmapProcShader, storage,
                          storageSize, (src, doFilter, tmx, tmy));
    return shader;
#else

    if (!doFilter)
    {
        if (kClamp_TileMode == tmx && kClamp_TileMode == tmy)
        {
            SK_PLACEMENT_NEW_ARGS(shader, SkBitmapProcShader, storage,
                                  storageSize, (src, doFilter, tmx, tmy));
        }
        else if (kRepeat_TileMode == tmx && kRepeat_TileMode == tmy)
        {
    #if 1
            SK_PLACEMENT_NEW_ARGS(shader, SkBitmapProcShader, storage,
                                  storageSize, (src, doFilter, tmx, tmy));
    #else
            switch (src.getConfig()) {
            case SkBitmap::kIndex8_Config:
                SK_PLACEMENT_NEW_ARGS(shader, Index8_NoFilter_RepeatTile_BitmapShader, storage, storageSize, (src));
                break;
            case SkBitmap::kRGB_565_Config:
                SK_PLACEMENT_NEW_ARGS(shader, U16_NoFilter_RepeatTile_BitmapShader, storage, storageSize, (src));
                break;
            case SkBitmap::kARGB_8888_Config:
                SK_PLACEMENT_NEW_ARGS(shader, U32_NoFilter_RepeatTile_BitmapShader, storage, storageSize, (src));
                break;
            default:
                break;
            }
    #endif
        }
    }
    else if (kClamp_TileMode == tmx && kClamp_TileMode == tmy)
    {
#if 1
        if (SkBitmapProcShader::CanDo(src, tmx, tmy))
        {
            SK_PLACEMENT_NEW_ARGS(shader, SkBitmapProcShader, storage,
                                  storageSize, (src, doFilter, tmx, tmy));
        }
#else
        switch (src.getConfig()) {
        case SkBitmap::kIndex8_Config:
            if (src.isOpaque())
                SK_PLACEMENT_NEW_ARGS(shader, Index8_Bilerp_BitmapShader, storage, storageSize, (src));
            break;
        case SkBitmap::kRGB_565_Config:
            SK_PLACEMENT_NEW_ARGS(shader, U16_Bilerp_BitmapShader, storage, storageSize, (src));
            break;
        case SkBitmap::kARGB_8888_Config:
            SK_PLACEMENT_NEW_ARGS(shader, ARGB32_Clamp_Bilinear_BitmapShader, storage, storageSize, (src));
            break;
        default:
            break;
        }
#endif
    }
    
    // if shader is null, then none of the special cases could handle the request
    // so fall through to our slow-general case
    if (shader == NULL)
        SK_PLACEMENT_NEW_ARGS(shader, Sampler_BitmapShader, storage, storageSize,
                              (src, doFilter, tmx, tmy));
    return shader;
#endif
}

SkShader* SkShader::CreateBitmapShader(const SkBitmap& src, bool doFilter,
                                       TileMode tmx, TileMode tmy)
{
    return SkShader::CreateBitmapShader(src, doFilter, tmx, tmy, NULL, 0);
}

#endif