/*******************************************************************************
 * 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 "imagebase.h"
#include "gfxlog.h"

namespace Java { namespace GFX {

ImageBase::ImageBase() : mAlpha(-1), mHasMask(false)
    {
    }

ImageBase::~ImageBase()
    {
    }

void ImageBase::doGetRgb(QImage& image, int* aRgbdata, int aOffset, int aScanlength, 
                         int aX, int aY, int aWidth, int aHeight)
    {
    GFX_LOG_FUNC_CALL();

    if(aX != 0 || aY != 0 || aWidth < image.width() || aHeight < image.height())
        {
        image = image.copy(aX, aY, aWidth, aHeight);
        if(image.isNull())
            {
            throw GfxException(EGfxErrorNoMemory, "copying from original image failed");
            }
        }

    // If image is not 32bpp we need to convert it
    if(image.format() != QImage::Format_RGB32 &&
       image.format() != QImage::Format_ARGB32)
        {
        image = image.convertToFormat(QImage::Format_ARGB32);
        if(image.isNull())
            {
            throw GfxException(EGfxErrorNoMemory, "format convertion to 32bpp failed");
            }
        }

    // Temporary storage for pixels
    QRgb* pixel = NULL;

    // dataArray index, start from offset
    int targetIndex = aOffset;
    // Iterate through lines
    for(int b = 0; b < aHeight; ++b)
        {
        // Obtain pointer to start of current line (y)
        const unsigned char* lineStart = image.scanLine(b);
        // Iterate through pixels on each line
        for (int a = 0; a < aWidth; ++a)
            {
            // Set the current pixel, relative to line start
            pixel = ((QRgb*)lineStart) + a;
            // Move target pointer to the next slot
            targetIndex = aOffset + a + (b * aScanlength);
            // Shift pixels to correct places, needed for 32-bit format
            // as the bits order in memory may vary between systems
            aRgbdata[targetIndex] =  ((qAlpha(*pixel) & 0xff) << 24) |
                                     ((qRed(*pixel)   & 0xff) << 16) |
                                     ((qGreen(*pixel) & 0xff) << 8 ) |
                                     ((qBlue(*pixel)  & 0xff));
            }
        }
    }

void ImageBase::doGetRgb(QImage& image, char* aRgbdata, char* aTransparencyMask,int aOffset, 
                         int aScanlength, int aX, int aY, int aWidth, int aHeight, int aFormat)
    {
    GFX_LOG_FUNC_CALL();

    if(aX != 0 || aY != 0 || aWidth < image.width() || aHeight < image.height())
        {
        image = image.copy(aX, aY, aWidth, aHeight);
        if(image.isNull())
            {
            throw GfxException(EGfxErrorNoMemory, "copying from original image failed");
            }
        }

    if(aScanlength < 0)
        {
         image = image.mirrored(false, true);
         if(image.isNull())
             {
             throw GfxException(EGfxErrorNoMemory, "Mirroring failed");
             }
        }

    // If image is not monochrome we need to convert it
    if(image.format() != QImage::Format_Mono)
    {
        image = image.convertToFormat(QImage::Format_Mono);
        if(image.isNull())
        {
            throw GfxException(EGfxErrorNoMemory, "Format conversion to 8bpp failed");
        }
    }

    // dataArray index, start from offset
    int targetIndex = aOffset;

    const unsigned char* imageStart = image.bits();
    QImage mask = image.alphaChannel();
    const unsigned char* maskStart = mask.bits();

    // Find the number of full bytes
    int fullBytes = aWidth/8;
    int bpl = image.bytesPerLine();

    if(bpl == fullBytes)
        {
        memcpy(aRgbdata+targetIndex, imageStart, bpl*aHeight);
        memcpy(aTransparencyMask+targetIndex, maskStart, bpl*aHeight);
        }
    else
        {
        memcpy(aRgbdata+targetIndex, imageStart, fullBytes*aHeight + aHeight);
        memcpy(aTransparencyMask+targetIndex, maskStart, fullBytes*aHeight + aHeight);
        }
    }

void ImageBase::doGetRgb(QImage& image, short* aRgbdata, int aOffset, int aScanlength, 
                         int aX, int aY, int aWidth, int aHeight, int aFormat)
    {
    GFX_LOG_FUNC_CALL();

    // Match format to QT
    int format;
    switch (aFormat) {
        case EFormatRGB555:
            format = QImage::Format_RGB555;
            break;
        case EFormatRGB16:
            format = QImage::Format_RGB16;
            break;
         case EFormatRGB444:
            format = QImage::Format_RGB444;
            break;
         case EFormatARGB4444Premultiplied:
            format = QImage::Format_ARGB4444_Premultiplied;
            break;
         default:
            format = QImage::Format_RGB16;
    }

    if(aX != 0 || aY != 0 || aWidth < image.width() || aHeight < image.height())
        {
        image = image.copy(aX, aY, aWidth, aHeight);
        if(image.isNull())
            {
            throw GfxException(EGfxErrorNoMemory, "copying from original image failed");
            }
        }

    // If image is not format we need, convert it
    if(image.format() != format)
        {
        image = image.convertToFormat((QImage::Format)format);
        if(image.isNull())
            {
            throw GfxException(EGfxErrorNoMemory, "format convertion to 16bpp failed");
            }
        }

    // Temporary storage for pixels
    short* pixel = NULL;
    // dataArray index, start from offset
    int targetIndex = aOffset;

    // Iterate through lines
    for(int b=0; b < aHeight; b++)
        {
        // Obtain pointer to start of current line (y)
        const unsigned char* lineStart = image.scanLine(b);
        // Iterate through pixels on each line
        for(int a=0; a < aWidth; a++)
            {
            // Set the current pixel, relative to line start
            pixel = ((short*)lineStart) + a;
            // Move target pointer to the next slot
            targetIndex = aOffset + a + (b * aScanlength);
            aRgbdata[targetIndex] =  *pixel;
            }
        }
    }

QTransform ImageBase::generateTransformMatrix(TTransform aTransform)
    {
    GFX_LOG_FUNC_CALL();

    // In case there's both mirror and rotate is requested, the angle of rotation
    // must be negative since when the transform is applied the z-axis is processed
    // before y-axis, while the spec mandates reverse order. So by having negative  
    // degrees for rotation along z-axis here, gives correct output.
    QTransform transform;
    switch(aTransform) 
        {
        case ETransNone:
            // No transform or mirror
            break;
        case ETransRot90:
            transform.rotate(90, Qt::ZAxis);
            break;
        case ETransRot180:
            transform.rotate(180, Qt::ZAxis);
            break;
        case ETransRot270:
            transform.rotate(270, Qt::ZAxis);
            break;
        case ETransMirror:
            transform.rotate(180,Qt::YAxis);
            break;
        case ETransMirrorRot90:
            transform.rotate(180, Qt::YAxis);
            transform.rotate(-90, Qt::ZAxis);
            break;
        case ETransMirrorRot180:
            transform.rotate(180, Qt::YAxis);
            transform.rotate(-180, Qt::ZAxis);
            break;
        case ETransMirrorRot270:
            transform.rotate(180, Qt::YAxis);
            transform.rotate(-270, Qt::ZAxis);
            break;
        default:
            Q_ASSERT_X(false, "Graphics", "Transform type not recognized");
        }
    return transform;
    }

int ImageBase::getAlpha() 
    {
    return mAlpha;
    }

bool ImageBase::hasMask()
    {
    return mHasMask;
    }

QImage ImageBase::imageDataToQImage(ImageDataWrapper* aData)
    {
    if(aData->getDepth() != 32)
        {
        // Java side always converts the ImageData to 32 bit before passing it
        // to native side, bail out if we get something else
        throw GfxException(EGfxErrorNoMemory, "Only 32 bit ImageData is supported in Image creation");
        }

    int bpp = 4; // bit depth = 32, 4 bytes per pixel
    int size = aData->getWidth()*aData->getHeight()*bpp;
    char* pixelData = aData->getData(ImageDataWrapper::EPixelData);

    for(int index = 0; index < size; index += bpp)
        {
        int pixel = *(reinterpret_cast<int*>(pixelData+index));

        pixelData[index]   = (uchar)(pixel >> 24) & 0xFF;
        pixelData[index+1] = (uchar)(pixel >> 16) & 0xFF;
        pixelData[index+2] = (uchar)(pixel >> 8) & 0xFF;
        pixelData[index+3] = 0xFF; // Set alpha to opaque here, alpha channel data will be handled later
        }

    QImage image(reinterpret_cast<uchar*>(aData->getData(ImageDataWrapper::EPixelData)),
                                              aData->getWidth(),
                                              aData->getHeight(),
                                              aData->getBytesPerLine(),
                                              QImage::Format_ARGB32);
    if(image.isNull())
        {
        throw GfxException(EGfxErrorNoMemory, "Image creation failed");
        }

    // Set indexed palette (if one is set)
    if(!aData->isDirect())
        {
        image.setColorTable(*aData->getPaletteData()->getIndexedPalette());
        }

    mHasMask = false;
    mAlpha = aData->getAlpha();

    if(aData->getData(ImageDataWrapper::EMaskData))
        {
        QImage mask(reinterpret_cast<uchar*>(aData->getData(ImageDataWrapper::EMaskData)),
                                             aData->getWidth(),
                                             aData->getHeight(),
                                             QImage::Format_Mono);
        if(mask.isNull())
            {
            throw GfxException(EGfxErrorNoMemory, "Image alpha channel creation failed");
            }
        image.setAlphaChannel(mask);
        mHasMask = true;
        }
    else if(mAlpha != -1)
        {
        // Global alpha is set, overrides alpha channel data
        QImage alpha(aData->getWidth(), aData->getHeight(), QImage::Format_Indexed8);
        if(alpha.isNull())
            {
            throw GfxException(EGfxErrorNoMemory, "Image alpha channel creation failed");
            }

        alpha.fill(aData->getAlpha());
        image.setAlphaChannel(alpha);
        }
    else if(aData->getData(ImageDataWrapper::EAlphaData))
        {
        // Alpha channel data is set
        const int w = aData->getWidth();
        QImage alpha(reinterpret_cast<uchar*>(aData->getData(ImageDataWrapper::EAlphaData)),
                                              w,
                                              aData->getHeight(),
                                              w,
                                              QImage::Format_Indexed8);
        QVector<QRgb> colors(255);
        for(int i=0; i<255; i++)
            {
            colors[i] = qRgb(i, i, i);
            }
        alpha.setColorTable(colors);
        colors.clear();

        if(alpha.isNull())
            {
            throw GfxException(EGfxErrorNoMemory, "Image alpha channel creation failed");
            }
        image.setAlphaChannel(alpha);
        }
    return image;
    }


QImage::Format ImageBase::mapInternalFormatToQt(TImageFormat internalImageFormat)
    {
    switch (internalImageFormat) 
        {
        case EFormatARGB32:
            return QImage::Format_ARGB32;
        case EFormatRGB32:
            return QImage::Format_RGB32;
        case EFormatARGB32Premultiplied:
            return QImage::Format_ARGB32_Premultiplied;
         case EFormatRGB16:
            return QImage::Format_RGB16;
         case EFormatRGB555:
            return QImage::Format_RGB555;
         case EFormatRGB444:
            return QImage::Format_RGB444;
         case EFormatARGB4444Premultiplied:
            return QImage::Format_ARGB4444_Premultiplied;
         case EFormatMONO:
            return QImage::Format_Mono;
         default:
            return QImage::Format_Invalid;
        }
    }

TImageFormat ImageBase::mapQtFormatToInternal(QImage::Format qtImageFormat)
    {
    switch (qtImageFormat) 
        {
        case QImage::Format_ARGB32:
            return EFormatARGB32;
        case QImage::Format_RGB32:
            return EFormatRGB32;
        case QImage::Format_ARGB32_Premultiplied:
            return EFormatARGB32Premultiplied;
         case QImage::Format_RGB16:
            return EFormatRGB16;
         case QImage::Format_RGB555:
            return EFormatRGB555;
         case QImage::Format_RGB444:
            return EFormatRGB444;
         case QImage::Format_ARGB4444_Premultiplied:
            return EFormatARGB4444Premultiplied;
         case QImage::Format_Mono:
            return EFormatMONO;
         default:
            return EFormatNone;
        }
    }

} // namespace GFX
} // namespace Java