// 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:

// 

#include <stdio.h>

#include <stdlib.h>

#include <EGL/egl.h>//EGL operations will be called a lot from here

#include <vg/openvg.h>

#include "driverapiwrapper.h"

#include "KhronosAPIWrapper.h"

bool DriverAPIWrapper::IsSgBackingVGImage( VGImage aImage )

	{

		for( std::list<VGImage>::iterator cur = m_SgImageVGImages.begin();

			 cur != m_SgImageVGImages.end();

			 ++cur )

		{

			if( (*cur) == aImage )

			{

				return true;

			}

		}

		return false;

	}

bool DriverAPIWrapper::IsSgBackingPBuffer( EGLSurface aSurface )

	{

		for( std::list<EGLSurface>::iterator cur = m_SgImagePbuffers.begin();

			 cur != m_SgImagePbuffers.end();

			 ++cur )

		{

			if( (*cur) == aSurface )

			{

				return true;

			}

		}

		return false;

	}

int DriverAPIWrapper::CreatePoolContext()

	{

	//Initialize EGL on the first run, as per 5.1 in the "Implementing SgImage" design doc

	if( m_initialized ){ return 0; }

	TRACE("DriverAPIWrapper::CreatePoolContext() ->\n");

    EGLDisplay display(0);

    EGLConfig config(0);

	EGLint num_config;

	EGLContext PoolContext(0);//for sharing

    EGLContext ContextWithFormatARGB_8888_PRE(0);//for sharing

    EGLContext ContextWithFormatARGB_8888(0);

    EGLContext ContextWithFormatXRGB_8888(0);

    EGLContext ContextWithFormatRGB_565(0);

    EGLContext ContextWithFormatA_8(0);

    EGLSurface DudSurface(0);

	int red(0);

	int green(0);

	int blue(0);

	int alpha(0);

	display = ::eglGetDisplay( EGL_DEFAULT_DISPLAY );//Notice: there is no support for multiple displays here

	if( !::eglInitialize(display, NULL, NULL) )

	{

		TRACE("DriverAPIWrapper::CreatePoolContext() <- (eglInitialize failed)\n");

		return 0;

	}

	m_Dpy = display;

	//Pool Context

    //get a Configuration, then get the context

	if( ::eglChooseConfig(	display,

							getColorAttributes( EUidPixelFormatARGB_8888, red, green, blue, alpha ),

							&config,

							1,

							&num_config ) == EGL_TRUE )

	{

		/* create an EGL rendering context */

		PoolContext = ContextWithFormatARGB_8888 = eglCreateContext(display, config, EGL_NO_CONTEXT, NULL);

		m_PoolConfig = config;

	}

    /* get an appropriate EGL surface buffer configuration */

	if( ::eglChooseConfig(	display,

							getColorAttributes( EUidPixelFormatXRGB_8888, red, green, blue, alpha ),

							&config,

							1,

							&num_config ) == EGL_TRUE )

	{

		/* create an EGL rendering context */

		PoolContext = ContextWithFormatXRGB_8888 = eglCreateContext(display, config, EGL_NO_CONTEXT, NULL);

	}

    //get a Configuration, then get the context

	if( ::eglChooseConfig(	display,

							getColorAttributes( EUidPixelFormatARGB_8888_PRE, red, green, blue, alpha ),

							&config,

							1,

							&num_config ) == EGL_TRUE )

	{

		/* create an EGL rendering context */

		ContextWithFormatARGB_8888_PRE = eglCreateContext(display, config, EGL_NO_CONTEXT, NULL);

	}

    //get a Configuration, then get the context

	if( ::eglChooseConfig(	display,

							getColorAttributes( EUidPixelFormatRGB_565, red, green, blue, alpha ),

							&config,

							1,

							&num_config ) == EGL_TRUE )

	{

		/* create an EGL rendering context */

		ContextWithFormatRGB_565 = eglCreateContext(display, config, EGL_NO_CONTEXT, NULL);

	}

    //get a Configuration, then get the context

	if( ::eglChooseConfig(	display,

							getColorAttributes( EUidPixelFormatA_8, red, green, blue, alpha ),

							&config,

							1,

							&num_config ) == EGL_TRUE )

	{

		/* create an EGL rendering context */

		ContextWithFormatA_8 = eglCreateContext(display, config, EGL_NO_CONTEXT, NULL);

	}

	EGLint attribs[] = { EGL_NONE };

	DudSurface = ::eglCreatePbufferSurface( display, PoolContext, attribs );

	TRACE( "PoolContext = %u\n", PoolContext );

	TRACE( "ContextWithFormatARGB_8888_PRE = %u\n", ContextWithFormatARGB_8888_PRE );

	TRACE( "ContextWithFormatARGB_8888 = %u\n", ContextWithFormatARGB_8888 );

	TRACE( "ContextWithFormatXRGB_8888 = %u\n", ContextWithFormatXRGB_8888 );

	TRACE( "ContextWithFormatRGB_565 = %u\n", ContextWithFormatRGB_565 );

	TRACE( "ContextWithFormatA_8 = %u\n", ContextWithFormatA_8 );

	TRACE( "DummySurface = %u\n", DudSurface );

	m_Dpy								= display;

	m_PoolContext						= PoolContext;

    m_ContextWithFormatARGB_8888_PRE	= ContextWithFormatARGB_8888_PRE;

    m_ContextWithFormatARGB_8888		= ContextWithFormatARGB_8888;

    m_ContextWithFormatXRGB_8888		= ContextWithFormatXRGB_8888;

    m_ContextWithFormatRGB_565			= ContextWithFormatRGB_565;

    m_ContextWithFormatA_8				= ContextWithFormatA_8;

    m_DudSurface						= DudSurface;

	//m_currentFunctionCall.AppendEGLContext( PoolContext );//for sharing

    //m_currentFunctionCall.AppendEGLContext( ContextWithFormatARGB_8888_PRE );//for sharing

    //m_currentFunctionCall.AppendEGLContext( ContextWithFormatARGB_8888 );

    //m_currentFunctionCall.AppendEGLContext( ContextWithFormatXRGB_8888 );

    //m_currentFunctionCall.AppendEGLContext( ContextWithFormatRGB_565 );

    //m_currentFunctionCall.AppendEGLContext( ContextWithFormatA_8 );

	//m_currentFunctionCall.AppendEGLSurface( DudSurface );

	TRACE("DriverAPIWrapper::CreatePoolContext() <-\n");

	m_initialized = true;

	return 1;

	}

