/* Copyright (c) 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.

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description:

 *

 */

#include "EGLExtension.h"

#include "EGLState.h"

#include "EGLImage.h"

#include "EGLContext.h"

#include "EGLDisplay.h"

#include "eglInternal.h"

#include "EGLProcess.h"

#include "EGLThread.h"

#include "EGLOs.h"

#include "ImageTarget.h"

#include <string.h>

typedef struct

	{

	const char*      extnName;		// procedure or extension name

	ProcPointer      procAddr;      // address

	} TExtnInfo;

static const TExtnInfo eglProcedures[] =

    { // list of EGL extension name strings, followed by any EGLI_NEW function names

        {"eglCreateImageKHR", (ProcPointer)eglCreateImageKHR},

        {"eglDestroyImageKHR", (ProcPointer)eglDestroyImageKHR}

    };

const EGLint KEglProcCount = sizeof(eglProcedures) / sizeof(TExtnInfo); 

CEGLExtension::CEGLExtension()

    {

    }

CEGLExtension::~CEGLExtension(void)

    {

    }

ProcPointer CEGLExtension::eglGetProcAddress(const char* aProcname)

    {

    EGLint nameLength =  strlen(aProcname);

	if ((nameLength > 3) && !strncmp(aProcname, "egl", 3))

		{ // EGL extensions - exhaustive search 

		for (EGLint idx = 0; idx < KEglProcCount; idx++)

			{

			if ( strcmp( aProcname, eglProcedures[idx].extnName ) == 0 )

				return eglProcedures[idx].procAddr;

			}

		}	

	return NULL;

    }

static EImageTarget mapImageTarget( EGLenum target )

	{

	switch(target)

		{

		case EGL_GL_TEXTURE_2D_KHR:

			return IMAGE_TARGET_TEXTURE_2D;

		case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR:

			return IMAGE_TARGET_TEXTURE_CUBE_MAP_POSITIVE_X;

        case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR:

			return IMAGE_TARGET_TEXTURE_CUBE_MAP_NEGATIVE_X;

        case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR:

			return IMAGE_TARGET_TEXTURE_CUBE_MAP_POSITIVE_Y;

        case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR:

			return IMAGE_TARGET_TEXTURE_CUBE_MAP_NEGATIVE_Y;

        case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR:

			return IMAGE_TARGET_TEXTURE_CUBE_MAP_POSITIVE_Z;

        case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR:

			return IMAGE_TARGET_TEXTURE_CUBE_MAP_NEGATIVE_Z;

		case EGL_GL_RENDERBUFFER_KHR:

			return IMAGE_TARGET_RENDERBUFFER;

		default:

			EGLI_ASSERT(false);

		}

	// Not reached.

	return (EImageTarget)-1;

	}

