*

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

 *

 *  \brief SI Device handling

 */

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include "wfcdevice.h"

#include "wfcelement.h"

#include "wfccontext.h"

#include "wfcimageprovider.h"

#include "owfarray.h"

#include "owfmemory.h"

#include "owfmutex.h"

#include "owfscreen.h"

#include "owftypes.h"

#include "owfobject.h"

#include "owfnativestream.h"

#include "owfnotifications.h"

#include "owfdebug.h"

#ifdef __cplusplus

extern "C" {

#endif

#define MAX_ATTRIBUTES      32

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

#define FIRST_DEVICE_HANDLE 1000

PHYSICAL_DEVICE gPhyDevice;

/*-------------------------------------------------------------------------*//*!

 *  \internal

 *

 *  Initialize devices with default parameters.

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

OWF_API_CALL void

WFC_Devices_Initialize()

{

    static WFCboolean initialised=WFC_FALSE;

    if (!initialised)

    {

        OWF_Array_Initialize(&(gPhyDevice.iDeviceInstanceArray));

        gPhyDevice.gDeviceHandleID = 0;

        initialised=WFC_TRUE;

    }

}

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

 *

 *

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

OWF_API_CALL WFCint

WFC_Devices_GetIds(WFCint* idList,

                   WFCint listCapacity,

                   const WFCint* filterList)

{

/* We assume there is only one physical device and

 * all screens are supported by this device */

    WFCint                  screenNumber = OWF_RESERVED_BAD_SCREEN_NUMBER,

                            n = MAX_ATTRIBUTES,

                            i = 0;

    WFCboolean              hasFilter;

    hasFilter = (filterList && (*filterList != WFC_NONE)) ?

                WFC_TRUE :

                WFC_FALSE;

    /* handle filter list, if given */

    if (hasFilter)

    {

        /* scan filter list (up to 32 attributes) */

        while (n > 0 && WFC_NONE != filterList[0])

        {

            switch (filterList[0])

            {

                case WFC_DEVICE_FILTER_SCREEN_NUMBER:

                    if (screenNumber!=OWF_RESERVED_BAD_SCREEN_NUMBER && screenNumber!=filterList[1])

                         {

                         /* invalid repeated filter on screen number */

                          return 0;

                         }

                    screenNumber = filterList[1];

                    if (!OWF_Screen_Valid(screenNumber))

                    {

                        /* invalid screen number */

                        return 0;

                    }

                    break;

                case WFC_NONE:

                    n = 0;

                    break;

                default:

                    /* EARLY EXIT - invalid attribute */

                    return 0;

            }

            /* Move pointer to next key-value pair */

            filterList += 2;

            n--;

        }

    }

    /* Return number of available devices */

    if (NULL == idList && !hasFilter) {

        return 1;

    }

    for (i = 0, n = 0; i < 1 && listCapacity >= 0; i++) {

        /* idList might be NULL when querying all devices w/

         * screen number in filter list */

        if (idList && n < listCapacity)

        {

            idList[n] = OWF_SUPPORTED_DEVICE_ID;

        }

        n++;

    }

    return n;

}

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

 *  Create instance of a device whose ID

 *  matches deviceId

 *

 *  \param deviceId ID of the device to create. Must be WFC_DEFAULT_DEVICE_ID

 *  or some other valid device ID (returned by Devices_GetIds)

 *

 *  \return Handle to created device or WFC_INVALID_HANDLE

 *

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

OWF_API_CALL WFCint

WFC_Device_Create(WFCint deviceId)

{

	WFC_DEVICE *dev = NULL;

    ENTER(WFC_Device_Create);

    WFC_Devices_Initialize();

    if (deviceId != WFC_DEFAULT_DEVICE_ID && deviceId != OWF_SUPPORTED_DEVICE_ID)

    {

        return WFC_INVALID_HANDLE;

    }

    dev = DEVICE(xalloc(1,sizeof(WFC_DEVICE)));

    if (dev == NULL)

    {

    	return WFC_INVALID_HANDLE;

    }

    dev->handle = FIRST_DEVICE_HANDLE + (gPhyDevice.gDeviceHandleID)++;

    dev->deviceId = deviceId;

    dev->latestUnreadError = WFC_ERROR_NONE;

    dev->mutex = NULL;

    OWF_Array_Initialize(&dev->contexts);

    OWF_Array_Initialize(&dev->providers);

    OWF_Array_Initialize(&dev->elements);

    if (!OWF_Array_AppendItem(&(gPhyDevice.iDeviceInstanceArray), dev))

        {

        xfree(dev);

        return WFC_INVALID_HANDLE;

        }

    LEAVE(WFC_Device_Create);

    return dev->handle;

}

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

 *  Set error code for device. Obs! In case the previous

 *  error code hasn't been read from the device, this function

 *  does nothing; the new error is set only if "current" error

 *  is none.

 *

 *  \param dev Device object

 *  \param code Error to set

 *

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

