/*******************************************************************************

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

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - initial API and implementation

 *******************************************************************************/

#include "gfxlog.h"

#include "imagedataimpl.h"

#include "palettedataimpl.h"

namespace Java { namespace GFX {

ImageDataWrapperImpl::ImageDataWrapperImpl()

: mAlpha(0),

  mBytesPerLine(0),

  mDelayTime(0),

  mDepth(0),

  mMaskPad(0),

  mScanlinePad(0),

  mTransparentPixel(0),

  mDisposalMethod(ImageDataWrapper::EDmUnspecified),

  mImageType(ImageDataWrapper::EUndefinedImage),

  mPaletteData(0)

{

    GFX_LOG_FUNC_CALL();

}

ImageDataWrapperImpl::~ImageDataWrapperImpl()

{

    GFX_LOG_FUNC_CALL();

    delete mPaletteData;

}

char* ImageDataWrapperImpl::getData(ImageDataWrapper::TDataType aType)

{

    GFX_LOG_FUNC_CALL();

    if (getDataSize(aType) == 0) return 0;

    switch(aType)

    {

        case EPixelData: return mPixelData.data();

        case EAlphaData: return mAlphaData.data();

        case EMaskData: return mMaskData.data();

        default: return NULL;

    }

}

int ImageDataWrapperImpl::getDataSize(ImageDataWrapper::TDataType aType)

{

    GFX_LOG_FUNC_CALL();

    switch(aType)

    {

        case EPixelData: return mPixelData.size();

        case EAlphaData: return mAlphaData.size();

        case EMaskData: return mMaskData.size();

        default: return 0;

    }

}

void ImageDataWrapperImpl::setData(Image* aSrc)

{

    GFX_LOG_FUNC_CALL();

    const QImage image = aSrc->toConstImage();

    fillData(&image, aSrc->getAlpha(), aSrc->hasMask());

}

void ImageDataWrapperImpl::setData(ImageDataWrapper::TDataType aType,

        const QByteArray& aData)

{

    GFX_LOG_FUNC_CALL();

    // QByteArray is implicitly shared, just assign

    switch(aType)

    {

        case EPixelData:

            mPixelData = aData;

            return;

        case EAlphaData:

            mAlphaData = aData;

            return;

        case EMaskData:

            mMaskData = aData;

            return;

        default: return;

    }

}

void ImageDataWrapperImpl::fillData(const QImage* aImage, int aAlpha, bool aMask)

{

    GFX_LOG_FUNC_CALL();

    int size = aImage->numBytes();

    // Cleanup old data

    mPixelData.clear();

    mAlphaData.clear();

    mMaskData.clear();

    delete mPaletteData;

    // Get image information

    mDepth = aImage->depth();

    mSize = QSize(aImage->width(), aImage->height());

    mScanlinePad = 4;

    mTransparentPixel = -1;

    mAlpha = aAlpha;

    mBytesPerLine = aImage->bytesPerLine();

    // Create pixel data

    mPixelData.fill(0, size);

    int bpp = mDepth / 8;

    const uchar* data = aImage->scanLine(0);

    char* pixelData = mPixelData.data();

    uchar* alphaData = 0;

    if (mDepth == 32 && !aMask && mAlpha == -1)

    {

        mAlphaData.fill(0xFF, aImage->width() * aImage->height());

        alphaData = (uchar*) mAlphaData.data();

    }

    int pixel = 0;

    int alpha = 0;

    bool alphaInUse = false;

    // Create

    for (int i = 0, j = 0; i < size; i += bpp, j++)

    {

        switch (mDepth)

        {

        case 32:

            alpha = data[i+3] & 0xFF;

            pixel = (data[i] & 0xFF) << 24 | (data[i+1] & 0xFF) << 16 | (data[i+2] & 0xFF) << 8 | alpha;

            if (!aMask && mAlpha == -1 && alpha != 0xFF)

            {

                *(uchar*)(alphaData + j) = alpha;

                if (!alphaInUse)

                {

                    alphaInUse = true;

                }

            }

            *(int*)(pixelData + i) = pixel;

            break;

        case 24:

            pixel = (data[i] & 0xFF) << 16 | (data[i+1] & 0xFF) << 8 | (data[i+2] & 0xFF);

            *(int*)(pixelData + i) = pixel;

            break;

        case 16:

            pixel = (data[i] & 0xFF) << 8 | (data[i+1] & 0xFF);

            *(int*)(pixelData + i) = pixel;

            break;

        case 8:

            *(pixelData + i) = (data[i] & 0xFF);

            break;

        default:

            throw GfxException(EGfxErrorIllegalArgument, "Unsupported bit depth");

        }

    }

    // According to eSWT's API, an alpha data should be present

    // only when there are actual semi or fully transparent pixels.

    if (!alphaInUse)

    {

        mAlphaData.clear();

    }

    if (aMask)

    {

        // Mask data is 1 bit/pixel

        int maskSize = aImage->width() * aImage->height() / 8;

        mAlphaData.fill(0xFF, maskSize);

        mMaskPad = 8;

        if (aImage->hasAlphaChannel())

        {

            QImage alpha = aImage->alphaChannel();

            alpha.convertToFormat(QImage::Format_Mono);

            mAlphaData = QByteArray::fromRawData(reinterpret_cast<const char*>(alpha.scanLine(0)), maskSize);

        }

    }

    else if (mAlpha != -1)

    {

        mAlphaData.fill(mAlpha, aImage->width()*aImage->height());

    }

    // Create palette

    if (aImage->numColors() > 0)

    {

        // If image has color table set, create indexed palette

        QVector<QRgb> colorTable = aImage->colorTable();

        mPaletteData = new IndexedPaletteDataWrapper(colorTable);

    }

    else

    {

        // Direct palette in use

        PaletteDataWrapper::TDirectData data(0x00FF0000, 0x0000FF00, 0x000000FF);

        mPaletteData = new DirectPaletteDataWrapper(data);

    }

}

void ImageDataWrapperImpl::setPaletteData(PaletteDataWrapper* aPaletteData)

{

    GFX_LOG_FUNC_CALL();

    delete mPaletteData;

    mPaletteData = aPaletteData;

}

bool ImageDataWrapperImpl::isDirect()

{

    GFX_LOG_FUNC_CALL();

    return mPaletteData->isDirect();

}

} // namespace GFX

} // namespace Java