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

 * Portions copyright (c) 2009-2010  Nokia Corporation and/or its subsidiary(-ies)

 *

 * 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

#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->displayContext))

            {   /* 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"));

    if (context->composerThread)

        {

        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;

        }

    /* The composition code reads the member variables directly, 

     * 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);

	/* After commit to working, writable attribute abstracted variables

	must not be written to directly. */

    OWF_AttributeList_Commit(&context->attributes,

                             WFC_CONTEXT_TYPE,

                             WFC_CONTEXT_BG_COLOR,

		             WORKING_ATTR_VALUE_INDEX );

    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;

        }

    err2 =OWF_MessageQueue_Init(&context->composerQueue);

    if (err2 != 0)

        {

        DPRINT(("WFC_Context_Initialize(): Cannot initialise the message queue err(%d)", err2));   

        return NULL;

        }

    context->composerThread = OWF_Thread_Create(WFC_Context_ComposerThread, context);

    if (!(context->composerThread))

        {

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

        DPRINT(("WFC_Context_Initialize(): Failed to create thread!"));

        return NULL;

        }

    OWF_ComposerThread_RendezvousWait(context->displayContext);

    /*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(context->displayContext, &screen))

       {

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

           WFC_Context_Shutdown(context);

           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"));

           WFC_Context_Shutdown(context);

           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);

    if (fail)

    {

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

        {

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

        }

        WFC_Context_Shutdown(context);

        return NULL;

    }

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

    {

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

    }

    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!"));

        WFC_Context_Shutdown(context);

        return NULL;

        }

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

         {

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

         WFC_Context_Shutdown(context);

         return NULL;

         }

    attribStatus= WFC_Context_InitializeAttributes(context, type);

    if (attribStatus!=ATTR_ERROR_NONE)

        {

        WFC_Context_Shutdown(context);

        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))

    {

        WFC_Context_Shutdown(context);

        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))

    {

        WFC_Context_Shutdown(context);

        return NULL;

    }

    return context;

}

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

 *  Create new context on device

 *

 *  \param device Device on which the context should be created

 *  \param type Context type (on- or off-screen)

 *

 *  \return New context object or NULL in case of failure

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

OWF_API_CALL WFC_CONTEXT*

WFC_Context_Create(WFC_DEVICE* device,

                   WFCNativeStreamType stream,

                   WFCContextType type,

                   WFCint screenNum)

{

    WFC_CONTEXT*            context = NULL;

    OWF_ASSERT(device);

    context = CREATE(WFC_CONTEXT);

    if (context)

    {

        if (!WFC_Context_Initialize(context, device, stream, type, screenNum))

        {

            DESTROY(context);

        }

    }

    return context;

}

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

 *  Setup context rendering target

 *

 *  \param context Context

 *  \param stream Target stream to use for rendering

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

OWF_API_CALL void

WFC_Context_SetTargetStream(WFC_CONTEXT* context,

                            OWFNativeStreamType stream)

{

    OWF_ASSERT(context);

    context->stream = stream;

    owfNativeStreamAddReference(stream);

    owfNativeStreamGetHeader(stream,

                             &context->targetWidth, &context->targetHeight,

                             NULL, NULL, NULL);

}

static OWFboolean

WFC_FastpathCheckTransparency(WFCbitfield transparencyTypes, WFCfloat globalAlpha, OWF_PIXEL_FORMAT sourceFormat)

    {

    if ((transparencyTypes & WFC_TRANSPARENCY_ELEMENT_GLOBAL_ALPHA) && (globalAlpha != 255.0f))

        {

        DPRINT(("=== WFC_FastpathCheckTransparency - Failed global alfa(%f) check", globalAlpha));

        return OWF_FALSE;

        }

    if ((transparencyTypes & WFC_TRANSPARENCY_SOURCE) && (sourceFormat != OWF_IMAGE_XRGB8888))

        {

        DPRINT(("=== WFC_FastpathCheckTransparency - Failed transparency check types=0x%x format=0x%x", 

                transparencyTypes, sourceFormat));

        return OWF_FALSE;

        }

    return OWF_TRUE;

    }

static OWFboolean

WFC_FastpathCheckGeometry(WFC_CONTEXT* context, WFC_ELEMENT* element)

    {

    OWFint sourceWidth = 0;

    OWFint sourceHeight = 0;

    OWFint destWidth = 0;

    OWFint destHeight = 0;

    OWFint targetWidth = 0;

    OWFint targetHeight = 0;

    OWF_ASSERT(context);

    OWF_ASSERT(element);

    if ((element->srcRect[0] != 0) || (element->srcRect[1] != 0))

        {

        DPRINT(("=== WFC_FastpathCheckGeometry(context = %p) - FAILED Source Position Check", context));

        return OWF_FALSE;

        }

    if ((element->dstRect[0] != 0) || (element->dstRect[1] != 0))

        {

        DPRINT(("=== WFC_FastpathCheckGeometry(context = %p) - FAILED Destination Position Check", context));

        return OWF_FALSE;

        }

    if(element->sourceFlip)

        {

        DPRINT(("=== WFC_FastpathCheckGeometry(context = %p) - FAILED Source Flip Check", context));

        return OWF_FALSE;

        }

    if(element->sourceRotation == WFC_ROTATION_0)

        {

        sourceWidth = element->srcRect[2];

        sourceHeight = element->srcRect[3];

        }

    else

        {

        DPRINT(("=== WFC_FastpathCheckGeometry(context = %p) - FAILED Source Rotation (0x%x) Check", 

                context, element->sourceRotation));

        return OWF_FALSE;

        }

    destWidth = element->dstRect[2];

    destHeight = element->dstRect[3];

    if ((sourceWidth != destWidth) || (sourceHeight != destHeight))

       {

       DPRINT(("=== WFC_FastpathCheckGeometry(context = %p) - FAILED Non-scaling Check", context));

       return OWF_FALSE;

       }

    if (context->rotation == WFC_ROTATION_0 || OWF_Screen_Rotation_Supported(context->displayContext))

        {

        if (context->rotation == WFC_ROTATION_0 || context->rotation == WFC_ROTATION_180)

            {

            targetWidth = context->targetWidth;

            targetHeight = context->targetHeight;

            }

        else

            {

            targetWidth = context->targetHeight;

            targetHeight = context->targetWidth;

            }

        if (destWidth == targetWidth && destHeight == targetHeight)

            {

            return OWF_TRUE;

            }

        else

            {

            DPRINT(("=== WFC_FastpathCheckGeometry(context = %p) - Failed Dimensions Check", context));

            }

        }

    else

        {

        DPRINT(("=== WFC_FastpathCheckGeometry(context = %p) - Failed Supported Rotations Check", context));

        }

    return OWF_FALSE;

    }

/**

 * Check if the current scene is candidate for fastpath optimisation.

 * Fastpath optimisation means the topmost visible layer will be passed direct to the 

 * lower level for presentation on the display without being composed.

 * There are two questions:

 * - Is the scene itself suitable for fastpathing?

 * - Can the surface selected for fastpathing be presented directly by the display?

 * This function will check the scene (eg reject if the top stream is non-opaque or smaller than the screen)

 *

 * @param context context object containing the scene to be checked.

 **/

