// Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// 

#ifdef WIN32

#define WIN32_LEAN_AND_MEAN                       // Exclude rarely-used stuff from Windows headers

#include <windows.h>

#endif

#include <stdio.h>

#include <stdlib.h>

#include <EGL/egl.h>

#include <vg/openvg.h>

#include "GLES/gl.h"

#include "KhronosAPIWrapper.h"

#include "serializedfunctioncall.h"

#include "remotefunctioncall.h"

#include "openvgrfc.h"

#include "eglrfc.h"

#include "driverrfc.h"

#include "apiwrapper.h"

#include "driverapiwrapper.h"

#include "eglapiwrapper.h"

#include "openvgapiwrapper.h"

#include "opengles11apiwrapper.h"

#include "graphicsvhwcallback.h"        //callback interface Wrapper=>Virtual HW

#include "platformthreading.h"

#include "serialisedapiuids.h"

#include "khronosapiwrapperdefs.h"

Psu::PLATFORM_THREADFUNC_RETTYPE WINAPI WorkerThreadFunction(void* aParam)

{

    TRACE("KhronosAPIWrapper WorkerThreadFunction ->\n");

    KhronosAPIWrapper* impl=(KhronosAPIWrapper*) aParam;

    impl->WorkerThread();

    TRACE("KhronosAPIWrapper WorkerThreadFunction <-\n");

    return 0;

}

int KhronosAPIWrapper::HandleNextRequest()

{

    TRACE("KhronosAPIWrapper::HandleNextRequest() ->\n");

    int ret(0);

    uint32_t inputBufferTail = m_InputRequestBuffer->GetReadIndex();

	RemoteFunctionCallData& rfc( *iRFCData );

    SerializedFunctionCall remotefcall(rfc);

    TRACE("KhronosAPIWrapper::HandleNextRequest ParseBuffer from %u\n",  inputBufferTail);

    TInt len = remotefcall.ParseBuffer( ((TUint8*)(m_currentInput))+inputBufferTail,

        VVI_PARAMETERS_INPUT_MEMORY_SIZE - inputBufferTail );

    ASSERT( len != -1 );

    m_InputRequestBuffer->FreeBytes( len );

    //TRACE("KhronosAPIWrapper::WorkerThread DispatchRequest -> %u\n",  m_currentFunctionCall.Data().Header().iTransactionId);

	TRACE("KhronosAPIWrapper::HandleNextRequest DispatchRequest opCode -> %u / retval initially:%d\n",  rfc.Header().iOpCode, rfc.Header().iReturnValue );

    const TUint32 processId(rfc.Header().iProcessId);

    const TUint32 threadId(rfc.Header().iThreadId);

	if ( processId != m_lastProcessId || threadId != m_lastThreadId )

		{

		m_lastProcessId = processId;

		m_lastThreadId = threadId;

		TRACE("KhronosAPIWrapper::HandleNextRequest Set process info for %u / %u \n", processId, threadId );

		m_EGLWrapper->SetProcessInformation( processId, threadId );

		}

	switch ( rfc.Header().iApiUid )

		{

		case SERIALISED_DRIVER_API_UID:

			{

			TRACE("KhronosAPIWrapper::HandleNextRequest SERIALISED_DRIVER_API_UID \n" );

			if ( DriverRFC::EDrvClientShutdown == rfc.Header().iOpCode )

				{

				m_OpenVGWrapper->Cleanup( processId, threadId );

				m_EGLWrapper->Cleanup( processId, threadId );

				m_OGLESWrapper->Cleanup( processId, threadId );

				}

			else

				{

				m_DriverAPIWrapper->DispatchRequest( rfc.Header().iOpCode );

				}

			break;

			}

		case SERIALISED_OPENVG_API_UID:

			{

			ret = m_OpenVGWrapper->DispatchRequest( rfc.Header().iOpCode );

			break;

			}

		case SERIALISED_EGL_API_UID:

			{

			ret = m_EGLWrapper->DispatchRequest( rfc.Header().iOpCode );

			break;

			}

		case SERIALISED_OPENGLES_1_1_API_UID:

			{

			m_OGLESWrapper->SetProcessInformation( processId, threadId );

			ret = m_OGLESWrapper->DispatchRequest( rfc.Header().iOpCode );

			break;

			}

		default:

			break;

		}

    TRACE("KhronosAPIWrapper::HandleNextRequest DispatchRequest <-\n");

	if ( RemoteFunctionCallData::EOpReply ==  rfc.Header().iOpType )

    {

        TRACE("KhronosAPIWrapper::HandleNextRequest ProsessingDone ->\n");

        iServiceIf->ProcessingDone( rfc.Header().iTransactionId );

        TRACE("KhronosAPIWrapper::HandleNextRequest ProsessingDone <-\n");

    }

    else if ( !m_InputRequestBuffer->IsDataAvailable() )

    {

        iServiceIf->LockOutputBuffer(); //We need to use the lock buffer so that the request id register is protected

        iServiceIf->ProcessingDone( 0 ); //Signal driver that buffer is empty

    }

    TRACE("ret = %d\n", ret);

    TRACE("KhronosAPIWrapper::HandleNextRequest() <-\n");

    return ret;

}

