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

 *  \brief OpenWF Composition SI, API implementation.

 *

 *  For function documentations, see OpenWF Composition specification 1.0

 *

 *  The general layout of an API function is:

 *  - grab API mutex (lock API)

 *  - check parameter validity

 *  - invoke implementation function (WFD_...)

 *  - unlock API

 *  - return

 *

 */

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <WF/wfc.h>

#include <WF/wfcext.h>

#include "wfcstructs.h"

#include "wfccontext.h"

#include "owfnativestream.h"

#include "owfscreen.h"

#define RGB_NUM_BYTES       (sizeof(WFCuint8) * 4)

#define COND_FAIL(cond,error,retval) \

    if (!(cond)) { \

        WFC_Device_SetError(dev, error); \

        WFC_Unlock(); \

        return retval; \

    }

#define COND_FAIL_NR(cond,error) \

    if (!(cond)) { \

        WFC_Device_SetError(dev, error); \

        WFC_Unlock(); \

        return; \

    }

#define GET_DEVICE(d, h, x) \

    WFC_Lock(); \

    d = WFC_Device_FindByHandle(h); \

    if (NULL == d) { \

        WFC_Unlock(); \

        return x; \

    }

#define GET_DEVICE_NR(d, h) \

    WFC_Lock(); \

    d = WFC_Device_FindByHandle(h); \

    if (WFC_INVALID_HANDLE == d) { \

        WFC_Unlock(); \

        return; \

    }

#define GET_CONTEXT_NR(c,d,h) \

    c = WFC_Device_FindContext(d, h); \

    if (WFC_INVALID_HANDLE == c) { \

        WFC_Device_SetError((d)->handle, WFC_ERROR_BAD_HANDLE); \

        WFC_Unlock(); \

        return; \

    }

#define GET_CONTEXT(c,d,h,x) \

    c = WFC_Device_FindContext(d, h); \

    if (WFC_INVALID_HANDLE == c) { \

        WFC_Device_SetError((d)->handle, WFC_ERROR_BAD_HANDLE); \

        WFC_Unlock(); \

        return x; \

    }

#define SUCCEED(retval) \

    WFC_Device_SetError(dev, WFC_ERROR_NONE); \

    WFC_Unlock(); \

    return retval

#define SUCCEED_NR() \

    WFC_Device_SetError(dev, WFC_ERROR_NONE); \

    WFC_Unlock(); \

    return

#define FAIL(err, retval) \

    WFC_Device_SetError(dev, err); \

    WFC_Unlock(); \

    return retval

#define FAIL_NR(err) \

    WFC_Device_SetError(dev, err); \

    WFC_Unlock(); \

    return

static OWF_MUTEX           mutex;

static void WFC_Cleanup()

{

    OWF_Mutex_Destroy(&mutex);

}

static void WFC_Lock()

{

    if (!mutex)

    {

        OWF_Mutex_Init(&mutex);

        xatexit(WFC_Cleanup);   // Use adaptation version of atexit

    }

    OWF_Mutex_Lock(&mutex);

}

static void WFC_Unlock()

{

    OWF_Mutex_Unlock(&mutex);

}

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

/*  4. DEVICE                                                              */

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

WFC_API_CALL WFCint WFC_APIENTRY

wfcEnumerateDevices(WFCint *deviceIds,

                    WFCint deviceIdsCount,

                    const WFCint *filterList)

{

    WFCint                  n;

    /* populate list with device IDs */

    n = WFC_Devices_GetIds(deviceIds, deviceIdsCount, filterList);

    return n;

}

WFC_API_CALL WFCDevice WFC_APIENTRY

wfcCreateDevice(WFCint deviceId, const WFCint *attribList)

{

    WFCDevice               device;

    /* currently only empty attribute list or NULL is allowed */

    if (attribList && *attribList != WFC_NONE)

    {

        return WFC_INVALID_HANDLE;

    }

    WFC_Lock();

    device = WFC_Device_Create(deviceId);

    WFC_Unlock();

    return device;

}

WFC_API_CALL WFCErrorCode WFC_APIENTRY

wfcDestroyDevice(WFCDevice dev)

{

    WFC_DEVICE*             device;

    WFCErrorCode            result = WFC_ERROR_BAD_DEVICE;

    DPRINT(("wfcDestroyDevice(%d)", dev));

    WFC_Lock();

    device = WFC_Device_FindByHandle(dev);

    if (device)

    {

        WFC_Device_Destroy(device);

        result = WFC_ERROR_NONE;

    }

    WFC_Unlock();

    return result;

}

