/*-------------------------------------------------------------------------
* drawElements Quality Program EGL Module
* ---------------------------------------
*
* Copyright 2014 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 Simple surface construction test.
*//*--------------------------------------------------------------------*/
#include "teglCreateSurfaceTests.hpp"
#include "egluNativeDisplay.hpp"
#include "egluNativeWindow.hpp"
#include "egluNativePixmap.hpp"
#include "egluUtil.hpp"
#include "teglSimpleConfigCase.hpp"
#include "tcuTestContext.hpp"
#include "tcuCommandLine.hpp"
#include "tcuTestLog.hpp"
#include "deSTLUtil.hpp"
#include "deUniquePtr.hpp"
#include <memory>
#if !defined(EGL_EXT_platform_base)
# define EGL_EXT_platform_base 1
typedef EGLDisplay (EGLAPIENTRYP PFNEGLGETPLATFORMDISPLAYEXTPROC) (EGLenum platform, void *native_display, const EGLint *attrib_list);
typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC) (EGLDisplay dpy, EGLConfig config, void *native_window, const EGLint *attrib_list);
typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC) (EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLint *attrib_list);
#endif // EGL_EXT_platform_base
using std::vector;
using tcu::TestLog;
namespace deqp
{
namespace egl
{
namespace
{
void checkEGLPlatformSupport (const char* platformExt)
{
std::vector<std::string> extensions = eglu::getPlatformExtensions();
if (!de::contains(extensions.begin(), extensions.end(), platformExt))
throw tcu::NotSupportedError((std::string("Platform extension '") + platformExt + "' not supported").c_str(), "", __FILE__, __LINE__);
}
EGLSurface createWindowSurface (EGLDisplay display, EGLConfig config, eglu::NativeDisplay& nativeDisplay, eglu::NativeWindow& window, bool useLegacyCreate)
{
EGLSurface surface = EGL_NO_SURFACE;
if (useLegacyCreate)
{
surface = eglCreateWindowSurface(display, config, window.getLegacyNative(), DE_NULL);
TCU_CHECK_EGL_MSG("eglCreateWindowSurface() failed");
}
else
{
checkEGLPlatformSupport(nativeDisplay.getPlatformExtensionName());
PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC createPlatformWindowSurfaceEXT = (PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC)eglGetProcAddress("eglCreatePlatformWindowSurfaceEXT");
TCU_CHECK_EGL_MSG("eglGetProcAddress() failed");
surface = createPlatformWindowSurfaceEXT(display, config, window.getPlatformNative(), DE_NULL);
TCU_CHECK_EGL_MSG("eglCreatePlatformWindowSurfaceEXT() failed");
}
return surface;
}
EGLSurface createPixmapSurface (EGLDisplay display, EGLConfig config, eglu::NativeDisplay& nativeDisplay, eglu::NativePixmap& pixmap, bool useLegacyCreate)
{
EGLSurface surface = EGL_NO_SURFACE;
if (useLegacyCreate)
{
surface = eglCreatePixmapSurface(display, config, pixmap.getLegacyNative(), DE_NULL);
TCU_CHECK_EGL_MSG("eglCreatePixmapSurface() failed");
}
else
{
checkEGLPlatformSupport(nativeDisplay.getPlatformExtensionName());
PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC createPlatformPixmapSurfaceEXT = (PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC)eglGetProcAddress("eglCreatePlatformPixmapSurfaceEXT");
TCU_CHECK_EGL_MSG("eglGetProcAddress() failed");
surface = createPlatformPixmapSurfaceEXT(display, config, pixmap.getPlatformNative(), DE_NULL);
TCU_CHECK_EGL_MSG("eglCreatePlatformPixmapSurfaceEXT() failed");
}
return surface;
}
class CreateWindowSurfaceCase : public SimpleConfigCase
{
public:
CreateWindowSurfaceCase (EglTestContext& eglTestCtx, const char* name, const char* description, bool useLegacyCreate, const vector<EGLint>& configIds)
: SimpleConfigCase (eglTestCtx, name, description, configIds)
, m_useLegacyCreate (useLegacyCreate)
{
}
void executeForConfig (tcu::egl::Display& display, EGLConfig config)
{
TestLog& log = m_testCtx.getLog();
EGLint id = display.getConfigAttrib(config, EGL_CONFIG_ID);
// \todo [2011-03-23 pyry] Iterate thru all possible combinations of EGL_RENDER_BUFFER, EGL_VG_COLORSPACE and EGL_VG_ALPHA_FORMAT
if (m_useLegacyCreate)
{
if ((m_eglTestCtx.getNativeWindowFactory().getCapabilities() & eglu::NativeWindow::CAPABILITY_CREATE_SURFACE_LEGACY) == 0)
throw tcu::NotSupportedError("Native window doesn't support legacy eglCreateWindowSurface()", "", __FILE__, __LINE__);
}
else
{
if ((m_eglTestCtx.getNativeWindowFactory().getCapabilities() & eglu::NativeWindow::CAPABILITY_CREATE_SURFACE_PLATFORM) == 0)
throw tcu::NotSupportedError("Native window doesn't support eglCreatePlatformWindowSurfaceEXT()", "", __FILE__, __LINE__);
}
log << TestLog::Message << "Creating window surface with config ID " << id << TestLog::EndMessage;
TCU_CHECK_EGL();
{
const int width = 64;
const int height = 64;
de::UniquePtr<eglu::NativeWindow> window (m_eglTestCtx.createNativeWindow(display.getEGLDisplay(), config, DE_NULL, width, height, eglu::parseWindowVisibility(m_testCtx.getCommandLine())));
tcu::egl::WindowSurface surface (display, createWindowSurface(display.getEGLDisplay(), config, m_eglTestCtx.getNativeDisplay(), *window, m_useLegacyCreate));
EGLint windowWidth = 0;
EGLint windowHeight = 0;
TCU_CHECK_EGL_CALL(eglQuerySurface(display.getEGLDisplay(), surface.getEGLSurface(), EGL_WIDTH, &windowWidth));
TCU_CHECK_EGL_CALL(eglQuerySurface(display.getEGLDisplay(), surface.getEGLSurface(), EGL_HEIGHT, &windowHeight));
if (windowWidth <= 0 || windowHeight <= 0)
{
log << TestLog::Message << " Fail, invalid surface size " << windowWidth << "x" << windowHeight << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid surface size");
}
else
log << TestLog::Message << " Pass" << TestLog::EndMessage;
}
}
private:
bool m_useLegacyCreate;
};
class CreatePixmapSurfaceCase : public SimpleConfigCase
{
public:
CreatePixmapSurfaceCase (EglTestContext& eglTestCtx, const char* name, const char* description, bool useLegacyCreate, const vector<EGLint>& configIds)
: SimpleConfigCase(eglTestCtx, name, description, configIds)
, m_useLegacyCreate (useLegacyCreate)
{
}
void executeForConfig (tcu::egl::Display& display, EGLConfig config)
{
TestLog& log = m_testCtx.getLog();
EGLint id = display.getConfigAttrib(config, EGL_CONFIG_ID);
// \todo [2011-03-23 pyry] Iterate thru all possible combinations of EGL_RENDER_BUFFER, EGL_VG_COLORSPACE and EGL_VG_ALPHA_FORMAT
if (m_useLegacyCreate)
{
if ((m_eglTestCtx.getNativePixmapFactory().getCapabilities() & eglu::NativePixmap::CAPABILITY_CREATE_SURFACE_LEGACY) == 0)
throw tcu::NotSupportedError("Native pixmap doesn't support legacy eglCreatePixmapSurface()", "", __FILE__, __LINE__);
}
else
{
if ((m_eglTestCtx.getNativePixmapFactory().getCapabilities() & eglu::NativePixmap::CAPABILITY_CREATE_SURFACE_PLATFORM) == 0)
throw tcu::NotSupportedError("Native pixmap doesn't support eglCreatePlatformPixmapSurfaceEXT()", "", __FILE__, __LINE__);
}
log << TestLog::Message << "Creating pixmap surface with config ID " << id << TestLog::EndMessage;
TCU_CHECK_EGL();
{
const int width = 64;
const int height = 64;
de::UniquePtr<eglu::NativePixmap> pixmap (m_eglTestCtx.createNativePixmap(display.getEGLDisplay(), config, DE_NULL, width, height));
tcu::egl::PixmapSurface surface (display, createPixmapSurface(display.getEGLDisplay(), config, m_eglTestCtx.getNativeDisplay(), *pixmap, m_useLegacyCreate));
EGLint pixmapWidth = 0;
EGLint pixmapHeight = 0;
TCU_CHECK_EGL_CALL(eglQuerySurface(display.getEGLDisplay(), surface.getEGLSurface(), EGL_WIDTH, &pixmapWidth));
TCU_CHECK_EGL_CALL(eglQuerySurface(display.getEGLDisplay(), surface.getEGLSurface(), EGL_HEIGHT, &pixmapHeight));
if (pixmapWidth <= 0 || pixmapHeight <= 0)
{
log << TestLog::Message << " Fail, invalid surface size " << pixmapWidth << "x" << pixmapHeight << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid surface size");
}
else
log << TestLog::Message << " Pass" << TestLog::EndMessage;
}
}
private:
bool m_useLegacyCreate;
};
class CreatePbufferSurfaceCase : public SimpleConfigCase
{
public:
CreatePbufferSurfaceCase (EglTestContext& eglTestCtx, const char* name, const char* description, const vector<EGLint>& configIds)
: SimpleConfigCase(eglTestCtx, name, description, configIds)
{
}
void executeForConfig (tcu::egl::Display& display, EGLConfig config)
{
TestLog& log = m_testCtx.getLog();
EGLint id = display.getConfigAttrib(config, EGL_CONFIG_ID);
int width = 64;
int height = 64;
// \todo [2011-03-23 pyry] Iterate thru all possible combinations of EGL_RENDER_BUFFER, EGL_VG_COLORSPACE and EGL_VG_ALPHA_FORMAT
log << TestLog::Message << "Creating pbuffer surface with config ID " << id << TestLog::EndMessage;
TCU_CHECK_EGL();
// Clamp to maximums reported by implementation
width = deMin32(width, display.getConfigAttrib(config, EGL_MAX_PBUFFER_WIDTH));
height = deMin32(height, display.getConfigAttrib(config, EGL_MAX_PBUFFER_HEIGHT));
if (width == 0 || height == 0)
{
log << TestLog::Message << " Fail, maximum pbuffer size of " << width << "x" << height << " reported" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid maximum pbuffer size");
return;
}
// \todo [2011-03-23 pyry] Texture-backed variants!
EGLint attribs[] =
{
EGL_WIDTH, width,
EGL_HEIGHT, height,
EGL_TEXTURE_FORMAT, EGL_NO_TEXTURE,
EGL_NONE
};
EGLSurface surface = eglCreatePbufferSurface(display.getEGLDisplay(), config, attribs);
TCU_CHECK_EGL_MSG("Failed to create pbuffer");
TCU_CHECK(surface != EGL_NO_SURFACE);
eglDestroySurface(display.getEGLDisplay(), surface);
log << TestLog::Message << " Pass" << TestLog::EndMessage;
}
};
} // anonymous
CreateSurfaceTests::CreateSurfaceTests (EglTestContext& eglTestCtx)
: TestCaseGroup(eglTestCtx, "create_surface", "Basic surface construction tests")
{
}
CreateSurfaceTests::~CreateSurfaceTests (void)
{
}
void CreateSurfaceTests::init (void)
{
// Window surfaces
{
tcu::TestCaseGroup* windowGroup = new tcu::TestCaseGroup(m_testCtx, "window", "Window surfaces");
addChild(windowGroup);
eglu::FilterList filters;
filters << (eglu::ConfigSurfaceType() & EGL_WINDOW_BIT);
vector<NamedConfigIdSet> configIdSets;
NamedConfigIdSet::getDefaultSets(configIdSets, m_eglTestCtx.getConfigs(), filters);
for (vector<NamedConfigIdSet>::iterator i = configIdSets.begin(); i != configIdSets.end(); i++)
windowGroup->addChild(new CreateWindowSurfaceCase(m_eglTestCtx, i->getName(), i->getDescription(), true, i->getConfigIds()));
}
// Pixmap surfaces
{
tcu::TestCaseGroup* pixmapGroup = new tcu::TestCaseGroup(m_testCtx, "pixmap", "Pixmap surfaces");
addChild(pixmapGroup);
eglu::FilterList filters;
filters << (eglu::ConfigSurfaceType() & EGL_PIXMAP_BIT);
vector<NamedConfigIdSet> configIdSets;
NamedConfigIdSet::getDefaultSets(configIdSets, m_eglTestCtx.getConfigs(), filters);
for (vector<NamedConfigIdSet>::iterator i = configIdSets.begin(); i != configIdSets.end(); i++)
pixmapGroup->addChild(new CreatePixmapSurfaceCase(m_eglTestCtx, i->getName(), i->getDescription(), true, i->getConfigIds()));
}
// Pbuffer surfaces
{
tcu::TestCaseGroup* pbufferGroup = new tcu::TestCaseGroup(m_testCtx, "pbuffer", "Pbuffer surfaces");
addChild(pbufferGroup);
eglu::FilterList filters;
filters << (eglu::ConfigSurfaceType() & EGL_PBUFFER_BIT);
vector<NamedConfigIdSet> configIdSets;
NamedConfigIdSet::getDefaultSets(configIdSets, m_eglTestCtx.getConfigs(), filters);
for (vector<NamedConfigIdSet>::iterator i = configIdSets.begin(); i != configIdSets.end(); i++)
pbufferGroup->addChild(new CreatePbufferSurfaceCase(m_eglTestCtx, i->getName(), i->getDescription(), i->getConfigIds()));
}
// Window surfaces with new platform extension
{
tcu::TestCaseGroup* windowGroup = new tcu::TestCaseGroup(m_testCtx, "platform_window", "Window surfaces with platform extension");
addChild(windowGroup);
eglu::FilterList filters;
filters << (eglu::ConfigSurfaceType() & EGL_WINDOW_BIT);
vector<NamedConfigIdSet> configIdSets;
NamedConfigIdSet::getDefaultSets(configIdSets, m_eglTestCtx.getConfigs(), filters);
for (vector<NamedConfigIdSet>::iterator i = configIdSets.begin(); i != configIdSets.end(); i++)
windowGroup->addChild(new CreateWindowSurfaceCase(m_eglTestCtx, i->getName(), i->getDescription(), false, i->getConfigIds()));
}
// Pixmap surfaces with new platform extension
{
tcu::TestCaseGroup* pixmapGroup = new tcu::TestCaseGroup(m_testCtx, "platform_pixmap", "Pixmap surfaces with platform extension");
addChild(pixmapGroup);
eglu::FilterList filters;
filters << (eglu::ConfigSurfaceType() & EGL_PIXMAP_BIT);
vector<NamedConfigIdSet> configIdSets;
NamedConfigIdSet::getDefaultSets(configIdSets, m_eglTestCtx.getConfigs(), filters);
for (vector<NamedConfigIdSet>::iterator i = configIdSets.begin(); i != configIdSets.end(); i++)
pixmapGroup->addChild(new CreatePixmapSurfaceCase(m_eglTestCtx, i->getName(), i->getDescription(), false, i->getConfigIds()));
}
}
} // egl
} // deqp