EGLAPI EGLImageKHR EGLAPIENTRY eglCreateImageKHR( EGLDisplay dpy,

												  EGLContext ctx,

												  EGLenum target,

												  EGLClientBuffer buffer,

												  const EGLint *attrib_list )

    {

    EGLI_ENTER_RET( EGL_NO_IMAGE_KHR );

    CEGLImage *image = NULL;

    CEGLDisplay *display = NULL;

    CEGLContext *context = NULL;

    display = state->GetDisplay( dpy );

    // Check display

    //<dpy> must be a valid EGLDisplay

    if( !display )

       {                   

       EGLI_LEAVE_RET( EGL_NO_IMAGE_KHR, EGL_BAD_DISPLAY );

       }

    context = display->GetContext( ctx ); 

    // Check context

    //<ctx> must be a valid OpenVG API context on that display

    if( !context )

       {                    

       EGLI_LEAVE_RET( EGL_NO_IMAGE_KHR, EGL_BAD_CONTEXT );

       }

    // Display and context ok, continue...

    switch( target )

        {

        case EGL_NATIVE_PIXMAP_KHR:

            {

            // Not supported

            // 1) set error code to EGL_BAD_PARAMETER

            // 2) release lock

            // 3) return no image

            EGLI_LEAVE_RET( EGL_NO_IMAGE_KHR, EGL_BAD_PARAMETER );

            break;

            }

        case EGL_VG_PARENT_IMAGE_KHR:

            {            

            // Context must be client context and api must be openVG

            if( context->ClientContext() && EGL_OPENVG_API == context->ClientApi() )                    

                {                        

                EGLI_LEAVE_RET( EGL_NO_IMAGE_KHR, EGL_BAD_CONTEXT );

                }

            //<buffer>

            //must be a handle of a VGImage object valid in the specified context, cast

            //into the type EGLClientBuffer

            //Furthermore, the specified VGImage

            //<buffer> must not be a child image

            if ( !state->VGInterface()->IsRootImage( buffer ) )

                {

                EGLI_LEAVE_RET( EGL_NO_IMAGE_KHR, EGL_BAD_ACCESS );

                }

            // TODO:

            /*

            1) We also need to check that VGImage is not bound 

            to a Pbuffer surface

            2) VGimage has not been already used to create EGLImage. 

            3) VGImage itself is not created from EGLImage.            

            */

            //state->VGInterface()-

            // 1)

            if( EGL_PBUFFER_BIT == context->Config()->GetAttribute( EGL_SURFACE_TYPE ) )

                {

                // If VGImage is bound to a Pbuffer no EGLImage

                EGLI_LEAVE_RET( EGL_NO_IMAGE_KHR, EGL_BAD_ACCESS );

                }

            // Descriptor for pixeldata data values

            SurfaceDescriptor desc; 

            // data is actual pixeldata

            void* data = NULL;

            //Any values

            //specified in <attr_list> are ignored.

            // GetImageData will allocate memory for data

            // data must be deleted in CEGLImage destructor

            state->VGInterface()->GetImageData( buffer, desc, data );

            if ( !data )

                {

                EGLI_LEAVE_RET( EGL_NO_IMAGE_KHR, EGL_BAD_ACCESS );

                }

            // Create CEGLImage.

            image = EGLI_NEW CEGLImage( target, buffer, desc, data );

            // If EGLImage creation fail then return error code.

            if( !image )

                {

                EGLI_LEAVE_RET( EGL_NO_IMAGE_KHR, EGL_BAD_ALLOC );

                }

            // Add refcount to VGImage

            state->VGInterface()->AddRef( buffer );

            // Add image in array

            image = display->AddEGLImage( image );

            break;

            }   

        case EGL_GL_TEXTURE_2D_KHR:

		case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR:

        case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR:

        case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR:

        case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR:

        case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR:

        case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR:

            {

            // From RFP document

            // EGL_KHR_gl_image (not required for OpenGL ES 1.1) [R12]

            /*<ctx> must be a valid OpenGL ES API context on that display.*/

			if( context->ClientContext() && (EGL_OPENGL_ES_API != context->ClientApi() || 2 != context->ClientVersion()) )

                {                        

                EGLI_LEAVE_RET( EGL_NO_IMAGE_KHR, EGL_BAD_CONTEXT );

                }

            // From spec.

            /*KHR_gl_texture_2D_image requires the presence of an OpenGL ES

            implementation (1.0 or later and/or 2.0 or later).*/

            /*Accepted as an attribute in the <attr_list> parameter of

            eglCreateImageKHR: EGL_GL_TEXTURE_LEVEL_KHR 0x30BC*/

            //EGL_GL_TEXTURE_LEVEL_KHR  

            /*If <target> is EGL_GL_TEXTURE_2D_KHR, 

            <buffer> must be the name of a nonzero, EGL_GL_TEXTURE_2D target texture object, 

            cast into the type EGLClientBuffer.  

            <attr_list> should specify the mipmap level

            which will be used as the EGLImage source (EGL_GL_TEXTURE_LEVEL_KHR); the

            specified mipmap level must be part of <buffer>.  If not specified, the

            default value listed in Table bbb will be used, instead.  Additional

            values specified in <attr_list> are ignored.  The texture must be complete

            unless the mipmap level to be used is 0, the texture has mipmap level 0

            specified, and no other mipmap levels are specified. */

            SurfaceDescriptor surfDesc;

            EGLint textureLevel = 0;

            EGLint dataSize;

            if( attrib_list && attrib_list[0] != EGL_NONE )

	            {

                  for(int i=0; attrib_list[i] != EGL_NONE ; i+=2)

                    {

                    if( attrib_list[i] == EGL_GL_TEXTURE_LEVEL_KHR )

                        {

                        textureLevel = attrib_list[i+1];

                        }

                    }

	            }

			EImageTarget textureTarget = mapImageTarget(target);

			IEGLtoGLES2Interface* iFace = (IEGLtoGLES2Interface*)state->GLESInterface(2);

			EStatus status = iFace->GetTextureInfo( context->ClientContext(), textureTarget, buffer, textureLevel, surfDesc );

			if ( status != DGLES2_SUCCESS )

				{

				switch( status )

					{

					case DGLES2_BAD_PARAMETER:

					case DGLES2_BAD_MATCH:

						EGLI_LEAVE_RET( EGL_NO_IMAGE_KHR, EGL_BAD_PARAMETER );

						break;

					default:

						EGLI_ASSERT(false);

					}

                EGLI_LEAVE_RET( EGL_NO_IMAGE_KHR, EGL_BAD_ALLOC );

                }

			dataSize = surfDesc.m_stride * surfDesc.m_height;

			unsigned char* data = new unsigned char [ dataSize ];

            iFace->GetTextureData( context->ClientContext(), textureTarget, buffer, textureLevel, data );

            // Create CEGLImage.

            image = EGLI_NEW CEGLImage( target, buffer, surfDesc, data );

            // If EGLImage creation fail then return error code.

            if( !image )

                {

                EGLI_LEAVE_RET( EGL_NO_IMAGE_KHR, EGL_BAD_ALLOC );

                }

            // Add image in array

            // That array is in display side.

            image = display->AddEGLImage( image );

            break;

            }

        case EGL_GL_TEXTURE_3D_KHR:

            {

            /*<ctx> must be a valid OpenGL ES API context on that display.*/

			//EGL_BAD_PARAMETER 

            // NOT SUPPORTED 

            EGLI_LEAVE_RET( EGL_NO_IMAGE_KHR, EGL_BAD_PARAMETER );

            }

        case EGL_GL_RENDERBUFFER_KHR:

            {

            //EGL_BAD_PARAMETER 

            // NOT SUPPORTED 

            EGLI_LEAVE_RET( EGL_NO_IMAGE_KHR, EGL_BAD_PARAMETER );

            }

        default:

            {

            //EGL_BAD_PARAMETER 

            EGLI_LEAVE_RET( EGL_NO_IMAGE_KHR, EGL_BAD_PARAMETER );

            }

        }

    EGLI_LEAVE_RET( image, EGL_SUCCESS );

    }

EGLAPI EGLBoolean EGLAPIENTRY eglDestroyImageKHR( EGLDisplay dpy,

												  EGLImageKHR image)

    {

    // TODO:

    /* Check display

       Delete image from display array*/ 

    EGLI_ENTER_RET( EGL_FALSE );

    CEGLDisplay *display = NULL;

    CEGLImage *tempImage = NULL;

    display = state->GetDisplay( dpy );

    // Check display

    //<dpy> must be a valid EGLDisplay

    if( !display )

       {                   

       EGLI_LEAVE_RET( EGL_FALSE, EGL_BAD_DISPLAY );

       }

    tempImage = display->GetImage( image );

    if( !tempImage )

        {

        EGLI_LEAVE_RET( EGL_FALSE, EGL_BAD_PARAMETER );

        }

    // Display and image are both ok...

    // Let siblings know that image is destroyed...

    // Delete mother of image...

    // Remove image...

    //tempImage

    display->RemoveEGLImage( image );

    return EGL_TRUE;

    }