/* Copyright (c) 2009 The Khronos Group Inc.

 *

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

 */

#ifdef __cplusplus

extern "C"

{

#endif

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#include <math.h>

#include "owfobject.h"

#include "owfimage.h"

#include "owfutils.h"

#include "owfmemory.h"

#include "owfdebug.h"

#include "owfdisplaycontextgeneral.h"

#ifdef OWF_IMAGE_INTERNAL_PIXEL_IS_FLOAT

#define roundSubPixel(p) ((OWFuint32)((p) + 0.5f))

#else

#define roundSubPixel(p) (p)

#endif

/*----------------------------------------------------------------------------*/

OWF_API_CALL void

OWF_IMAGE_Ctor(void* self)

{

    self = self;

}

/*----------------------------------------------------------------------------*/

OWF_API_CALL void

OWF_IMAGE_Dtor(void* self)

{

    OWF_IMAGE* image;

    image = (OWF_IMAGE*)self;

    if (image && image->data)

    {

        if (!image->foreign)

        {

            OWF_Image_FreeData(0, &image->data);

        }

    }

    if (image)

    {

        memset(image, 0, sizeof(OWF_IMAGE));

    }

}

/*----------------------------------------------------------------------------*/

static OWFfloat

NonLinear(OWFfloat x)

{

    if (x <= 0.00304f)

    {

        return 12.92f * x;

    }

    return 1.0556f * pow(x, 1.f/2.4f) - 0.0556f;

}

/*----------------------------------------------------------------------------*/

static OWFfloat

Linear(OWFfloat x)

{

    if (x <= 0.03928)

    {

        return x / 12.92f;

    }

    return pow((x + 0.0556f) / 1.0556f, 2.4f);

}

/*----------------------------------------------------------------------------*/

OWF_API_CALL void

OWF_Image_NonLinearizeData(OWF_IMAGE* image)\

{

    OWFpixel*            ptr;

    OWFint               count;

    OWF_ASSERT(image != NULL && image->data != NULL);

    OWF_ASSERT(image->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

    if (!image->format.linear)

    {

        return;

    }

    ptr = (OWFpixel*) image->data;

    count = image->width * image->height;

    while (count > 0)

    {

        ptr->color.red   = (OWFsubpixel) NonLinear(ptr->color.red /

                               OWF_RED_MAX_VALUE) * OWF_RED_MAX_VALUE;

        ptr->color.green = (OWFsubpixel) NonLinear(ptr->color.green /

                               OWF_GREEN_MAX_VALUE) * OWF_GREEN_MAX_VALUE;

        ptr->color.blue  = (OWFsubpixel) NonLinear(ptr->color.blue /

                               OWF_BLUE_MAX_VALUE) * OWF_BLUE_MAX_VALUE;

        --count;

        ptr++;

    }

    image->format.linear = OWF_FALSE;

}

/*----------------------------------------------------------------------------*/

OWF_API_CALL void

OWF_Image_LinearizeData(OWF_IMAGE* image)

{

    OWFpixel*               ptr;

    OWFuint                 count;

    OWF_ASSERT(image != NULL && image->data != NULL);

    OWF_ASSERT(image->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

    if (image->format.linear)

    {

        return;

    }

    ptr = (OWFpixel*) image->data;

    count = image->width * image->height;

    while (count > 0)

    {

        ptr->color.red   = (OWFsubpixel) Linear(ptr->color.red /

                               OWF_RED_MAX_VALUE) * OWF_RED_MAX_VALUE;

        ptr->color.green = (OWFsubpixel) Linear(ptr->color.green /

                               OWF_GREEN_MAX_VALUE) * OWF_GREEN_MAX_VALUE;

        ptr->color.blue  = (OWFsubpixel) Linear(ptr->color.blue /

                               OWF_BLUE_MAX_VALUE) * OWF_BLUE_MAX_VALUE;

        --count;

        ptr += image->pixelSize;

    }

    image->format.linear = OWF_TRUE;

}

/*----------------------------------------------------------------------------*/

#define GAMMA(color, max, gamma) (max * pow(color/max, gamma))

OWF_API_CALL void

OWF_Image_Gamma(OWF_IMAGE* image, OWFfloat gamma)

{

    OWFpixel*            ptr;

    OWFint               count;

    OWF_ASSERT(image != NULL && image->data != NULL);

    OWF_ASSERT(image->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

    if (gamma == 1.0f)

    {

        return;

    }

    ptr = (OWFpixel*) image->data;

    count = image->width * image->height;

    while (count > 0)

    {

        ptr->color.red   =

            (OWFsubpixel) GAMMA(ptr->color.red, OWF_RED_MAX_VALUE, gamma);

        ptr->color.green =

            (OWFsubpixel) GAMMA(ptr->color.green, OWF_GREEN_MAX_VALUE, gamma);

        ptr->color.blue  =

            (OWFsubpixel) GAMMA(ptr->color.blue, OWF_BLUE_MAX_VALUE, gamma);

        --count;

        ptr++;

    }

}

/*----------------------------------------------------------------------------*/

OWF_API_CALL void

OWF_Image_EdgeReplication(OWF_IMAGE* image)

{

    OWFint          y;

    OWFint          copyStride;

    OWFuint8*       srcPtr      = NULL;

    OWFuint8*       dstPtr      = NULL;

    OWF_ASSERT(image);

    OWF_ASSERT(image->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

    OWF_ASSERT(image->width >= 3 && image->height >= 3);

    /* top side replication */

    srcPtr = (OWFuint8*) image->data;

    srcPtr += 1 * image->stride + 0 * image->pixelSize;

    dstPtr = (OWFuint8*) image->data;

    memcpy(dstPtr, srcPtr, copyStride);

    /* bottom side replication */

    srcPtr = (OWFuint8*) image->data;

    srcPtr += (image->height-2) * image->stride + 0 * image->pixelSize;        

    dstPtr = (OWFuint8*) image->data;

    dstPtr += (image->height-1) * image->stride + 0 * image->pixelSize;

    memcpy(dstPtr, srcPtr, copyStride);

    /* left side replication */

    for (y = 0; y < image->height; y++)

    {

        OWF_Image_SetPixel(image, 0, y, OWF_Image_GetPixelPtr(image, 1, y));

    }

    /* right side replication */

    for (y = 0; y < image->height; y++)

    {

        OWF_Image_SetPixel(image, image->width-1, y, OWF_Image_GetPixelPtr(image,

                                                              image->width-2,

                                                              y));

    }   

}

/*----------------------------------------------------------------------------*/

OWF_API_CALL OWFboolean

OWF_Image_SourceFormatConversion(OWF_IMAGE* dst, OWF_IMAGE* src)

{

    OWFint      countY, widthDiff, heightDiff;

    void*       srcLinePtr;

    OWFpixel*   dstLinePtr;

    OWFboolean  replicateEdges = OWF_FALSE;

    OWF_ASSERT(dst != 0 && dst->data != NULL);

    OWF_ASSERT(src != 0 && src->data != NULL);

    OWF_ASSERT(dst->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

    srcLinePtr = src->data;

    dstLinePtr = (OWFpixel*) dst->data;    

    /* dst image must either be the same size as the src image or 2 pixels 

       bigger (enough space to perform edge replication) */

    if (dst->width != src->width || dst->height != src->height)

    {

        widthDiff = dst->width - src->width;

        heightDiff = dst->height - src->height;

        if (widthDiff == 2 && heightDiff == 2)

        {

            replicateEdges = OWF_TRUE;   

            /* start of the destination buffer should have a 1 pixel offset */

            dstLinePtr = (OWFpixel*) dst->data + 1 * dst->width + 1;

        }

        else

        {

            return OWF_FALSE;

        }

    }

    if (dst->format.pixelFormat != OWF_IMAGE_ARGB_INTERNAL)

    {

        return OWF_FALSE;

    }

    for (countY = src->height; countY; countY--)

    {

        OWFint count = src->width;

        OWFpixel* dstPtr = dstLinePtr;

        switch (src->format.pixelFormat)

        {

            case OWF_IMAGE_ARGB8888:

            {

                OWFuint32* srcPtr = (OWFuint32*) srcLinePtr;

                while (count > 0)

                {

                    dstPtr->color.alpha = (OWFsubpixel)

                        OWF_ALPHA_MAX_VALUE * ((*srcPtr & ARGB8888_ALPHA_MASK) >> ARGB8888_ALPHA_SHIFT) / OWF_BYTE_MAX_VALUE;

                    dstPtr->color.red   = (OWFsubpixel)

                        OWF_RED_MAX_VALUE * ((*srcPtr & ARGB8888_RED_MASK) >> ARGB8888_RED_SHIFT) / OWF_BYTE_MAX_VALUE;

                    dstPtr->color.green = (OWFsubpixel)

                        OWF_GREEN_MAX_VALUE * ((*srcPtr & ARGB8888_GREEN_MASK)>> ARGB8888_GREEN_SHIFT) / OWF_BYTE_MAX_VALUE;

                    dstPtr->color.blue  = (OWFsubpixel)

                        OWF_BLUE_MAX_VALUE * ((*srcPtr & ARGB8888_BLUE_MASK) >> ARGB8888_BLUE_SHIFT) / OWF_BYTE_MAX_VALUE;

                    dstPtr ++;

                    srcPtr ++;

                    count--;

                }

#else

#endif

                break;

            }

            case OWF_IMAGE_XRGB8888:

            {

                OWFuint32* srcPtr = (OWFuint32*) srcLinePtr;

                while (count > 0)

                {

                    dstPtr->color.alpha = OWF_FULLY_OPAQUE;

                    dstPtr->color.red   = (OWFsubpixel)

                        OWF_RED_MAX_VALUE * ((*srcPtr & ARGB8888_RED_MASK) >> ARGB8888_RED_SHIFT) / OWF_BYTE_MAX_VALUE;

                    dstPtr->color.green = (OWFsubpixel)

                        OWF_GREEN_MAX_VALUE * ((*srcPtr & ARGB8888_GREEN_MASK) >> ARGB8888_GREEN_SHIFT) / OWF_BYTE_MAX_VALUE;

                    dstPtr->color.blue  = (OWFsubpixel)

                        OWF_BLUE_MAX_VALUE * ((*srcPtr & ARGB8888_BLUE_MASK) >> ARGB8888_BLUE_SHIFT) / OWF_BYTE_MAX_VALUE;

#else

                    *(OWFuint32*)dstPtr = *srcPtr | ARGB8888_ALPHA_MASK;

#endif

                    dstPtr ++;

                    srcPtr ++;

                    count--;

                }

                break;

            }

            case OWF_IMAGE_RGB565:

            {

                OWFfloat tmp;

                OWFuint16* srcPtr = (OWFuint16*) srcLinePtr;

                while (count > 0)

                {

                    /*

                     * Formula for converting channel value is:

                     * Each channel is multiplied by (2^d - 1)/(2^s -1)

                     * where d is dest channel bits and s is source channel bits.

                     */

                    dstPtr->color.alpha = (OWFsubpixel) OWF_FULLY_OPAQUE;

                    tmp = (OWFfloat)((*srcPtr & RGB565_RED_MASK) >> RGB565_RED_SHIFT);

                    dstPtr->color.red   = (OWFsubpixel)OWF_RED_MAX_VALUE * tmp / 31.0f + OWF_SOURCE_CONVERSION_ROUNDING_VALUE;

                    tmp = (OWFfloat)((*srcPtr & RGB565_GREEN_MASK) >> RGB565_GREEN_SHIFT);

                    dstPtr->color.green = (OWFsubpixel)OWF_GREEN_MAX_VALUE * tmp / 63.0f + OWF_SOURCE_CONVERSION_ROUNDING_VALUE;

                    tmp = (OWFfloat)(*srcPtr & RGB565_BLUE_MASK);

                    dstPtr->color.blue  = (OWFsubpixel)OWF_BLUE_MAX_VALUE * tmp / 31.0f + OWF_SOURCE_CONVERSION_ROUNDING_VALUE;

                    dstPtr ++;

                    srcPtr ++;

                    count--;

                }

                break;

            }

            case OWF_IMAGE_UYVY:

            {

                OWFuint8* srcPtr = (OWFuint8*) srcLinePtr;

                OWFint y,u,v,r,g,b,x;

                for (x = 0; x < count; x++)

                {

                    u = srcPtr[0] - 128;

                    v = srcPtr[2] - 128;

                    y = srcPtr[3] - 16;

                    r = ((298 * y + 409 * u) / 256);

                    g = ((298 * y - 100 * v - 208 * u) / 256);

                    b = ((298 * y + 516 * v) / 256);

                    CLIP(r);

                    CLIP(g);

                    CLIP(b);

                    dstPtr->color.alpha = 255;

                    dstPtr->color.red = r;

                    dstPtr->color.green = g;

                    dstPtr->color.blue = b;

                    dstPtr++;

                    y = srcPtr[1] - 16;

                    r = ((298 * y + 409 * u) / 256);

                    g = ((298 * y - 100 * v - 208 * u) / 256);

                    b = ((298 * y + 516 * v) / 256);

                    CLIP(r);

                    CLIP(g);

                    CLIP(b);

                    dstPtr->color.alpha = 255;

                    dstPtr->color.red = r;

                    dstPtr->color.green = g;

                    dstPtr->color.blue = b;

                    dstPtr++;                  

                    srcPtr += 4;                                      

                }

                break;

            }

            default:

            {

                return OWF_FALSE; /* source format not supported */

            }

        }

        dstLinePtr+=dst->width;

        srcLinePtr=(OWFuint8*)srcLinePtr+src->stride;

    }

    if (replicateEdges)

    {

        OWF_Image_EdgeReplication(dst);

    }

    return OWF_TRUE;

}

/*----------------------------------------------------------------------------*/

OWF_PUBLIC OWFint

OWF_Image_GetStride(OWFint width, const OWF_IMAGE_FORMAT* format, OWFint minimumStride)

{

    OWFint                  size;

    OWFint                  pixelSize;

    OWF_ASSERT(format);

    pixelSize = OWF_Image_GetFormatPixelSize(format->pixelFormat);

    if (pixelSize < 0)

    {

        /* negative pixelSize means that pixel size is a fraction

         * (1/-pixelSize) of a byte, e.g. -8 means pixel has size

         * of one bit. */

        size = (width + 1) / -pixelSize;

    }

    else

    {

        size = width * pixelSize;

    }

    if (size<minimumStride)

    {

        size=minimumStride;

    }

    if (format->rowPadding)

    {

        size += format->rowPadding - 1;

        size -= size % format->rowPadding;

    }

    return size;

}

/*----------------------------------------------------------------------------*/

OWF_API_CALL OWFboolean

OWF_Image_IsValidDestinationFormat(OWF_IMAGE_FORMAT* format)

{

    switch (format->pixelFormat)

    {

        case OWF_IMAGE_ARGB8888:

        {

            return OWF_TRUE;

        }

        case OWF_IMAGE_XRGB8888:

        {

            return OWF_TRUE;

        }

#ifdef SUPPORT_565_OUTPUT

        case OWF_IMAGE_RGB565:

        {

            return OWF_TRUE;

        }

#endif

        default:

        {

            return OWF_FALSE; /* destination format not supported */

        }

    }

}

/*----------------------------------------------------------------------------*/

OWF_API_CALL OWFboolean

OWF_Image_DestinationFormatConversion(OWF_IMAGE* dst, OWF_IMAGE* src)

{

    OWFint                  countY;

    OWFuint32*              dstPtr;

    OWFpixel*               srcPtr;

    OWFuint8*               destination;

    OWF_ASSERT(dst != 0 && dst->data != NULL);

    OWF_ASSERT(src != 0 && src->data != NULL);

    OWF_ASSERT(src->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

    if (src->format.pixelFormat != OWF_IMAGE_ARGB_INTERNAL)