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

 */

/*! \ingroup wfc

 *  \file wfcelement.c

 *

 *  \brief SI Element handling

 */

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <string.h>

#include <WF/wfc.h>

#include "wfcelement.h"

#include "wfccontext.h"

#include "wfcdevice.h"

#include "wfcstructs.h"

#include "wfcimageprovider.h"

#include "owfnativestream.h"

#include "owfattributes.h"

#include "owfmemory.h"

#include "owfobject.h"

#include "owfdebug.h"

#ifdef __cplusplus

extern "C" {

#endif

#define FIRST_ELEMENT_HANDLE    3000

#define FAIL_IF(c,e)        if (c) { return e; }

static const WFCbitfield    validTransparencyModes[] = {

                                WFC_TRANSPARENCY_NONE,

                                WFC_TRANSPARENCY_ELEMENT_GLOBAL_ALPHA,

                                WFC_TRANSPARENCY_SOURCE,

                                WFC_TRANSPARENCY_MASK,

                                WFC_TRANSPARENCY_ELEMENT_GLOBAL_ALPHA |

                                    WFC_TRANSPARENCY_SOURCE,

                                WFC_TRANSPARENCY_ELEMENT_GLOBAL_ALPHA |

                                    WFC_TRANSPARENCY_MASK

                            };

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

 *

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

void

WFC_Element_Initialize(WFC_ELEMENT* element)

{

    element->dstRect[0]         = 0;

    element->dstRect[1]         = 0;

    element->dstRect[2]         = 0;

    element->dstRect[3]         = 0;

    element->srcRect[0]         = 0;

    element->srcRect[1]         = 0;

    element->srcRect[2]         = 0;

    element->srcRect[3]         = 0;

    element->source             = WFC_INVALID_HANDLE;

    element->sourceFlip         = WFC_FALSE;

    element->sourceRotation     = WFC_ROTATION_0;

    element->sourceScaleFilter  = WFC_SCALE_FILTER_NONE;

    element->transparencyTypes  = 0;

    element->globalAlpha        = OWF_ALPHA_MAX_VALUE;

    element->maskHandle         = WFC_INVALID_HANDLE;

    element->sourceHandle       = WFC_INVALID_HANDLE;

}

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

 *

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

OWF_API_CALL void

WFC_Element_Destroy(WFC_ELEMENT* element)

{

    if (element)

    {

        DPRINT(("WFC_Element_Destroy"));

        DPRINT(("  element = %p (%d)", element, element->handle));

        DESTROY(element->cachedSource);

        DESTROY(element->cachedMask);

        DPRINT(("  cachedSource = %p (%d)", element->cachedSource,

                                            element->cachedSource ?

                                                element->cachedSource->handle :

                                                0));

        DPRINT(("  cachedMask = %p (%d)", element->cachedMask,

                                          element->cachedMask ?

                                              element->cachedMask->handle :

                                              0));

        DESTROY(element->source);

        DESTROY(element->mask);

        DPRINT(("  source = %p (%d)", element->source,

                                      element->source ?

                                          element->source->handle :

                                          0));

        DPRINT(("  mask = %p (%d)", element->mask,

                                    element->mask ?

                                        element->mask->handle :

                                        0));

        DESTROY(element->context);

        OWF_Pool_PutObject(element);

    }

}

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

 *  Create new element into context

 *

 *  \param context Context into which to create the element

 *

 *  \return New element object or NULL

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

OWF_API_CALL WFC_ELEMENT*

WFC_Element_Create(WFC_CONTEXT* context)

{

    static WFCint           nextElementHandle = FIRST_ELEMENT_HANDLE;

    WFC_ELEMENT*            element;

    element = (WFC_ELEMENT*)OWF_Pool_GetObject(context->elementPool);

    if (element)

    {

        WFC_Element_Initialize(element);

        element->handle = nextElementHandle++;

        ADDREF(element->context, context);

        element->device = context->device;

    }

    return element;

}

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

 *

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

OWF_API_CALL WFC_ELEMENT*

WFC_Element_Clone(WFC_ELEMENT* element)

{

    WFC_ELEMENT*        clone;

    WFC_CONTEXT*        context;

    OWF_ASSERT(element);

    DPRINT(("WFC_Element_Clone: element = %d, context = %d", element->handle,

            element->context->handle));

    context = CONTEXT(element->context);

    clone = (WFC_ELEMENT*)OWF_Pool_GetObject(context->elementPool);

    if (clone)

    {

        WFC_Element_Initialize(clone);

        clone->handle           = element->handle;

        clone->sourceFlip       = element->sourceFlip;

        clone->sourceRotation   = element->sourceRotation;

        clone->sourceScaleFilter= element->sourceScaleFilter;

        clone->transparencyTypes= element->transparencyTypes;

        clone->globalAlpha      = element->globalAlpha;

        clone->maskHandle       = element->maskHandle;

        clone->sourceHandle     = element->sourceHandle;

        ADDREF(clone->cachedMask, element->cachedMask);

        ADDREF(clone->cachedSource, element->cachedSource);

        ADDREF(clone->mask,     element->mask);

        ADDREF(clone->source,   element->source);

        clone->device = element->device;

        ADDREF(clone->context,  element->context);

        memcpy(clone->srcRect,  element->srcRect, 4 * sizeof(WFCfloat));

        memcpy(clone->dstRect,  element->dstRect, 4 * sizeof(WFCfloat));

    }

    return clone;

}

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

 *

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

static WFCboolean WFC_Element_ClampRectangle(const char* rtype,

                                             WFCfloat* rect)

{

    /*

     * int -> float conversion:

     * ------------------------

     *

     * above 2^24 we start to lose precision when performing

     * conversions between floats & ints, thus we must clamp

     * values above in order to avoid nasty sign-change effects

     * and other weird side-effects.

     *

     */

    const WFCfloat          LIMIT = 1.6777216E7f;

    WFCint                  i;

    WFCboolean              clamped = WFC_FALSE;

    /* Prevent compiler warning when DPRINT is disabled */

    (void) rtype;

    for (i = 0; i < 4; i++)

    {

        if (fabs(rect[i]) > LIMIT)

        {

#ifdef DEBUG

            static const char* coord[4] = {"x", "y", "width", "height"};

            (void)coord[0];

#endif

            DPRINT(("  Warning: Precision loss in element's %s rectangle's "

                    "%s coordinate.",

                    rtype, coord[i]));

            rect[i] = rect[i] < 0 ? -LIMIT : LIMIT;

            clamped = WFC_TRUE;

        }

    }

    return clamped;

}

/*===========================================================================

 *

 * Attribute set-time checking functions. These are used for checking

 * the attributes before saving them into elements. Attributes are validated

 * for 2nd time during commit, where e.g. destination rectangle size vs.

 * mask size dependency is checked.

 *

 *============================================================================*/

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

 *

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

static WFCErrorCode

WFC_Element_ValidateSourceRectangle(WFC_ELEMENT* element,

                                    WFCfloat* rect)

{

    WFCErrorCode            result = WFC_ERROR_NONE;

#ifndef DEBUG

    (void) element;

#endif    

    OWF_ASSERT(element);

    OWF_ASSERT(rect);

    if (rect[0] < 0.0f || rect[1] < 0.0f || rect[2] < 0.0f || rect[3] < 0.0f)

    {

        result = WFC_ERROR_ILLEGAL_ARGUMENT;

    }

    else if (WFC_Element_ClampRectangle("source", rect))

    {

        result = WFC_ERROR_NONE;

    }

    return result;

}

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

 *

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

static WFCErrorCode

WFC_Element_ValidateDestinationRectangle(WFC_ELEMENT* element,

                                         WFCfloat* rect)

{

    WFCErrorCode            result = WFC_ERROR_NONE;

#ifndef DEBUG

    (void) element;

#endif    

    OWF_ASSERT(element);

    OWF_ASSERT(rect);

    DPRINT(("WFC_Element_ValidateDestinationRectangle(element = %d)",

            element->handle));

    if (rect[2] < 0.0f || rect[3] < 0.0f)

    {

        result = WFC_ERROR_ILLEGAL_ARGUMENT;

    }

    else if (WFC_Element_ClampRectangle("destination", rect))

    {

        /* ... return error or something here? */

        result = WFC_ERROR_NONE;

    }

    /* Hmm.. let's clamp the rectangle even more! To 16k*16k at max;

     * in OWF_Image_Create we calculate the byte size of the image buffer

     * required, and if we have 4bpp, we get overflow for pixelcounts

     * >= 65536*16384. */

    rect[2] = CLAMP(rect[2], 0, 16384);

    rect[3] = CLAMP(rect[3], 0, 16384);

    return result;

}

#define BOOLEAN_TO_ERROR(x) ((x) ? WFC_ERROR_NONE : WFC_ERROR_ILLEGAL_ARGUMENT)

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

 *

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

static WFCErrorCode

WFC_Element_ValidateScalarAttributei(WFC_ELEMENT* element,

                                     WFCElementAttrib attrib,

                                     WFCint value)

{

    WFCErrorCode            result = WFC_ERROR_NONE;

    OWF_ASSERT(element);

    switch (attrib)

    {

        case WFC_ELEMENT_SOURCE:

        {

            WFC_IMAGE_PROVIDER* source;

            source = WFC_Device_FindImageProvider(element->device,

                                                  value,

                                                  WFC_IMAGE_SOURCE);

            result = BOOLEAN_TO_ERROR((WFC_INVALID_HANDLE == value) ||

                                      ((WFC_INVALID_HANDLE != value) &&

                                       (NULL != source)));

            break;

        }

        case WFC_ELEMENT_MASK:

        {

            WFC_IMAGE_PROVIDER* mask;

            mask = WFC_Device_FindImageProvider(element->device,

                                                value,

                                                WFC_IMAGE_MASK);

            result = BOOLEAN_TO_ERROR((WFC_INVALID_HANDLE == value) ||

                                      ((WFC_INVALID_HANDLE != value) &&

                                       (NULL != mask)));

            break;

        }

        case WFC_ELEMENT_SOURCE_ROTATION:

        {

            WFCRotation rotation = (WFCRotation) value;

            result = BOOLEAN_TO_ERROR((WFC_ROTATION_0    == rotation ||

                                       WFC_ROTATION_90   == rotation ||

                                       WFC_ROTATION_180  == rotation ||

                                       WFC_ROTATION_270  == rotation));

            break;

        }

        case WFC_ELEMENT_SOURCE_SCALE_FILTER:

        {

            WFCScaleFilter  filter = (WFCScaleFilter) value;

            result = BOOLEAN_TO_ERROR((WFC_SCALE_FILTER_NONE     == filter ||

                                       WFC_SCALE_FILTER_FASTER   == filter ||

                                       WFC_SCALE_FILTER_BETTER   == filter));

            break;

        }

        case WFC_ELEMENT_SOURCE_FLIP:

        {

            WFCboolean  flip = (WFCboolean) value;

            result = BOOLEAN_TO_ERROR((WFC_TRUE == flip ||

                                       WFC_FALSE == flip));

            break;

        }

        case WFC_ELEMENT_TRANSPARENCY_TYPES:

        {

            WFCint          ii;

            WFCint          count = sizeof(validTransparencyModes) /

                                    sizeof(WFCbitfield);

            WFCbitfield     types = (WFCbitfield) value;

            result = WFC_ERROR_ILLEGAL_ARGUMENT;

            for (ii = 0; ii < count; ii++) {

                if (types == validTransparencyModes[ii])

                {

                    result = WFC_ERROR_NONE;

                    break;

                }

            }

            break;

        }

        default:

        {

            result = WFC_ERROR_BAD_ATTRIBUTE;

            break;

        }

    }

    return result;

}

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

 *

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

static WFCErrorCode

WFC_Element_ValidateScalarAttributef(WFC_ELEMENT* element,

                                     WFCElementAttrib attrib,

                                     WFCfloat value)

{

    WFCErrorCode          result = WFC_ERROR_NONE;

#ifndef DEBUG

    (void) element;

#endif

    OWF_ASSERT(element);

    switch (attrib)

    {

        case WFC_ELEMENT_GLOBAL_ALPHA:

        {

            result = BOOLEAN_TO_ERROR(value >= OWF_ALPHA_MIN_VALUE &&

                                      value <= OWF_ALPHA_MAX_VALUE);

            break;

        }

        /* SPECIAL CASES */

        case WFC_ELEMENT_SOURCE_FLIP:

        case WFC_ELEMENT_SOURCE_ROTATION:

        case WFC_ELEMENT_SOURCE_SCALE_FILTER:

        case WFC_ELEMENT_TRANSPARENCY_TYPES:

        case WFC_ELEMENT_SOURCE:

        case WFC_ELEMENT_MASK:

        {

            /* NOTE! special early out here. */

            result = WFC_ERROR_BAD_ATTRIBUTE;

            break;

        }

        default:

        {

            result = WFC_ERROR_ILLEGAL_ARGUMENT;

            break;

        }

    }

    return result;

}

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

 *

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

static void

WFC_Element_SetElementImageProvider(WFC_ELEMENT* element,

                                    WFC_IMAGE_PROVIDER_TYPE type,

                                    WFCHandle handle)

{

    WFC_IMAGE_PROVIDER*     provider;

    OWF_ASSERT(element);

    provider = WFC_Device_FindImageProvider(element->device, handle, type);

    switch (type)

    {

        case WFC_IMAGE_SOURCE:

        {

            DESTROY(element->cachedSource);

            ADDREF(element->cachedSource, provider);

            element->sourceHandle = handle;

            break;

        }

        case WFC_IMAGE_MASK:

        {

            DESTROY(element->cachedMask);

            ADDREF(element->cachedMask, provider);

            element->maskHandle = handle;

            break;

        }

    }

}

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

 *  \brief Set vector integer attribute for an element

 *

 *  \param element          Element

 *  \param attrib           Attribute name

 *  \param count            Attribute size

 *  \param values           Attribute vector value

 *

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

OWF_API_CALL WFCErrorCode

WFC_Element_SetAttribiv(WFC_ELEMENT* element,

                        WFCElementAttrib attrib,

                        WFCint count,

                        const WFCint* values)

{

    WFCErrorCode            result = WFC_ERROR_NONE;

    FAIL_IF(NULL == values, WFC_ERROR_ILLEGAL_ARGUMENT);