OWF_API_CALL void OWF_APIENTRY

WFC_Device_SetError(WFCDevice dev,

                    WFCErrorCode code)

{

#ifdef DEBUG_LOG

    static char* const      errmsg[] =

                            {

                            "WFC_ERROR_NONE",

                            "WFC_ERROR_OUT_OF_MEMORY",

                            "WFC_ERROR_ILLEGAL_ARGUMENT",

                            "WFC_ERROR_UNSUPPORTED",

                            "WFC_ERROR_BAD_ATTRIBUTE",

                            "WFC_ERROR_IN_USE",

                            "WFC_ERROR_BUSY",

                            "WFC_ERROR_BAD_DEVICE",

                            "WFC_ERROR_BAD_HANDLE",

                            "WFC_ERROR_INCONSISTENCY",

                            };

#endif

    WFC_DEVICE* device = WFC_Device_FindByHandle(dev);

    if (WFC_INVALID_HANDLE == device)

    {

        /* Invalid device handle. Nothing we can do about it so return. */

        return;

    }

    if (!device->mutex)

    {

        OWF_Mutex_Init(&device->mutex);

    }

    OWF_Mutex_Lock(&device->mutex);

    if (code == WFC_ERROR_IN_USE)

        {

        code=WFC_ERROR_IN_USE;

        }

    if (WFC_INVALID_HANDLE != device) {

        if (WFC_ERROR_NONE == device->latestUnreadError &&

            code != device->latestUnreadError)

        {

#ifdef DEBUG_LOG

             char* const msg = errmsg[code > WFC_ERROR_NONE ?

                    code - WFC_ERROR_OUT_OF_MEMORY + 1 : 0];

             (void)msg; //always reference to avoid warning

#endif

            DPRINT(("setError(dev = %08x, err = %08x)", dev, code));

            DPRINT(("  error set to = %04x (%s)", (OWFuint16) code, msg));

            device->latestUnreadError = code;

        }

    }

    OWF_Mutex_Unlock(&device->mutex);

}

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

 *  Read and reset last error code from device.

 *

 *  \param device Device object

 *

 *  \return WFCErrorCode

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

OWF_API_CALL WFCErrorCode

WFC_Device_GetError(WFC_DEVICE* device)

{

    WFCErrorCode            err;

    OWF_ASSERT(device);

    err = device->latestUnreadError;

    device->latestUnreadError = WFC_ERROR_NONE;

    return err;

}

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

 *  Find device object by handle

 *

 *  \param dev Device handle

 *

 *  \return Matching device object or NULL

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

OWF_API_CALL WFC_DEVICE*

WFC_Device_FindByHandle(WFCDevice dev)

{

    WFCint i = 0, length = 0;

    WFC_DEVICE* pDevice = NULL;

    if (dev == WFC_INVALID_HANDLE)

    {

        return NULL;

    }

    WFC_Devices_Initialize();

    length = gPhyDevice.iDeviceInstanceArray.length;

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

        {

        pDevice = DEVICE(OWF_Array_GetItemAt(&(gPhyDevice.iDeviceInstanceArray), i));

        if (pDevice->handle == dev)

            {

            return pDevice;

            }

        }

    return NULL;

}

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

 *  Get device attribute

 *

 *  \param device Device

 *  \param attrib Attribute name

 *  \param value Pointer to where the value should be saved

 *

 *  \return WFCErrorCode

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

OWF_API_CALL WFCErrorCode

WFC_Device_GetAttribi(WFC_DEVICE* device,

                      WFCDeviceAttrib attrib,

                      WFCint* value)

{

    WFCErrorCode            result = WFC_ERROR_NONE;

    OWF_ASSERT(device);

    switch (attrib)

    {

        case WFC_DEVICE_CLASS:

        {

            *value = WFC_DEVICE_CLASS_FULLY_CAPABLE;

            break;

        }

        case WFC_DEVICE_ID:

        {

            *value = device->deviceId;

            break;

        }

        default:

        {

            result = WFC_ERROR_BAD_ATTRIBUTE;

        }

    }

    return result;

}

/*[][][][] CONTEXTS  [][][][][][][][][][][][][][][][][][][][][][][][][][][][]*/

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

 *  Create context on device

 *

 *  \param device Device

 *  \param stream Target stream for context

 *  \param type Context type

 *

 *  \return New context

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