/**

* This code is supposed to create a pbuffer to back an sgImage

* TODO: not tested at all

*/

int DriverAPIWrapper::CreatePbufferSg(  )

	{

	TRACE("DriverAPIWrapper::CreatePbufferSg ->\n");

	EGLint w;

	EGLint h;

	if( !m_initialized )

		{

		CreatePoolContext();

		}

	m_currentFunctionCall.GetEGLint( w, 0 );

	m_currentFunctionCall.GetEGLint( h, 1 );

	//eglCreatePbufferSurface

	EGLint pbuffer_surface_attribs[] =

	{

      EGL_WIDTH,    w,

	  EGL_HEIGHT,   h,

      EGL_NONE

	};

    EGLSurface surface = ::eglCreatePbufferSurface( m_Dpy, m_PoolConfig, pbuffer_surface_attribs );

	if( surface != EGL_NO_SURFACE )

	{

		m_SgImagePbuffers.push_back( surface );

	}

	TRACE("DriverAPIWrapper::CreatePbufferSg surface=%u \n", surface );

    m_currentFunctionCall.SetReturnValue( (TUint32)surface );

    TRACE("DriverAPIWrapper::CreatePbufferSg <-\n");

    return WriteReply();

	}

/**

* This code is supposed to create a pbuffer to back an sgImage

* TODO: not tested at all

*/

int DriverAPIWrapper::CreateVGImageSg(  )

	{

	TRACE("DriverAPIWrapper::CreateVGImageSg ->\n");

	EGLint w;

	EGLint h;

	EGLint pixelformat;

	VGImage img;

	if( !m_initialized )

	{

		CreatePoolContext();

	}

	EGLenum previousApi = ::eglQueryAPI();

	::eglBindAPI( EGL_OPENVG_API );

	m_currentFunctionCall.GetEGLint( w, 0 );

	m_currentFunctionCall.GetEGLint( h, 1 );

	m_currentFunctionCall.GetEGLint( pixelformat, 2 );

	::eglMakeCurrent( m_Dpy, m_DudSurface, m_DudSurface, m_PoolContext );

	//eglCreatePbufferSurface

	EGLint pbuffer_surface_attribs[] =

	{

      EGL_WIDTH,    w,

	  EGL_HEIGHT,   h,

      EGL_NONE

	};

	VGImageFormat format = getVGColorFormat( pixelformat );

	img = ::vgCreateImage(format, w, h, VG_IMAGE_QUALITY_NONANTIALIASED);//todo: quality; how to decide (TSgImageInfo only provides w,h, pixelformat)?

		if( img != VG_INVALID_HANDLE )

	{

		m_SgImageVGImages.push_back( img );

	}

    m_currentFunctionCall.SetReturnValue( (TUint32)img );

	::eglBindAPI( previousApi );

    TRACE("DriverAPIWrapper::CreateVGImageSg <-\n");

    return WriteReply();

	}

