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

 *

 *  \brief SI Context handling

 */

#include <string.h>

#include <stdio.h>

#include <time.h>

#include <stdlib.h>

#include <math.h>

#include <WF/wfc.h>

#include <EGL/egl.h>

#include "wfccontext.h"

#include "wfcpipeline.h"

#include "owfscreen.h"

#include "owfdisplaycontextgeneral.h"

#include "owfnotifications.h"

/*! maximum number of elements per scene */

#define MAX_ELEMENTS            512

/*! maximum number of scenes per context */

#define MAX_SCENES              3

#define CONTEXT_SCENE_POOL_SIZE     MAX_SCENES

#define CONTEXT_ELEMENT_POOL_SIZE   MAX_SCENES * MAX_ELEMENTS

#define CONTEXT_NODE_POOL_SIZE      2 * CONTEXT_ELEMENT_POOL_SIZE

/*! almost 2^31 */

#define MAX_DELAY               2100000000

/*! 15ms */

#define AUTO_COMPOSE_DELAY      15000

#define FIRST_CONTEXT_HANDLE    2000

#define WAIT_FOREVER            -1

#ifdef __cplusplus

extern "C" {

#endif

static WFCHandle                nextContextHandle = FIRST_CONTEXT_HANDLE;

typedef enum

{

    WFC_MESSAGE_NONE,

    WFC_MESSAGE_QUIT,

    WFC_MESSAGE_COMPOSE,

    WFC_MESSAGE_COMMIT,

    WFC_MESSAGE_FENCE_1_DISPLAY,

    WFC_MESSAGE_FENCE_2_SYNCOBJECT,

    WFC_MESSAGE_ACTIVATE,

    WFC_MESSAGE_DEACTIVATE,

    WFC_MESSAGE_START_COUNTDOWN,

    WFC_MESSAGE_CANCEL

} WFC_MESSAGES;

static void*

WFC_Context_ComposerThread(void* data);

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

 *

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

void WFC_CONTEXT_Ctor(void* self)

{

    self = self;

}

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

static WFCboolean

WFC_Context_CreateState(WFC_CONTEXT* context)

    {   /* Must be called late enough that scratch buffers can be mapped and hardware rotation capability queried */

    OWF_IMAGE_FORMAT        fInt,

                            fExt;

    WFCint                  stride = 0;

    OWF_ASSERT(context);

    DPRINT(("WFC_Context_CreateContextState"));

    owfNativeStreamGetHeader(context->stream,

                             NULL, NULL, &stride, &fExt, NULL);

    /* internal image used as intermediate target */

    fInt.pixelFormat    = OWF_IMAGE_ARGB_INTERNAL;

    fInt.linear         = fExt.linear;

    fInt.premultiplied  = fExt.premultiplied;

    fInt.rowPadding     = 1;

    if (context->type == WFC_CONTEXT_TYPE_ON_SCREEN)

        {

        /* The unrotated target buffer: Can't get real address without locking for writing!  NO STRIDE */

        context->state.unrotatedTargetImage=OWF_Image_Create(context->targetWidth,context->targetHeight,&fExt,context->scratchBuffer[2],0);

        /* The rotated version of the target buffer for hardware rotation

         * or a de-rotated version of the internal buffer into another scratch buffer for software rotation

         */ 

        if (OWF_Screen_Rotation_Supported(context->screenNumber))

            {   /* The rotated version of the target buffer for hardware rotation */

            context->state.rotatedTargetImage=OWF_Image_Create(context->targetHeight,context->targetWidth,&fExt,context->scratchBuffer[2],0);

            }

        else

            {   /* a de-rotated version of the internal buffer into another scratch buffer for software rotation */

            context->state.rotatedTargetImage=OWF_Image_Create(context->targetWidth,context->targetHeight,&fInt,context->scratchBuffer[1],0);

            }

        }

    else

        {

        /* The unrotated target buffer: Can't get real address without locking for writing!  STRIDE HONOURED */

        context->state.unrotatedTargetImage=OWF_Image_Create(context->targetWidth,context->targetHeight,&fExt,context->scratchBuffer[2],stride);

        /* a de-rotated version of the internal buffer into another scratch buffer for software rotation */

        context->state.rotatedTargetImage=OWF_Image_Create(context->targetWidth,context->targetHeight,&fInt,context->scratchBuffer[1],0);

        }

    /* The internal target buffer composed to for 0 and 180 degree rotation */

    context->state.unrotatedInternalTargetImage=OWF_Image_Create(context->targetWidth,context->targetHeight,&fInt,context->scratchBuffer[0],stride);

    /* The internal target buffer composed to for 90 and 270 degree rotation */

    context->state.rotatedInternalTargetImage=OWF_Image_Create(context->targetHeight,context->targetWidth,&fInt,context->scratchBuffer[0],stride);

    if (context->state.unrotatedTargetImage && context->state.rotatedTargetImage && context->state.unrotatedInternalTargetImage && context->state.rotatedInternalTargetImage)

        {

        return WFC_TRUE;

        }

    else

        {

        return WFC_FALSE;

        }

    }

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

static void

WFC_Context_DestroyState(WFC_CONTEXT* context)

    {

    /* The unrotated target buffer */ 

    OWF_Image_Destroy(context->state.unrotatedTargetImage);

    /* The rotated version of the target buffer for hardware rotation, 

     * or a de-rotated version of the internal buffer into another scratch buffer for software rotation

     */ 

    OWF_Image_Destroy(context->state.rotatedTargetImage);

    /* The internal target buffer composed to for 0 and 180 degree rotation */

    OWF_Image_Destroy(context->state.unrotatedInternalTargetImage);

    /* The internal target buffer composed to for 90 and 270 degree rotation */

    OWF_Image_Destroy(context->state.rotatedInternalTargetImage);

    }

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

 * Should only be accessed indirectly by calls to WFC_Device_DestroyContext or

 * WFC_Device_DestroyContexts

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

void WFC_CONTEXT_Dtor(void* self)

{

    OWFint                  ii = 0;

    WFC_CONTEXT*            context = NULL;

    OWF_ASSERT(self);

    DPRINT(("WFC_CONTEXT_Dtor(%p)", self));

    context = CONTEXT(self);

    OWF_ASSERT(context);

    WFC_Pipeline_DestroyState(context);

    WFC_Context_DestroyState(context);

    OWF_MessageQueue_Destroy(&context->composerQueue);

    /* make the stream destroyable */

    if (context->stream != OWF_INVALID_HANDLE)

        {

        owfNativeStreamSetProtectionFlag(context->stream, OWF_FALSE);

        owfNativeStreamDestroy(context->stream);

        }

    context->stream = OWF_INVALID_HANDLE;

    OWF_AttributeList_Destroy(&context->attributes);

    for (ii = 0; ii < SCRATCH_BUFFER_COUNT; ii++)

    {

        OWF_Image_FreeData(context->displayContext, &context->scratchBuffer[ii]);

        context->scratchBuffer[ii] = 0;

    }

    OWF_DisplayContext_Destroy(context->screenNumber, context->displayContext);

    context->displayContext = NULL;    

    OWF_Pool_Destroy(context->scenePool);

    OWF_Pool_Destroy(context->elementPool);

    OWF_Pool_Destroy(context->nodePool);

    OWF_Semaphore_Destroy(&context->compositionSemaphore);

    OWF_Semaphore_Destroy(&context->commitSemaphore);

    OWF_Mutex_Destroy(&context->updateFlagMutex);

    OWF_Mutex_Destroy(&context->sceneMutex);

}

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

 *

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

OWF_API_CALL void

WFC_Context_Shutdown(WFC_CONTEXT* context)

{

    OWF_ASSERT(context);

    DPRINT(("WFC_Context_Shutdown(context = %d)", context->handle));

    DPRINT(("Waiting for composer thread termination"));

    OWF_Message_Send(&context->composerQueue, WFC_MESSAGE_QUIT, 0);

    OWF_Thread_Join(context->composerThread, NULL);

    OWF_Thread_Destroy(context->composerThread);

    context->composerThread = NULL;

    if (context->device)

    {

        /* #4604: added guard condition */

        WFC_Device_DestroyContextElements(context->device, context);

        WFC_Device_DestroyContextImageProviders(context->device, context);

    }

    WFC_Scene_Destroy(context->workScene);

    WFC_Scene_Destroy(context->snapshotScene);

    WFC_Scene_Destroy(context->committedScene);

    context->workScene = NULL;

    context->snapshotScene = NULL;

    context->committedScene = NULL;    

}

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

 *  Initialize context attributes

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

OWF_API_CALL OWF_ATTRIBUTE_LIST_STATUS

WFC_Context_InitializeAttributes(WFC_CONTEXT* context,

                                 WFCContextType type)

{

    OWF_ATTRIBUTE_LIST_STATUS attribError=ATTR_ERROR_NONE;

    OWF_ASSERT(context);

    /* initialize attributes/properties */

    if (context->stream)

    {

        owfNativeStreamGetHeader(context->stream,

                                 &context->targetWidth,

                                 &context->targetHeight,

                                 NULL, NULL, NULL);

    }

    context->type               = type;

    context->rotation           = WFC_ROTATION_0;

    context->backgroundColor    = 0x000000FF;

    context->lowestElement      = WFC_INVALID_HANDLE;

    OWF_AttributeList_Create(&context->attributes,

                             WFC_CONTEXT_TYPE,

                             WFC_CONTEXT_BG_COLOR);

    attribError=OWF_AttributeList_GetError(&context->attributes);

    if (attribError!=ATTR_ERROR_NONE)

        {

        OWF_ASSERT(attribError==ATTR_ERROR_NO_MEMORY);

        return attribError;

        }

     * not via the attribute engine.

     */

    OWF_Attribute_Initi(&context->attributes,

                        WFC_CONTEXT_TYPE,

                        (WFCint*) &context->type,

                        OWF_TRUE);

    OWF_Attribute_Initi(&context->attributes,

                        WFC_CONTEXT_TARGET_WIDTH,

                        &context->targetWidth,

                        OWF_TRUE);

    OWF_Attribute_Initi(&context->attributes,

                        WFC_CONTEXT_TARGET_HEIGHT,

                        &context->targetHeight,

                        OWF_TRUE);

    OWF_Attribute_Initi(&context->attributes,

                        WFC_CONTEXT_ROTATION,

                        (WFCint*) &context->rotation,

                        OWF_FALSE);

    OWF_Attribute_Initi(&context->attributes,

                        WFC_CONTEXT_BG_COLOR,

                        (WFCint*) &context->backgroundColor,

                        OWF_FALSE);

    OWF_Attribute_Initi(&context->attributes,

                        WFC_CONTEXT_LOWEST_ELEMENT,

                        (OWFint*) &context->lowestElement,

                        OWF_TRUE);

    attribError=OWF_AttributeList_GetError(&context->attributes);

    return attribError;

}

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

 *

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

static WFC_CONTEXT*

WFC_Context_Initialize(WFC_CONTEXT* context,

                       WFC_DEVICE* device,

                       WFCNativeStreamType stream,

                       WFCContextType type,

                       WFCint screenNum)

{

    void*                   scratch[SCRATCH_BUFFER_COUNT];

    OWFint                  err2    = 0;

    OWFint                  ii      = 0,

                            nbufs   = 0;

    OWFint                  fail    = 0;

    OWF_ATTRIBUTE_LIST_STATUS attribStatus = ATTR_ERROR_NONE;

    OWF_ASSERT(context);

    OWF_ASSERT(device);

    DPRINT(("WFC_Context_Initialize(%p,%p,%d,%d)", context, device, type, screenNum));

    context->type               = type;

    context->device             = device;

    context->handle             = nextContextHandle;

    context->screenNumber       = screenNum;

    context->activationState    = WFC_CONTEXT_STATE_PASSIVE;

    context->sourceUpdateCount  = 0;

    context->clientElementCount = 0;

    ++nextContextHandle;

    context->displayContext = OWF_DisplayContext_Create(screenNum);

    if (context->displayContext == NULL)

        {

        DPRINT(("WFC_Context_Initialize(): Could not create display Context"));

        return NULL;

        }

    context->eglPrivateSignalSync = (TFPtrEglPrivateSignalSyncNok) eglGetProcAddress("egl_Private_SignalSyncNOK");

    if (! context->eglPrivateSignalSync)

        {

        DPRINT(("WFC_Context_Initialize(): Missing EGL extension - egl_Private_SignalSyncNOK extension"));   

        return NULL;

        }

     /*the following section of the code could be pushed to adaptation in future*/

    if (type == WFC_CONTEXT_TYPE_ON_SCREEN)

    {

        OWF_IMAGE_FORMAT        imageFormat;

        OWF_SCREEN              screen;

        WFCint width = 0;

        WFCint height = 0;

        WFCint normalSize = 0;

        WFCint flippedSize = 0;

        WFCNativeStreamType stream;

        /* Set up stream for sending data to screen */

        if (!OWF_Screen_GetHeader(screenNum, &screen))

        {

            DPRINT(("WFC_Context_Initialize(): Could not retrieve the screen parameters"));

            return NULL;

        }

        /* Set on-screen pixel format */

        imageFormat.pixelFormat     = OWF_SURFACE_PIXEL_FORMAT;

        imageFormat.premultiplied   = OWF_SURFACE_PREMULTIPLIED;

        imageFormat.linear          = OWF_SURFACE_LINEAR;

        imageFormat.rowPadding      = OWF_SURFACE_ROWPADDING;

        width = screen.normal.width;

        height = screen.normal.height;

        normalSize = screen.normal.height * screen.normal.stride;

        flippedSize = screen.flipped.height * screen.flipped.stride;

        if (flippedSize > normalSize)

            {

            width = screen.flipped.width;

            height = screen.flipped.height;

            }

        stream = owfNativeStreamCreateImageStream(width,

                                                  height,

                                                  &imageFormat,

                                                  1);

        if (stream)

        {

            WFC_Context_SetTargetStream(context, stream);

            /* At this point the stream's refcount is 2 - we must decrement

             * it by one to ensure that the stream is destroyed when the

             * context (that "owns" it) is destroyed.

             */

            owfNativeStreamRemoveReference(stream);

        }

        else

        {

            DPRINT(("WFC_Context_Initialize(): cannot create internal target stream"));

            return NULL;

        }

    }

    else

    {

        WFC_Context_SetTargetStream(context, stream);

    }

    nbufs = SCRATCH_BUFFER_COUNT-1;

    for (ii = 0; ii < nbufs; ii++)

    {

        scratch[ii] = OWF_Image_AllocData(context->displayContext, MAX_SOURCE_WIDTH,

                MAX_SOURCE_HEIGHT,

                OWF_IMAGE_ARGB_INTERNAL);

        fail = fail || (scratch[ii] == NULL);

    }

    /*

     * allocate one-channel buffer for alpha

     * obs! this assumes sizeof(OWFsubpixel) is 4.

     */

    scratch[nbufs] = OWF_Image_AllocData(context->displayContext, MAX_SOURCE_WIDTH,

                                         MAX_SOURCE_HEIGHT,

                                         OWF_IMAGE_L32);

    fail = fail || (scratch[nbufs] == NULL);

    err2 = OWF_MessageQueue_Init(&context->composerQueue);

    fail = fail || (err2 != 0);

    if (fail)

    {

        OWF_MessageQueue_Destroy(&context->composerQueue);

        for (ii = 0; ii < SCRATCH_BUFFER_COUNT; ii++)

        {

            OWF_Image_FreeData(context->displayContext, &scratch[ii]);

        }

        return NULL;

    }

    for (ii = 0; ii < SCRATCH_BUFFER_COUNT; ii++)

    {

        context->scratchBuffer[ii] = scratch[ii];

    }

    if (!WFC_Pipeline_CreateState(context) || !WFC_Context_CreateState(context))

         {

         DPRINT(("WFC_Context_Initialize(): Could not create pipeline state object"));

         return NULL;

         }

    if (    OWF_Semaphore_Init(&context->compositionSemaphore, 1)

        ||  OWF_Semaphore_Init(&context->commitSemaphore, 1)

        ||  OWF_Mutex_Init(&context->updateFlagMutex)

        ||  OWF_Mutex_Init(&context->sceneMutex)

        )

        {

        DPRINT(("WFC_Context_Initialize(): Could not create mutexes and semaphores!"));

        return NULL;

        }

    attribStatus= WFC_Context_InitializeAttributes(context, type);

    if (attribStatus!=ATTR_ERROR_NONE)

        {

        return NULL;

        }

    context->scenePool = OWF_Pool_Create(sizeof(WFC_SCENE),

                                         CONTEXT_SCENE_POOL_SIZE);

    context->elementPool = OWF_Pool_Create(sizeof(WFC_ELEMENT),

                                           CONTEXT_ELEMENT_POOL_SIZE);

    context->nodePool = OWF_Pool_Create(sizeof(OWF_NODE),

                                        CONTEXT_NODE_POOL_SIZE);

    if (!( context->scenePool &&

          context->nodePool && context->elementPool))

    {

        /* must call these to remove references to context */

        context->workScene = NULL;

        context->committedScene = NULL;

        return NULL;

    }

    DPRINT(("  Creating scenes"));

    context->workScene = WFC_Scene_Create(context);

    context->committedScene = WFC_Scene_Create(context);

    context->snapshotScene = NULL;

    /* snapshotScene is initialized in InvokeCommit */

    /* context's refcount is now 3 */

    if (!(context->workScene && context->committedScene &&

          context->nodePool && context->elementPool))

    {

        /* must call these to remove references to context */

        WFC_Scene_Destroy(context->workScene);

        WFC_Scene_Destroy(context->committedScene);

        context->workScene = NULL;