OWF_API_CALL WFC_CONTEXT*

WFC_Device_CreateContext(WFC_DEVICE* device,

                         OWFNativeStreamType stream,

                         WFCContextType type,

                         WFCint screenNum)

{

    WFC_CONTEXT*            context;

    ENTER(WFC_Device_CreateContext);

    OWF_ASSERT(device);

    context = WFC_Context_Create(device, stream, type, screenNum);

    if (context)

    {

        if (!OWF_Array_AppendItem(&device->contexts, context))

        {

            DESTROY(context);

        }

    }

    LEAVE(WFC_Device_CreateContext);

    return context;

}

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

 *  Destroy context from device

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

OWF_API_CALL WFCErrorCode

WFC_Device_DestroyContext(WFC_DEVICE* device,

                          WFCContext context)

{

    WFCint                  i;

    WFCErrorCode            result = WFC_ERROR_BAD_HANDLE;

    ENTER(WFC_Device_DestroyContext);

    OWF_ASSERT(device);

    DPRINT(("WFC_Device_DestroyContext(context = %d)", context));

    for (i = 0; i < device->contexts.length; i++)

    {

        WFC_CONTEXT*        ctmp;

        ctmp = (WFC_CONTEXT*) OWF_Array_GetItemAt(&device->contexts, i);

        if (ctmp->handle == context)

        {

            WFC_CONTEXT*    context;

            context = CONTEXT(OWF_Array_RemoveItemAt(&device->contexts, i));

            DPRINT(("  Shutting down context %d", context->handle));

            WFC_Context_Shutdown(context);

            DESTROY(context);

            result = WFC_ERROR_NONE;

            break;

        }

    }

    DPRINT((""));

    DPRINT(("-------------------------------------------------------"));

    DPRINT(("Device statistics after context destruction:"));

    DPRINT(("  Contexts: %d", device->contexts.length));

    DPRINT(("  Elements: %d", device->elements.length));

    DPRINT(("  Image providers: %d", device->providers.length));

     DPRINT(("-------------------------------------------------------"));

    LEAVE(WFC_Device_DestroyContext);

    return result;

}

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

 *  Destroy all device's contexts

 *

 *  \param device Device object

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

OWF_API_CALL void

WFC_Device_DestroyContexts(WFC_DEVICE* device)

{

    WFCint                  i;

    ENTER(WFC_Device_DestroyContexts);

    for (i = 0; i < device->contexts.length; i++)

    {

        WFC_CONTEXT*        context;

        context = CONTEXT(OWF_Array_GetItemAt(&device->contexts, i));

        WFC_Context_Shutdown(context);

        DESTROY(context);

    }

    OWF_Array_Destroy(&device->contexts);

    LEAVE(WFC_Device_DestroyContexts);

}

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

 *  Find context context object by handle

 *

 *  \param device Device

 *  \param context Context handle

 *

 *  \return Corresponding context object or NULL

 *  if handle is invalid.

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

OWF_API_CALL WFC_CONTEXT*

WFC_Device_FindContext(WFC_DEVICE* device,

                       WFCContext context)

{

    WFCint                  i;

    WFC_CONTEXT*            result = NULL;

    ENTER(WFC_Device_FindContext);

    FAIL_IF(NULL == device, NULL);

    for (i = 0; i < device->contexts.length; i++)

    {

        WFC_CONTEXT*        ctmp;

        ctmp = CONTEXT(OWF_Array_GetItemAt(&device->contexts, i));

        if (ctmp->handle == context)

        {

            result = ctmp;

            break;

        }

    }

    LEAVE(WFC_Device_FindContext);

    return result;

}

/*[][][][] ELEMENTS  [][][][][][][][][][][][][][][][][][][][][][][][][][][][]*/

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

 *  Create new element

 *

 *  \param device

 *  \param context

 *

 *  \return New element or NULL

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

OWF_API_CALL WFC_ELEMENT*

WFC_Device_CreateElement(WFC_DEVICE* device, WFC_CONTEXT* context)

{

    WFC_ELEMENT*        element=NULL;

    ENTER(WFC_Device_CreateElement);

    FAIL_IF(NULL == device || NULL == context, NULL);

    if (WFC_Context_IncreaseClientElementCount(context)>0)

    {

        element = WFC_Element_Create(context);

        if (!element || !OWF_Array_AppendItem(&device->elements, element))

        {

            DPRINT(("WFC_Device_CreateElement: couldn't create element"));