/* [Not in doxygen]

 * The first time MOpenWFC_RI_Display_Update::SetTopLayerSurface (or SetLayerSurface) is called 

 * with a different stream handle, it can fail indicating the display cannot accept the stream.

 * The compositor will then have to immediately compose that frame as normal, and should continue

 * to perform normal composition until the scene changes to present a different stream as fastpath candidate.  

 * 

 * There is a middle ground, e.g. can the hardware handle over-sized images, or do scaling or do rotation?

 * SetTopLayerSurface accepts an optional list of imperfect attributes to be checked by the adaptation.

 * By WFC_Context_CheckFastpath only listing the attributes that are considered imperfect,

 * and SetLayerSurface rejecting fastpath for any attribute IDs that it doesn't recognise,

 * safe independent extensibility is assured. 

 */

static void

WFC_Context_CheckFastpath(WFC_CONTEXT* context)

    {

    WFC_ELEMENT* element = NULL;

    OWF_ASSERT(context);

    DPRINT(("WFC_Context_CheckFastpath(context = %p) - Check Fastpath", context));

    if ((context->type != WFC_CONTEXT_TYPE_ON_SCREEN) ||

        OWF_DisplayContext_FastpathChecked(context->displayContext))

        {

        return;

        }

    // Simple case-fast path top most layer

    // More complex case, fast-path top most VISIBLE, OPAQUE layer.

    OWF_DisplayContext_DisableFastpath(context->displayContext);

    OWF_DisplayContext_SetFastpathChecked(context->displayContext);

    // Find top layer

    element = WFC_Scene_TopMostElement(context->committedScene);

    if (element && element->source && element->skipCompose == WFC_FALSE)

        {

        if (element->mask)

            {

            DPRINT(("=== WFC_Context_CheckFastpath(context = %p) - FAILED elemenent includes mask", context));

            return;

            }

        OWF_ASSERT(element->source->lockedStream.image);

        OWF_ASSERT(element->source->streamHandle != OWF_INVALID_HANDLE);

        if (!WFC_FastpathCheckGeometry(context, element))

            {

            return;

            }

        if (!WFC_FastpathCheckTransparency(element->transparencyTypes, 

                                           element->globalAlpha, 

                                           element->source->lockedStream.image->format.pixelFormat))

            {

            return;

            }

        OWF_DisplayContext_EnableFastpath(context->displayContext, element->source->streamHandle);

        DPRINT(("=== WFC_Context_CheckFastpath(context = %p) - Fastpath Enabled", context));

        }

    }

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

 * Checks if the given stream would be valid as an off-screen context target.

 * 

 * Checks that the format can be rendered TO.

 * Also checks that the image size is acceptable (within the scratch buffers).

 * This is called before the context is created so is effectively a "static" context method.

 * 

 *  \param stream Target stream to use for rendering

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