WFC_API_CALL WFCint WFC_APIENTRY

wfcGetDeviceAttribi(WFCDevice dev,

                    WFCDeviceAttrib attrib)

{

    WFC_DEVICE*             device;

    WFCint                  result = 0;

    WFCErrorCode            err;

    GET_DEVICE(device, dev, 0);

    err = WFC_Device_GetAttribi(device, attrib, &result);

    FAIL(err, result);

}

WFC_API_CALL WFCErrorCode WFC_APIENTRY

wfcGetError(WFCDevice dev)

{

    WFC_DEVICE* device;

    WFCErrorCode            err;

    GET_DEVICE(device, dev, WFC_ERROR_BAD_DEVICE);

    err = WFC_Device_GetError(device);

    WFC_Unlock();

    return err;

}

WFC_API_CALL void WFC_APIENTRY

wfcCommit(WFCDevice dev, WFCContext ctx, WFCboolean wait)

{

    WFC_DEVICE*             device;

    WFC_CONTEXT*            context;

    WFCErrorCode            error;

    DPRINT(("wfcCommit(%d,%d,%d)", dev, ctx, wait));

    GET_DEVICE_NR(device, dev);

    GET_CONTEXT_NR(context, device, ctx);

    error = WFC_Context_InvokeCommit(device, context, wait);

    FAIL_NR(error);

}

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

/* 5. CONTEXT                                                              */

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

WFC_API_CALL WFCContext WFC_APIENTRY

wfcCreateOnScreenContext(WFCDevice dev,

                         WFCint screenNumber,

                         const WFCint* attribList)

{

    WFC_CONTEXT*            context = NULL;

    WFC_DEVICE*             device = NULL;

    GET_DEVICE(device, dev, WFC_INVALID_HANDLE);

    /* currently only empty attribute list or NULL is allowed */

    COND_FAIL(!(attribList && *attribList != WFC_NONE),

              WFC_ERROR_BAD_ATTRIBUTE,

              WFC_INVALID_HANDLE);

    if (screenNumber == WFC_DEFAULT_SCREEN_NUMBER)

    {

        screenNumber = OWF_Screen_GetDefaultNumber();

    }

    else

    {

        /* check screen number validity */

        if (!OWF_Screen_Valid(screenNumber))

        {

            FAIL(WFC_ERROR_UNSUPPORTED, WFC_INVALID_HANDLE);

        }

    }

    /* check that no other context currently uses this screen */

    if (!OWF_Screen_Valid_And_Available(screenNumber))

    {

        FAIL(WFC_ERROR_IN_USE, WFC_INVALID_HANDLE);

    }

    context = WFC_Device_CreateContext(device,

                                       WFC_INVALID_HANDLE,

                                       WFC_CONTEXT_TYPE_ON_SCREEN,

                                       screenNumber);

    if (!context)

    {

        FAIL(WFC_ERROR_OUT_OF_MEMORY, WFC_INVALID_HANDLE);

    }

    SUCCEED(context->handle);

}

WFC_API_CALL WFCContext WFC_APIENTRY

wfcCreateOffScreenContext(WFCDevice dev,

                          WFCNativeStreamType stream,

                          const WFCint *attribList)

{

    WFC_CONTEXT*            context = NULL;

    WFC_DEVICE*             device = NULL;

    OWFNativeStreamType 	internalStream=OWF_INVALID_HANDLE;

    OWF_STREAM_ERROR 		streamError;

    GET_DEVICE(device, dev, WFC_INVALID_HANDLE);

    /* currently only empty attribute list or NULL is allowed */

    COND_FAIL(!(attribList && *attribList != WFC_NONE),

              WFC_ERROR_BAD_ATTRIBUTE,

              WFC_INVALID_HANDLE);

    COND_FAIL(OWF_INVALID_HANDLE != (OWFNativeStreamType) stream,

              WFC_ERROR_ILLEGAL_ARGUMENT,

              WFC_INVALID_HANDLE);

    internalStream=owfNativeStreamFromWFC(stream,&streamError);

    COND_FAIL(OWF_STREAM_ERROR_INVALID_STREAM!=streamError,WFC_ERROR_UNSUPPORTED,WFC_INVALID_HANDLE);

    COND_FAIL(OWF_STREAM_ERROR_OUT_OF_MEMORY!=streamError,WFC_ERROR_OUT_OF_MEMORY,WFC_INVALID_HANDLE);

    if (!WFC_Context_IsValidTargetStream(internalStream))

    {

        owfNativeStreamDestroy(internalStream); /*cancel owfNativeStreamFromWFC reference increase*/

        FAIL(WFC_ERROR_UNSUPPORTED,WFC_INVALID_HANDLE);

    }

    context = WFC_Device_CreateContext(device, internalStream,

                                       WFC_CONTEXT_TYPE_OFF_SCREEN,

                                       OWF_RESERVED_BAD_SCREEN_NUMBER);

    owfNativeStreamDestroy(internalStream);	/*cancel owfNativeStreamFromWFC reference increase*/

    COND_FAIL(NULL != context, WFC_ERROR_OUT_OF_MEMORY, WFC_INVALID_HANDLE);

    SUCCEED(context->handle);

}