int DriverAPIWrapper::DeleteSgImage()

{

	EGLSurface surface;

	VGImage image;

	m_currentFunctionCall.GetEGLSurface( surface, 0 );

	m_currentFunctionCall.GetVGParamValue( image, 1 );

	eglDestroySurface( m_Dpy, surface );

	vgDestroyImage( image );

	return WriteReply();

}

void DriverAPIWrapper::SyncVGImageFromPBuffer( EGLSurface aPbuffer, VGImage aVGImage )

{

	TRACE("DriverAPIWrapper::SyncVGImageFromPBuffer ->\n");

	//Store the previous current

	EGLDisplay disp = ::eglGetCurrentDisplay();

	EGLSurface draw = ::eglGetCurrentSurface( EGL_DRAW );

	EGLSurface read = ::eglGetCurrentSurface( EGL_READ );

	EGLContext ctx  = ::eglGetCurrentContext();

	EGLint width(0);

	EGLint height(0);

	eglSurfaceAttrib( disp, aPbuffer, EGL_WIDTH, width );

	eglSurfaceAttrib( disp, aPbuffer, EGL_HEIGHT, height );

	::eglMakeCurrent( m_Dpy, aPbuffer, aPbuffer, m_PoolContext );

	::vgGetPixels( aVGImage, 0, 0, 0, 0, width, height );

	//Set the previous current

	::eglMakeCurrent( disp, draw, read, ctx );

	TRACE("DriverAPIWrapper::SyncVGImageFromPBuffer <-\n");

}

int DriverAPIWrapper::SyncPBufferFromVGImage( VGImage aSrc, VGint aWidth, VGint aHeight )

{

	TRACE("DriverAPIWrapper::SyncPBufferFromVGImage ->\n");

	if( ((VGboolean)vgGeti( VG_SCISSORING )) == VG_TRUE )

	{

		::vgSeti( VG_SCISSORING, VG_FALSE );

		//The surface is the same size, as the vgimage

		::vgSetPixels( 0, 0, aSrc, 0, 0, aWidth, aHeight );

		::vgSeti( VG_SCISSORING, VG_TRUE );

	}

	else

	{

		::vgSetPixels( 0, 0, aSrc, 0, 0, aWidth, aHeight );

	}

	TRACE("DriverAPIWrapper::SyncPBufferFromVGImage <-\n");

	return 0;

}

VGImageFormat DriverAPIWrapper::getVGColorFormat( int aPixelFormat )

{

	switch( aPixelFormat )

		{

		case  EUidPixelFormatXRGB_8888:

			{

			return VG_sXRGB_8888;

			}

		case EUidPixelFormatARGB_8888:

			{

			return VG_sARGB_8888;

			}

		case EUidPixelFormatARGB_8888_PRE:

			{

			return VG_sARGB_8888_PRE;

			}

		case EUidPixelFormatRGB_565:

			{

			return VG_sRGB_565;

			}

		case EUidPixelFormatA_8:

			{

			return VG_A_8;

			}

		default:

			{

			return VG_sARGB_8888;

			}

		}

}

EGLint* DriverAPIWrapper::getColorAttributes( int aPixelFormat, int& aRed, int& aGreen, int& aBlue, int& aAlpha )

	{

	switch( aPixelFormat )

		{

		case  EUidPixelFormatXRGB_8888:

			{

			aRed = aGreen = aBlue = aAlpha = 8;

			break;

			}

		case EUidPixelFormatARGB_8888:

			{

			aRed = aGreen = aBlue = aAlpha = 8;

			break;

			}

		case EUidPixelFormatARGB_8888_PRE:

			{

			aRed = aGreen = aBlue = aAlpha = 8;

			break;

			}

		case EUidPixelFormatRGB_565:

			{

			aRed = 5; aGreen = 6; aBlue = 5; aAlpha = 0;

			break;

			}

		case EUidPixelFormatA_8:

			{

			aRed = aGreen = aBlue = 0; aAlpha = 8;

			break;

			}

		default:

			{

			aRed = aGreen = aBlue = aAlpha = 0;

			break;

			}

		}

		static EGLint attribs[] =

		{

		  EGL_RED_SIZE,   aRed,

		  EGL_GREEN_SIZE, aGreen,

		  EGL_BLUE_SIZE,  aBlue,

		  EGL_ALPHA_SIZE, aAlpha,

	      EGL_RENDERABLE_TYPE, EGL_OPENVG_BIT,

		  EGL_SURFACE_TYPE,   EGL_PBUFFER_BIT,

		  EGL_NONE

		};

	return attribs;

	}