OWF_API_CALL WFCboolean

WFC_Context_IsValidTargetStream(OWFNativeStreamType stream)

{

    OWFint      width,height;

    OWF_IMAGE_FORMAT    format;

    owfNativeStreamGetHeader(stream,

                         &width, &height,

                         NULL, &format, NULL);

    if (width>MAX_SOURCE_WIDTH)

        {

        return WFC_FALSE;

        }

    if (height>MAX_SOURCE_HEIGHT)

        {

        return WFC_FALSE;

        }

    return (WFCboolean)OWF_Image_IsValidDestinationFormat(&format);

}

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

 * Checks that the image size is acceptable (within the scratch buffers).

 * This is called before the source is created.

 * 

 *  \param stream source stream to use for rendering.

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

OWF_API_CALL WFCboolean

WFC_Context_IsValidSourceStream(OWFNativeStreamType stream)

{

    OWFint      width,height;

    owfNativeStreamGetHeader(stream,

                         &width, &height,

                         NULL, NULL, NULL);

    if ((width+2) * (height+2) > MAX_SOURCE_WIDTH * MAX_SOURCE_HEIGHT)

        {

        return WFC_FALSE;

        }

    return WFC_TRUE;

}

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

 *  Find element from current scene

 *

 *  \param context Context object

 *  \param element Element to find

 *

 *  \return Element object or NULL if element hasn't been inserted

 *  into current scene.

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

OWF_API_CALL WFC_ELEMENT*

WFC_Context_FindElement(WFC_CONTEXT* context,

                        WFCElement element)

{

    OWF_ASSERT(context);

    return WFC_Scene_FindElement(context->workScene, element);

}

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

 *  Commit context scene graph changes

 *

 *  \param context Context to commit

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

static void

WFC_Context_DoCommit(WFC_CONTEXT* context)