WFC_API_CALL void WFC_APIENTRY

wfcDestroyContext(WFCDevice dev,

                  WFCContext ctx)

{

    WFC_DEVICE*             device = NULL;

    WFCErrorCode            err;

    DPRINT(("wfcDestroyContext(%d, %d)", dev, ctx));

    GET_DEVICE_NR(device, dev);

    err = WFC_Device_DestroyContext(device, ctx);

    FAIL_NR(err);

}

WFC_API_CALL WFCint WFC_APIENTRY

wfcGetContextAttribi(WFCDevice dev,

                     WFCContext ctx,

                     WFCContextAttrib attrib)

{

    WFC_CONTEXT*            context = NULL;

    WFC_DEVICE*             device = NULL;

    WFCint                  value = 0;

    WFCErrorCode            err;

    GET_DEVICE(device, dev, 0);

    GET_CONTEXT(context, device, ctx, 0);

    err = WFC_Context_GetAttribi(context, attrib, &value);

    FAIL(err, value);

}

WFC_API_CALL void WFC_APIENTRY

wfcSetContextAttribi(WFCDevice dev,

                     WFCContext ctx,

                     WFCContextAttrib attrib,

                     WFCint value)

{

    WFC_DEVICE*             device;

    WFC_CONTEXT*            context;

    WFCErrorCode            err;

    GET_DEVICE_NR(device, dev);

    GET_CONTEXT_NR(context, device, ctx);

    err = WFC_Context_SetAttribi(context, attrib, value);

    FAIL_NR(err);

}

WFC_API_CALL void WFC_APIENTRY

wfcGetContextAttribfv(WFCDevice dev,

                      WFCContext ctx,

                      WFCContextAttrib attrib,

                      WFCint count,

                      WFCfloat *values) WFC_APIEXIT

{

    WFC_DEVICE*             device;

    WFC_CONTEXT*            context;

    WFCErrorCode            err;

    GET_DEVICE_NR(device, dev);

    GET_CONTEXT_NR(context, device, ctx);

    err = WFC_Context_GetAttribfv(context, attrib, count, values);

    FAIL_NR(err);

}

WFC_API_CALL void WFC_APIENTRY

wfcSetContextAttribfv(WFCDevice dev,

                      WFCContext ctx,

                      WFCContextAttrib attrib,

                      WFCint count,

                      const WFCfloat *values) WFC_APIEXIT

{

      WFC_DEVICE*             device;

      WFC_CONTEXT*            context;

      WFCErrorCode            err;

      GET_DEVICE_NR(device, dev);

      GET_CONTEXT_NR(context, device, ctx);

      err = WFC_Context_SetAttribfv(context, attrib, count, values);

      FAIL_NR(err);

}

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

/* 6. IMAGE PROVIDERS (SOURCES & MASKS)                                    */

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

WFC_API_CALL WFCSource WFC_APIENTRY

wfcCreateSourceFromStream(WFCDevice dev,

                          WFCContext ctx,

                          WFCNativeStreamType stream,

                          const WFCint *attribList)

