host/gl/glestranslator/EGL/EglOsApi.h - platform/hardware/google/gfxstream - Git at Google

 /*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 #ifndef EGL_OS_API_H
 #define EGL_OS_API_H

 #include "aemu/base/Compiler.h"

 #include <EGL/egl.h>
 #include <EGL/eglext.h>

 #include <memory>

 #define PBUFFER_MAX_WIDTH  32767
 #define PBUFFER_MAX_HEIGHT 32767
 #define PBUFFER_MAX_PIXELS (PBUFFER_MAX_WIDTH * PBUFFER_MAX_HEIGHT)

 class GlLibrary;

 namespace EglOS {

 // This header contains declaration used to abstract the underlying
 // desktop GL library (or equivalent) that is being used by our EGL
 // and GLES translation libraries.

 // Use EglOS::Engine::getHostInstance() to retrieve an instance of the
 // EglOS::Engine interface that matches the host display system.
 //
 // Alternate renderers (e.g. software-based Mesa) can also implement
 // their own engine.

 // Base class used to wrap various GL Surface types.
 class Surface {
 public:
     typedef enum {
         WINDOW = 0,
         PBUFFER = 1,
     } SurfaceType;

     explicit Surface(SurfaceType type) : mType(type) {}

     SurfaceType type() const { return mType; }

 protected:
     SurfaceType mType;
 };

 // An interface class for engine-specific implementation of a GL context.
 class Context {
 public:
     Context(bool coreProfile = false) : mCoreProfile(coreProfile) {}
     bool isCoreProfile() const {
         return mCoreProfile;
     }

     // as of now, only osx has this non-nullptr, needed by media decoder
     virtual void* lowLevelContext() { return nullptr; }
     virtual void* getNative() { return nullptr; }

 protected:
     ~Context() = default;
 private:
     bool mCoreProfile = false;
 };

 // Base class used to wrap engine-specific pixel format descriptors.
 class PixelFormat {
 public:
     PixelFormat() {}

     virtual ~PixelFormat() {}

     virtual PixelFormat* clone() = 0;
 };

 // Small structure used to describe the properties of an engine-specific
 // config.
 struct ConfigInfo {
     EGLint red_size;
     EGLint green_size;
     EGLint blue_size;
     EGLint alpha_size;
     EGLint alpha_mask_size = 0;
     EGLenum caveat;
     EGLint depth_size;
     EGLint frame_buffer_level;
     EGLint max_pbuffer_width;
     EGLint max_pbuffer_height;
     EGLint max_pbuffer_size;
     EGLBoolean native_renderable;
     EGLint renderable_type;
     EGLint native_visual_id;
     EGLint native_visual_type;
     EGLint samples_per_pixel;
     EGLint stencil_size;
     EGLint surface_type;
     EGLenum transparent_type;
     EGLint trans_red_val;
     EGLint trans_green_val;
     EGLint trans_blue_val;
     EGLBoolean recordable_android;
     PixelFormat* frmt;
 };

 // A callback function type used with Display::queryConfig() to report to the
 // caller a new host EGLConfig.
 // |opaque| is an opaque value passed to queryConfig().
 // All other parameters are config attributes.
 // Note that ownership of |frmt| is transfered to the callback.
 typedef void (AddConfigCallback)(void* opaque, const ConfigInfo* configInfo);

 // Pbuffer description.
 // |width| and |height| are its dimensions.
 // |largest| is set to ask the largest pixek buffer (see GLX_LARGEST_PBUFFER).
 // |format| is one of EGL_TEXTURE_RGB or EGL_TEXTURE_RGBA
 // |target| is one of EGL_TEXTURE_2D or EGL_NO_TEXTURE.
 // |hasMipmap| is true if the Pbuffer has mipmaps.
 struct PbufferInfo {
     EGLint width;
     EGLint height;
     EGLint largest;
     EGLint format;
     EGLint target;
     EGLint hasMipmap;
 };

 enum class GlesVersion {
     ES2 = 0,
     ES30 = 1,
     ES31 = 2,
     ES32 = 3,
 };

 inline GlesVersion calcMaxESVersionFromCoreVersion(int coreMajor, int coreMinor) {
     switch (coreMajor) {
         case 3:
             return coreMinor > 1 ? EglOS::GlesVersion::ES30 : EglOS::GlesVersion::ES2;
         case 4:
             // 4.3 core has all the entry points we need, but we want 4.5 core for
             // ARB_ES31_compatibility to avoid shader translation (for now. TODO:
             // translate ESSL 310 to 4.3 shaders)
             return coreMinor > 4 ? EglOS::GlesVersion::ES31 : EglOS::GlesVersion::ES30;
         default:
             return EglOS::GlesVersion::ES2;
     }
 }

 // A class to model the engine-specific implementation of a GL display
 // connection.
 class Display {
 public:
     Display() = default;
     virtual ~Display() {}

     virtual GlesVersion getMaxGlesVersion() = 0;
     virtual const char* getExtensionString() { return ""; }
     virtual const char* getVendorString() { return "Google"; }

     virtual void queryConfigs(int renderableType,
                               AddConfigCallback* addConfigFunc,
                               void* addConfigOpaque) = 0;

     virtual bool isValidNativeWin(Surface* win) = 0;
     virtual bool isValidNativeWin(EGLNativeWindowType win) = 0;

     virtual bool checkWindowPixelFormatMatch(EGLNativeWindowType win,
                                              const PixelFormat* pixelFormat,
                                              unsigned int* width,
                                              unsigned int* height) = 0;

     virtual std::shared_ptr<Context> createContext(
             EGLint profileMask,
             const PixelFormat* pixelFormat,
             Context* sharedContext) = 0;

     virtual Surface* createPbufferSurface(
             const PixelFormat* pixelFormat, const PbufferInfo* info) = 0;

     virtual EGLImage createImageKHR(
             EGLDisplay,
             EGLContext,
             EGLenum,
             EGLClientBuffer,
             const EGLint* attribs) {
         return (EGLImage)0;
     }

     virtual EGLBoolean destroyImageKHR(
             EGLDisplay,
             EGLImage) { return EGL_FALSE; }

     virtual EGLDisplay getNative() { return (EGLDisplay)0; }

     virtual bool releasePbuffer(Surface* pb) = 0;

     virtual bool makeCurrent(Surface* read,
                              Surface* draw,
                              Context* context) = 0;

     virtual void swapBuffers(Surface* srfc) = 0;

     virtual EGLBoolean releaseThread() { return EGL_TRUE; }

     DISALLOW_COPY_AND_ASSIGN(Display);
 };

 // An interface class to model a specific underlying GL graphics subsystem
 // or engine. Use getHost() to retrieve the implementation for the current
 // host.
 class Engine {
 public:
     Engine() = default;
     virtual ~Engine() {}

     // Return a Display instance to the default display / window.
     virtual Display* getDefaultDisplay() = 0;

     // Return to engine-specific implementation of GlLibrary.
     virtual GlLibrary* getGlLibrary() = 0;

     // Return to engine-specific implementation of eglGetProcAddress.
     virtual void* eglGetProcAddress(const char*) = 0;

     // Return to engine-specific implementation of eglDebugMessageControlKHR.
     virtual EGLint eglDebugMessageControlKHR(EGLDEBUGPROCKHR callback,
                                              const EGLAttrib* attribs) {
         return EGL_BAD_ATTRIBUTE;
     }

     // Create a new window surface. |wnd| is a host-specific window handle
     // (e.g. a Windows HWND). A software renderer would always return NULL
     // here.
     virtual Surface* createWindowSurface(PixelFormat* cfg,
                                          EGLNativeWindowType wnd) = 0;


     // Retrieve the implementation for the current host. This can be called
     // multiple times, and will initialize the engine on first call.
     static Engine* getHostInstance();
 };

 // getEgl2EglHostInstance returns a host instance that is used to mount
 // EGL/GLES translator on top of another EGL/GLES library
 Engine* getEgl2EglHostInstance(bool nullEgl);

 }  // namespace EglOS

 #endif  // EGL_OS_API_H
	/*
	* Copyright (C) 2011 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	#ifndef EGL_OS_API_H
	#define EGL_OS_API_H

	#include "aemu/base/Compiler.h"

	#include <EGL/egl.h>
	#include <EGL/eglext.h>

	#include <memory>

	#define PBUFFER_MAX_WIDTH 32767
	#define PBUFFER_MAX_HEIGHT 32767
	#define PBUFFER_MAX_PIXELS (PBUFFER_MAX_WIDTH * PBUFFER_MAX_HEIGHT)

	class GlLibrary;

	namespace EglOS {

	// This header contains declaration used to abstract the underlying
	// desktop GL library (or equivalent) that is being used by our EGL
	// and GLES translation libraries.

	// Use EglOS::Engine::getHostInstance() to retrieve an instance of the
	// EglOS::Engine interface that matches the host display system.
	//
	// Alternate renderers (e.g. software-based Mesa) can also implement
	// their own engine.

	// Base class used to wrap various GL Surface types.
	class Surface {
	public:
	typedef enum {
	WINDOW = 0,
	PBUFFER = 1,
	} SurfaceType;

	explicit Surface(SurfaceType type) : mType(type) {}

	SurfaceType type() const { return mType; }

	protected:
	SurfaceType mType;
	};

	// An interface class for engine-specific implementation of a GL context.
	class Context {
	public:
	Context(bool coreProfile = false) : mCoreProfile(coreProfile) {}
	bool isCoreProfile() const {
	return mCoreProfile;
	}

	// as of now, only osx has this non-nullptr, needed by media decoder
	virtual void* lowLevelContext() { return nullptr; }
	virtual void* getNative() { return nullptr; }

	protected:
	~Context() = default;
	private:
	bool mCoreProfile = false;
	};

	// Base class used to wrap engine-specific pixel format descriptors.
	class PixelFormat {
	public:
	PixelFormat() {}

	virtual ~PixelFormat() {}

	virtual PixelFormat* clone() = 0;
	};

	// Small structure used to describe the properties of an engine-specific
	// config.
	struct ConfigInfo {
	EGLint red_size;
	EGLint green_size;
	EGLint blue_size;
	EGLint alpha_size;
	EGLint alpha_mask_size = 0;
	EGLenum caveat;
	EGLint depth_size;
	EGLint frame_buffer_level;
	EGLint max_pbuffer_width;
	EGLint max_pbuffer_height;
	EGLint max_pbuffer_size;
	EGLBoolean native_renderable;
	EGLint renderable_type;
	EGLint native_visual_id;
	EGLint native_visual_type;
	EGLint samples_per_pixel;
	EGLint stencil_size;
	EGLint surface_type;
	EGLenum transparent_type;
	EGLint trans_red_val;
	EGLint trans_green_val;
	EGLint trans_blue_val;
	EGLBoolean recordable_android;
	PixelFormat* frmt;
	};

	// A callback function type used with Display::queryConfig() to report to the
	// caller a new host EGLConfig.
	// \|opaque\| is an opaque value passed to queryConfig().
	// All other parameters are config attributes.
	// Note that ownership of \|frmt\| is transfered to the callback.
	typedef void (AddConfigCallback)(void* opaque, const ConfigInfo* configInfo);

	// Pbuffer description.
	// \|width\| and \|height\| are its dimensions.
	// \|largest\| is set to ask the largest pixek buffer (see GLX_LARGEST_PBUFFER).
	// \|format\| is one of EGL_TEXTURE_RGB or EGL_TEXTURE_RGBA
	// \|target\| is one of EGL_TEXTURE_2D or EGL_NO_TEXTURE.
	// \|hasMipmap\| is true if the Pbuffer has mipmaps.
	struct PbufferInfo {
	EGLint width;
	EGLint height;
	EGLint largest;
	EGLint format;
	EGLint target;
	EGLint hasMipmap;
	};

	enum class GlesVersion {
	ES2 = 0,
	ES30 = 1,
	ES31 = 2,
	ES32 = 3,
	};

	inline GlesVersion calcMaxESVersionFromCoreVersion(int coreMajor, int coreMinor) {
	switch (coreMajor) {
	case 3:
	return coreMinor > 1 ? EglOS::GlesVersion::ES30 : EglOS::GlesVersion::ES2;
	case 4:
	// 4.3 core has all the entry points we need, but we want 4.5 core for
	// ARB_ES31_compatibility to avoid shader translation (for now. TODO:
	// translate ESSL 310 to 4.3 shaders)
	return coreMinor > 4 ? EglOS::GlesVersion::ES31 : EglOS::GlesVersion::ES30;
	default:
	return EglOS::GlesVersion::ES2;
	}
	}

	// A class to model the engine-specific implementation of a GL display
	// connection.
	class Display {
	public:
	Display() = default;
	virtual ~Display() {}

	virtual GlesVersion getMaxGlesVersion() = 0;
	virtual const char* getExtensionString() { return ""; }
	virtual const char* getVendorString() { return "Google"; }

	virtual void queryConfigs(int renderableType,
	AddConfigCallback* addConfigFunc,
	void* addConfigOpaque) = 0;

	virtual bool isValidNativeWin(Surface* win) = 0;
	virtual bool isValidNativeWin(EGLNativeWindowType win) = 0;

	virtual bool checkWindowPixelFormatMatch(EGLNativeWindowType win,
	const PixelFormat* pixelFormat,
	unsigned int* width,
	unsigned int* height) = 0;

	virtual std::shared_ptr<Context> createContext(
	EGLint profileMask,
	const PixelFormat* pixelFormat,
	Context* sharedContext) = 0;

	virtual Surface* createPbufferSurface(
	const PixelFormat* pixelFormat, const PbufferInfo* info) = 0;

	virtual EGLImage createImageKHR(
	EGLDisplay,
	EGLContext,
	EGLenum,
	EGLClientBuffer,
	const EGLint* attribs) {
	return (EGLImage)0;
	}

	virtual EGLBoolean destroyImageKHR(
	EGLDisplay,
	EGLImage) { return EGL_FALSE; }

	virtual EGLDisplay getNative() { return (EGLDisplay)0; }

	virtual bool releasePbuffer(Surface* pb) = 0;

	virtual bool makeCurrent(Surface* read,
	Surface* draw,
	Context* context) = 0;

	virtual void swapBuffers(Surface* srfc) = 0;

	virtual EGLBoolean releaseThread() { return EGL_TRUE; }

	DISALLOW_COPY_AND_ASSIGN(Display);
	};

	// An interface class to model a specific underlying GL graphics subsystem
	// or engine. Use getHost() to retrieve the implementation for the current
	// host.
	class Engine {
	public:
	Engine() = default;
	virtual ~Engine() {}

	// Return a Display instance to the default display / window.
	virtual Display* getDefaultDisplay() = 0;

	// Return to engine-specific implementation of GlLibrary.
	virtual GlLibrary* getGlLibrary() = 0;

	// Return to engine-specific implementation of eglGetProcAddress.
	virtual void* eglGetProcAddress(const char*) = 0;

	// Return to engine-specific implementation of eglDebugMessageControlKHR.
	virtual EGLint eglDebugMessageControlKHR(EGLDEBUGPROCKHR callback,
	const EGLAttrib* attribs) {
	return EGL_BAD_ATTRIBUTE;
	}

	// Create a new window surface. \|wnd\| is a host-specific window handle
	// (e.g. a Windows HWND). A software renderer would always return NULL
	// here.
	virtual Surface* createWindowSurface(PixelFormat* cfg,
	EGLNativeWindowType wnd) = 0;


	// Retrieve the implementation for the current host. This can be called
	// multiple times, and will initialize the engine on first call.
	static Engine* getHostInstance();
	};

	// getEgl2EglHostInstance returns a host instance that is used to mount
	// EGL/GLES translator on top of another EGL/GLES library
	Engine* getEgl2EglHostInstance(bool nullEgl);

	} // namespace EglOS

	#endif // EGL_OS_API_H