void KhronosAPIWrapper::WorkerThread()

{

    TRACE("KhronosAPIWrapper::WorkerThread ->\n");

    while(1)

    {

        int ret;

        while ( !m_exit && !m_InputRequestBuffer->IsDataAvailable() )

        {

            TRACE("KhronosAPIWrapper::WorkerThread Waiting\n");

			//No more data, wait for some more

            Psu::platform_wait_for_signal(m_SemapHandle);

            TRACE("KhronosAPIWrapper::WorkerThread Signaled\n");

        }

        TRACE("KhronosAPIWrapper::WorkerThread Process request\n");

        if ( m_exit )

        {

            TRACE("KhronosAPIWrapper::WorkerThread m_exit\n");

            return;

        }

        ret = HandleNextRequest();

        TRACE("KhronosAPIWrapper::WorkerThread <-\n");

    }

}

TUint32 KhronosAPIWrapper::GetWriteCount()

{

    TRACE("KhronosAPIWrapper::GetWriteCount()\n");

    return InputBufferWriteCount();

}

void KhronosAPIWrapper::IncrementReadCount( TUint32 aReadCount )

{

    TRACE("KhronosAPIWrapper::IncrementReadCount()\n");

    IncrementInputBufferReadCount( aReadCount );

}

TUint32 KhronosAPIWrapper::GetReadCount()

{

    TRACE("KhronosAPIWrapper::GetReadCount()\n");

    return InputBufferReadCount();

}

TUint32 KhronosAPIWrapper::BufferTail()

{

    TRACE("KhronosAPIWrapper::BufferTail()\n");

    return InputBufferTail();

}

void KhronosAPIWrapper::SetBufferTail( TUint32 aIndex )

{

    TRACE("KhronosAPIWrapper::SetBufferTail()\n");

    SetInputBufferTail( aIndex );

}

TUint32 KhronosAPIWrapper::BufferHead()

{

    TRACE("KhronosAPIWrapper::BufferHead()\n");

    return InputBufferHead();

}

TUint32 KhronosAPIWrapper::MaxTailIndex()

{

    TRACE("KhronosAPIWrapper::MaxTailIndex()\n");

    return InputMaxTailIndex();

}

void KhronosAPIWrapper::SetMaxTailIndex( TUint32 aIndex )

{

    TRACE("KhronosAPIWrapper::SetMaxTailIndex()\n");

    SetInputMaxTailIndex( aIndex );

}

TUint32 KhronosAPIWrapper::InputMaxTailIndex()

{

    TRACE("KhronosAPIWrapper::InputMaxTailIndex()\n");

    TUint32 ret = m_InputBufferMaxTailIndex;

    return ret;

}

void KhronosAPIWrapper::SetInputMaxTailIndex( TUint32 aIndex )

{

    TRACE("KhronosAPIWrapper::SetInputMaxTailIndex aIndex %u\n", aIndex );

    m_InputBufferMaxTailIndex = aIndex;

}

void KhronosAPIWrapper::SetInputBufferTail(uint32_t p_val)

{

    TRACE("KhronosAPIWrapper::SetInputBufferTail aIndex %u\n", p_val );

    m_InputBufferTail = p_val;

}

uint32_t KhronosAPIWrapper::InputBufferTail()

{

    uint32_t val = m_InputBufferTail;

    TRACE("KhronosAPIWrapper::InputBufferTail %u\n", val );

    return val;

}

void KhronosAPIWrapper::SetInputBufferHead(uint32_t p_val)

{

    TRACE("KhronosAPIWrapper::SetInputBufferHead aIndex %u\n", p_val );

    m_InputBufferHead = p_val;

}

uint32_t KhronosAPIWrapper::InputBufferHead()

{

    uint32_t val = m_InputBufferHead;

    TRACE("KhronosAPIWrapper::InputBufferHead %u\n", val );

    return val;

}

void KhronosAPIWrapper::SetInputBufferReadCount(uint32_t p_val)

{

    TRACE("KhronosAPIWrapper::SetInputBufferReadCount aIndex %u\n", p_val );

    m_InputBufferReadCount = p_val;

}

void KhronosAPIWrapper::IncrementInputBufferReadCount( TUint32 aReadCount )

{

    TRACE("KhronosAPIWrapper::IncrementInputBufferReadCount m_InputBufferReadCount++ %u\n", m_InputBufferReadCount );

    m_InputBufferReadCount += aReadCount;

}

uint32_t KhronosAPIWrapper::InputBufferReadCount()

{

    uint32_t val = m_InputBufferReadCount;

    TRACE("KhronosAPIWrapper::InputBufferReadCount %u\n", val );

    return val;

}

void KhronosAPIWrapper::SetInputBufferWriteCount(uint32_t p_val)