{

    WFC_DEVICE*             device;

    WFC_IMAGE_PROVIDER*     source;

    WFC_CONTEXT*            context;

    OWFNativeStreamType 	internalStream=OWF_INVALID_HANDLE;

    OWF_STREAM_ERROR 		streamError;

    GET_DEVICE(device, dev, WFC_INVALID_HANDLE);

    /* currently only empty attribute list or NULL is allowed */

    COND_FAIL(!(attribList && *attribList != WFC_NONE),

              WFC_ERROR_BAD_ATTRIBUTE,

              WFC_INVALID_HANDLE);

    GET_CONTEXT(context, device, ctx, WFC_INVALID_HANDLE);

    COND_FAIL(OWF_INVALID_HANDLE != (OWFNativeStreamType) stream,

              WFC_ERROR_ILLEGAL_ARGUMENT,

              WFC_INVALID_HANDLE);

    internalStream=owfNativeStreamFromWFC(stream,&streamError);

    COND_FAIL(OWF_STREAM_ERROR_INVALID_STREAM!=streamError,WFC_ERROR_UNSUPPORTED,WFC_INVALID_HANDLE);

    COND_FAIL(OWF_STREAM_ERROR_OUT_OF_MEMORY!=streamError,WFC_ERROR_OUT_OF_MEMORY,WFC_INVALID_HANDLE);

    if (context->stream == internalStream)

    	{

    	owfNativeStreamDestroy(internalStream);

        FAIL( WFC_ERROR_IN_USE, WFC_INVALID_HANDLE);

    	}

    if (!WFC_Context_IsValidSourceStream(internalStream))

        {

        owfNativeStreamDestroy(internalStream);

        FAIL( WFC_ERROR_UNSUPPORTED, WFC_INVALID_HANDLE);

        }

    source = WFC_Device_CreateSource(device, context, internalStream);

    owfNativeStreamDestroy(internalStream);	/*cancel FromWFC reference increase*/

    COND_FAIL(NULL != source, WFC_ERROR_OUT_OF_MEMORY, WFC_INVALID_HANDLE);

    SUCCEED(source->handle);

}

WFC_API_CALL void WFC_APIENTRY

wfcDestroySource(WFCDevice dev,

                 WFCSource src)

{

    WFC_DEVICE*             device;

    WFCErrorCode            err;

    GET_DEVICE_NR(device, dev);

    err = WFC_Device_DestroySource(device, src);

    FAIL_NR(err);

}

WFC_API_CALL WFCMask WFC_APIENTRY

wfcCreateMaskFromStream(WFCDevice dev,

                        WFCContext ctx,

                        WFCNativeStreamType stream,

                        const WFCint *attribList) WFC_APIEXIT

{

    WFC_DEVICE*             device;

    WFC_CONTEXT*            context;

    WFC_IMAGE_PROVIDER*     mask;

    WFCboolean              inUse;

    OWFNativeStreamType 	internalStream=OWF_INVALID_HANDLE;

    OWF_STREAM_ERROR 		streamError;

    GET_DEVICE(device, dev, WFC_ERROR_BAD_DEVICE);

    /* currently only empty attribute list or NULL is allowed */

    COND_FAIL(!(attribList && *attribList != WFC_NONE),

              WFC_ERROR_BAD_ATTRIBUTE,

              WFC_INVALID_HANDLE);

    GET_CONTEXT(context, device, ctx, WFC_INVALID_HANDLE);

    COND_FAIL(OWF_INVALID_HANDLE != (OWFNativeStreamType) stream,

              WFC_ERROR_ILLEGAL_ARGUMENT,

              WFC_INVALID_HANDLE);

    internalStream=owfNativeStreamFromWFC(stream,&streamError);

    COND_FAIL(OWF_STREAM_ERROR_INVALID_STREAM!=streamError,WFC_ERROR_UNSUPPORTED,WFC_INVALID_HANDLE);

    COND_FAIL(OWF_STREAM_ERROR_OUT_OF_MEMORY!=streamError,WFC_ERROR_OUT_OF_MEMORY,WFC_INVALID_HANDLE);

    inUse = WFC_Device_StreamIsTarget(device, internalStream);

    if (inUse)

    	{

       	owfNativeStreamDestroy(internalStream);

        FAIL( WFC_ERROR_IN_USE, WFC_INVALID_HANDLE);

       	}

    mask = WFC_Device_CreateMask(device, context, internalStream);

    owfNativeStreamDestroy(internalStream);	/*cancel FromWFC reference increase*/

    COND_FAIL(NULL != mask, WFC_ERROR_OUT_OF_MEMORY, WFC_INVALID_HANDLE);

    SUCCEED(mask->handle);

}

WFC_API_CALL void WFC_APIENTRY

wfcDestroyMask(WFCDevice dev,

               WFCMask mask) WFC_APIEXIT

{

    WFC_DEVICE*             device;

    WFCErrorCode            error;

    GET_DEVICE_NR(device, dev);