{

    OWF_ASSERT(context);

    DPRINT(("WFC_Context_DoCommit(context = %p)", context));

    OWF_ASSERT(context->snapshotScene);

    DPRINT(("COMMIT: Committing attribute list changes"));

    DPRINT(("COMMIT: Acquiring mutex"));

    OWF_Mutex_Lock(&context->sceneMutex);

    /* comitting scene attribute changes */

    DPRINT(("COMMIT: Committing scene attribute changes"));

    OWF_AttributeList_Commit(&context->attributes,

                             WFC_CONTEXT_TYPE,

                             WFC_CONTEXT_BG_COLOR,COMMITTED_ATTR_VALUE_INDEX);

    /* resolve sources and masks */

    DPRINT(("COMMIT: Committing scene changes"));

    WFC_Scene_Commit(context->snapshotScene);

    DPRINT(("COMMIT: Destroying old committed scene"));

    WFC_Scene_Destroy(context->committedScene);

    DPRINT(("COMMIT: Setting new snapshot scene as committed one."));

    context->committedScene = context->snapshotScene;

    context->snapshotScene = NULL;

    // reset the visibility flags

    owfSymDeviceResetVisibilityState(context);

    DPRINT(("COMMIT: Unlocking mutex"));

    OWF_Mutex_Unlock(&context->sceneMutex);

    DPRINT(("COMMIT: Signaling commit semaphore"));

    /* signal we're ready */

    OWF_Semaphore_Post(&context->commitSemaphore);

}

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

 *

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

static OWFboolean

WFC_Context_LockTargetForWriting(WFC_CONTEXT* context)

{

    OWF_ASSERT(context);

    DPRINT(("WFC_Context_LockTargetForWriting"));

    context->state.targetBuffer =

        owfNativeStreamAcquireWriteBuffer(context->stream);

    if (!context->state.targetBuffer)

        {

        DPRINT(("Failed to WFC_Context_LockTargetForWriting owfNativeStreamAcquireWriteBuffer"));

        return OWF_FALSE;

        }

    context->state.targetPixels =

        owfNativeStreamGetBufferPtr(context->stream,

                                    context->state.targetBuffer);

    if ((WFC_ROTATION_0   == context->rotation || WFC_ROTATION_180 == context->rotation) ||

        !OWF_Screen_Rotation_Supported(context->displayContext))

    {

        /* final target, in target format */

        context->state.targetImage =context->state.unrotatedTargetImage;

    }

    else

    {

        /* final target, in target format */

        /* fExt stride/padding value is the rotated value */

        context->state.targetImage = context->state.rotatedTargetImage;

    }

    OWF_Image_SetPixelBuffer(context->state.targetImage,context->state.targetPixels);

    if (context->state.targetImage==NULL)

        {

        OWF_ASSERT(WFC_FALSE);

        }

    /* take context rotation into account. */

    if (WFC_ROTATION_0   == context->rotation ||

        WFC_ROTATION_180 == context->rotation)

    {

        context->state.internalTargetImage = context->state.unrotatedInternalTargetImage;

    }

    else

    {

        context->state.internalTargetImage = context->state.rotatedInternalTargetImage;

    }

    if (context->state.internalTargetImage==NULL)

        {

        OWF_ASSERT(WFC_FALSE);

        }

    return OWF_TRUE;

}

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

 *

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

static void

WFC_Context_UnlockTarget(WFC_CONTEXT* context,OWFboolean aDoPost)

{

    OWF_ROTATION rotation = OWF_ROTATION_0;

    OWF_ASSERT(context);

    DPRINT(("WFC_Context_UnlockTarget"));

    DPRINT(("  Unlocking target stream=%d, buffer=%d",

            context->stream, context->state.targetBuffer));

    owfNativeStreamReleaseWriteBuffer(context->stream,

                                      context->state.targetBuffer,

                                      EGL_NO_DISPLAY,

                                      NULL);

    if (aDoPost)

    {

        switch (context->rotation)

        {

            case WFC_ROTATION_0:

            {

                rotation = OWF_ROTATION_0;

                break;

            }

            case WFC_ROTATION_90:

            {

                rotation = OWF_ROTATION_90;

                break;

            }

            case WFC_ROTATION_180:

            {

                rotation = OWF_ROTATION_180;

                break;

            }

            case WFC_ROTATION_270:

            {

                rotation = OWF_ROTATION_270;

                break;

            }

            default:

            {

                OWF_ASSERT(0);

            }

        }