framework/platform/android/tcuAndroidPlatformCapabilityQueryJNI.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program Platform Utilites
 * ----------------------------------------------
 *
 * Copyright 2015 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.
 *
 *//*!
 * \file
 * \brief Android platform capability query JNI component
 *//*--------------------------------------------------------------------*/

#include "tcuDefs.hpp"

#include "tcuCommandLine.hpp"
#include "gluRenderConfig.hpp"
#include "gluRenderContext.hpp"
#include "eglwLibrary.hpp"
#include "eglwEnums.hpp"
#include "egluUtil.hpp"
#include "egluGLUtil.hpp"

#include <jni.h>

namespace
{
namespace opt
{

DE_DECLARE_COMMAND_LINE_OPT(GLMajorVersion, int);
DE_DECLARE_COMMAND_LINE_OPT(GLMinorVersion, int);

} // opt

class GLConfigParser : public tcu::CommandLine
{
public:
					GLConfigParser			(const std::string& argString);

	bool			hasGLMajorVersion		(void) const;
	bool			hasGLMinorVersion		(void) const;
	int				getGLMajorVersion		(void) const;
	int				getGLMinorVersion		(void) const;

private:
	virtual void	registerExtendedOptions	(de::cmdline::Parser& parser);
};

GLConfigParser::GLConfigParser (const std::string& argString)
{
	const std::string execString = "fakebinaryname " + argString; // convert argument list to full command line

	if (!parse(execString))
	{
		tcu::print("failed to parse command line");
		TCU_THROW(Exception, "failed to parse command line");
	}
}

bool GLConfigParser::hasGLMajorVersion (void) const
{
	return getCommandLine().hasOption<opt::GLMajorVersion>();
}

bool GLConfigParser::hasGLMinorVersion (void) const
{
	return getCommandLine().hasOption<opt::GLMinorVersion>();
}

int GLConfigParser::getGLMajorVersion (void) const
{
	DE_ASSERT(hasGLMajorVersion());
	return getCommandLine().getOption<opt::GLMajorVersion>();
}

int GLConfigParser::getGLMinorVersion (void) const
{
	DE_ASSERT(hasGLMinorVersion());
	return getCommandLine().getOption<opt::GLMinorVersion>();
}

void GLConfigParser::registerExtendedOptions (de::cmdline::Parser& parser)
{
	using de::cmdline::Option;

	parser
		<< Option<opt::GLMajorVersion>	(DE_NULL, "deqp-gl-major-version", "OpenGL ES Major version")
		<< Option<opt::GLMinorVersion>	(DE_NULL, "deqp-gl-minor-version", "OpenGL ES Minor version");
}

glu::RenderConfig parseRenderConfig (const std::string& argsStr)
{
	const GLConfigParser parsedCommandLine (argsStr);

	if (!parsedCommandLine.hasGLMajorVersion() ||
		!parsedCommandLine.hasGLMinorVersion())
	{
		tcu::print("minor and major version must be supplied");
		TCU_THROW(Exception, "minor and major version must be supplied");
	}
	else
	{
		const glu::ContextType	testContextType	(glu::ApiType::es(parsedCommandLine.getGLMajorVersion(), parsedCommandLine.getGLMinorVersion()));
		glu::RenderConfig		renderConfig	(testContextType);

		glu::parseRenderConfig(&renderConfig, parsedCommandLine);

		return renderConfig;
	}
}

bool isRenderConfigSupported (const std::string& cmdLineStr)
{
	const glu::RenderConfig		renderConfig	= parseRenderConfig(cmdLineStr);
	const eglw::DefaultLibrary	egl;
	const eglw::EGLDisplay		display			= egl.getDisplay(EGL_DEFAULT_DISPLAY);
	eglw::EGLint				eglMajor		= -1;
	eglw::EGLint				eglMinor		= -1;

	if (display == EGL_NO_DISPLAY)
	{
		tcu::print("could not get default display");
		TCU_THROW(Exception, "could not get default display");
	}

	if (egl.initialize(display, &eglMajor, &eglMinor) != EGL_TRUE)
	{
		tcu::print("failed to initialize egl");
		TCU_THROW(Exception, "failed to initialize egl");
	}
	tcu::print("EGL initialized, major=%d, minor=%d", eglMajor, eglMinor);

	try
	{
		// ignoring return value
		(void)eglu::chooseConfig(egl, display, renderConfig);
	}
	catch (const tcu::NotSupportedError&)
	{
		tcu::print("No matching config");
		egl.terminate(display);
		return false;
	}
	catch (...)
	{
		egl.terminate(display);
		throw;
	}
	egl.terminate(display);

	return true;
}

} // anonymous


DE_BEGIN_EXTERN_C

JNIEXPORT jint JNICALL Java_com_drawelements_deqp_platformutil_DeqpPlatformCapabilityQueryInstrumentation_nativeRenderConfigSupportedQuery (JNIEnv* env, jclass, jstring jCmdLine)
{
	enum
	{
		CONFIGQUERYRESULT_SUPPORTED = 0,
		CONFIGQUERYRESULT_NOT_SUPPORTED = 1,
		CONFIGQUERYRESULT_GENERIC_ERROR = -1,
	};

	std::string			cmdLine;
	const char* const	cmdLineBytes = env->GetStringUTFChars(jCmdLine, DE_NULL);

	if (cmdLineBytes == DE_NULL)
	{
		// no command line is not executable
		tcu::print("no command line supplied");
		return CONFIGQUERYRESULT_GENERIC_ERROR;
	}

	try
	{
		// try to copy to local buffer
		cmdLine = std::string(cmdLineBytes);
	}
	catch (const std::bad_alloc&)
	{
		env->ReleaseStringUTFChars(jCmdLine, cmdLineBytes);
		tcu::print("failed to copy cmdLine");
		return CONFIGQUERYRESULT_GENERIC_ERROR;
	}
	env->ReleaseStringUTFChars(jCmdLine, cmdLineBytes);

	try
	{
		const bool isSupported = isRenderConfigSupported(cmdLine);

		return (isSupported) ? (CONFIGQUERYRESULT_SUPPORTED)
		                     : (CONFIGQUERYRESULT_NOT_SUPPORTED);
	}
	catch (const std::exception& ex)
	{
		// don't bother forwarding the exception to the caller. They cannot do anything with the exception anyway.
		tcu::print("Error: %s", ex.what());
		return CONFIGQUERYRESULT_GENERIC_ERROR;
	}
}

DE_END_EXTERN_C