{

    TRACE("KhronosAPIWrapper::SetInputBufferWriteCount	%u\n", p_val );

    m_InputbufferWriteCount = p_val;

}

uint32_t KhronosAPIWrapper::InputBufferWriteCount()

{

    uint32_t val = m_InputbufferWriteCount;

    TRACE("KhronosAPIWrapper::InputBufferWriteCount %u\n", val );

    return val;

}

void KhronosAPIWrapper::Construct( MGraphicsVHWCallback* aServiceIf, void* surfacebuffer, void* inputdata, void* outputdata )

{

    TRACE("KhronosAPIWrapper::Construct()\n");

	m_lastVgError = VG_NO_ERROR;

	m_lastEglError = EGL_SUCCESS;

	m_lastProcessId = 0;

	m_lastThreadId = 0;

    m_currentInput = inputdata;

    m_currentResult = outputdata;

    m_surfaceBuffer = surfacebuffer;

    m_exit = false;

    iServiceIf = aServiceIf;

    m_initDone = false;

	iRFCData = new RemoteFunctionCallData;

    m_InputRequestBuffer = new RequestBufferReader( *this, VVI_PARAMETERS_INPUT_MEMORY_SIZE );

	Psu::platform_create_semaphore(m_SemapHandle, 0, 1000000);

    Psu::platform_mutex_init( &m_InputBufferMutex );

    m_InputBufferTail = 0;

    m_InputBufferHead = 0;

    m_InputBufferReadCount = 0;

    m_InputbufferWriteCount = 0;

    iStack = new APIWrapperStack();

    iStack->InitStack( KMaxStackSize );

	m_OpenVGWrapper = new OpenVGAPIWrapper( *iRFCData, iStack, m_currentResult, iServiceIf, this );

	m_OGLESWrapper = new OGLES11Wrapper(*iRFCData, iStack, m_currentResult, iServiceIf);

	m_EGLWrapper = new EGLAPIWrapper( *iRFCData, iStack, m_currentResult, iServiceIf, m_surfaceBuffer, this );

	m_DriverAPIWrapper = new DriverAPIWrapper( *iRFCData, iStack, m_currentResult, iServiceIf, this );

#ifdef KHRONOS_API_W_MULTITHREAD

    int result = Psu::platform_create_simple_thread(&m_threadHandle,

        &WorkerThreadFunction, this);

    if (result)

    {

//Error

    }

#endif

}

KhronosAPIWrapper::KhronosAPIWrapper( MGraphicsVHWCallback* aServiceIf, void* surfacebuffer, void* inputdata, void* outputdata )

{

    Construct( aServiceIf, surfacebuffer, inputdata, outputdata );

}

KhronosAPIWrapper::KhronosAPIWrapper( protocol_MGraphicsVHWCallback* aServiceIf, void* surfacebuffer, void* inputdata, void* outputdata )

{

    Construct( (MGraphicsVHWCallback*)aServiceIf, surfacebuffer, inputdata, outputdata );

}

KhronosAPIWrapper::~KhronosAPIWrapper()

{

    TRACE("KhronosAPIWrapper::~KhronosAPIWrapper\n");

    m_exit = true;

    Psu::platform_signal_semaphore(m_SemapHandle);

    Psu::platform_join_thread(m_threadHandle);

    Psu::platform_release_semaphore(m_SemapHandle);

    Psu::platform_mutex_destroy( &m_InputBufferMutex );

    delete iStack; iStack = NULL;

	delete m_InputRequestBuffer; m_InputRequestBuffer = NULL;

	delete m_OpenVGWrapper; m_OpenVGWrapper = NULL;

	delete m_EGLWrapper; m_EGLWrapper = NULL;

	delete m_DriverAPIWrapper; m_DriverAPIWrapper = NULL;

	delete m_OGLESWrapper; m_OGLESWrapper = NULL;

	delete iRFCData; iRFCData = NULL;

}

unsigned long KhronosAPIWrapper::InputParameterOffset()

{

    TRACE("KhronosAPIWrapper::InputParameterOffset()\n");

    return 0;

}

unsigned long KhronosAPIWrapper::Execute()

{

    TRACE("KhronosAPIWrapper::Execute\n");

    TInt ret(0);

#ifdef KHRONOS_API_W_MULTITHREAD

    Psu::platform_signal_semaphore(m_SemapHandle);

#else

    while ( m_InputRequestBuffer->IsDataAvailable() )

    {

        HandleNextRequest();

    }

#endif

    return ret;

}

#ifdef WIN32

BOOL APIENTRY DllMain( HMODULE hModule,

DWORD  ul_reason_for_call,

LPVOID lpReserved

)

{

    switch (ul_reason_for_call)

    {

        case DLL_PROCESS_ATTACH:

        case DLL_THREAD_ATTACH:

        case DLL_THREAD_DETACH:

        case DLL_PROCESS_DETACH:

            break;

    }

    return true;

}

#endif