You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
369 lines
13 KiB
369 lines
13 KiB
/*------------------------------------------------------------------------- |
|
* 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 "egluUnique.hpp" |
|
|
|
#include "eglwLibrary.hpp" |
|
#include "eglwEnums.hpp" |
|
|
|
#include "teglSimpleConfigCase.hpp" |
|
#include "tcuTestContext.hpp" |
|
#include "tcuCommandLine.hpp" |
|
#include "tcuTestLog.hpp" |
|
|
|
#include "deSTLUtil.hpp" |
|
#include "deUniquePtr.hpp" |
|
|
|
#include <memory> |
|
|
|
namespace deqp |
|
{ |
|
namespace egl |
|
{ |
|
|
|
using std::vector; |
|
using tcu::TestLog; |
|
using namespace eglw; |
|
|
|
namespace |
|
{ |
|
|
|
void checkEGLPlatformSupport (const Library& egl, const char* platformExt) |
|
{ |
|
std::vector<std::string> extensions = eglu::getClientExtensions(egl); |
|
|
|
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) |
|
{ |
|
const Library& egl = nativeDisplay.getLibrary(); |
|
EGLSurface surface = EGL_NO_SURFACE; |
|
|
|
if (useLegacyCreate) |
|
{ |
|
surface = egl.createWindowSurface(display, config, window.getLegacyNative(), DE_NULL); |
|
EGLU_CHECK_MSG(egl, "eglCreateWindowSurface() failed"); |
|
} |
|
else |
|
{ |
|
checkEGLPlatformSupport(egl, nativeDisplay.getPlatformExtensionName()); |
|
|
|
surface = egl.createPlatformWindowSurfaceEXT(display, config, window.getPlatformNative(), DE_NULL); |
|
EGLU_CHECK_MSG(egl, "eglCreatePlatformWindowSurfaceEXT() failed"); |
|
} |
|
|
|
return surface; |
|
} |
|
|
|
EGLSurface createPixmapSurface (EGLDisplay display, EGLConfig config, eglu::NativeDisplay& nativeDisplay, eglu::NativePixmap& pixmap, bool useLegacyCreate) |
|
{ |
|
const Library& egl = nativeDisplay.getLibrary(); |
|
EGLSurface surface = EGL_NO_SURFACE; |
|
|
|
if (useLegacyCreate) |
|
{ |
|
surface = egl.createPixmapSurface(display, config, pixmap.getLegacyNative(), DE_NULL); |
|
EGLU_CHECK_MSG(egl, "eglCreatePixmapSurface() failed"); |
|
} |
|
else |
|
{ |
|
checkEGLPlatformSupport(egl, nativeDisplay.getPlatformExtensionName()); |
|
|
|
surface = egl.createPlatformPixmapSurfaceEXT(display, config, pixmap.getPlatformNative(), DE_NULL); |
|
EGLU_CHECK_MSG(egl, "eglCreatePlatformPixmapSurfaceEXT() failed"); |
|
} |
|
|
|
return surface; |
|
} |
|
|
|
class CreateWindowSurfaceCase : public SimpleConfigCase |
|
{ |
|
public: |
|
CreateWindowSurfaceCase (EglTestContext& eglTestCtx, const char* name, const char* description, bool useLegacyCreate, const eglu::FilterList& filters) |
|
: SimpleConfigCase (eglTestCtx, name, description, filters) |
|
, m_useLegacyCreate (useLegacyCreate) |
|
{ |
|
} |
|
|
|
void executeForConfig (EGLDisplay display, EGLConfig config) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
EGLint id = eglu::getConfigID(egl, display, config); |
|
const eglu::NativeWindowFactory& windowFactory = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine()); |
|
|
|
// \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 ((windowFactory.getCapabilities() & eglu::NativeWindow::CAPABILITY_CREATE_SURFACE_LEGACY) == 0) |
|
TCU_THROW(NotSupportedError, "Native window doesn't support legacy eglCreateWindowSurface()"); |
|
} |
|
else |
|
{ |
|
if ((windowFactory.getCapabilities() & eglu::NativeWindow::CAPABILITY_CREATE_SURFACE_PLATFORM) == 0) |
|
TCU_THROW(NotSupportedError, "Native window doesn't support eglCreatePlatformWindowSurfaceEXT()"); |
|
} |
|
|
|
log << TestLog::Message << "Creating window surface with config ID " << id << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "init"); |
|
|
|
{ |
|
const int width = 64; |
|
const int height = 64; |
|
de::UniquePtr<eglu::NativeWindow> window (windowFactory.createWindow(&m_eglTestCtx.getNativeDisplay(), display, config, DE_NULL, eglu::WindowParams(width, height, eglu::parseWindowVisibility(m_testCtx.getCommandLine())))); |
|
eglu::UniqueSurface surface (egl, display, createWindowSurface(display, config, m_eglTestCtx.getNativeDisplay(), *window, m_useLegacyCreate)); |
|
|
|
EGLint windowWidth = 0; |
|
EGLint windowHeight = 0; |
|
|
|
EGLU_CHECK_CALL(egl, querySurface(display, *surface, EGL_WIDTH, &windowWidth)); |
|
EGLU_CHECK_CALL(egl, querySurface(display, *surface, 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 eglu::FilterList& filters) |
|
: SimpleConfigCase(eglTestCtx, name, description, filters) |
|
, m_useLegacyCreate (useLegacyCreate) |
|
{ |
|
} |
|
|
|
void executeForConfig (EGLDisplay display, EGLConfig config) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
EGLint id = eglu::getConfigID(egl, display, config); |
|
const eglu::NativePixmapFactory& pixmapFactory = eglu::selectNativePixmapFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine()); |
|
|
|
// \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 ((pixmapFactory.getCapabilities() & eglu::NativePixmap::CAPABILITY_CREATE_SURFACE_LEGACY) == 0) |
|
TCU_THROW(NotSupportedError, "Native pixmap doesn't support legacy eglCreatePixmapSurface()"); |
|
} |
|
else |
|
{ |
|
if ((pixmapFactory.getCapabilities() & eglu::NativePixmap::CAPABILITY_CREATE_SURFACE_PLATFORM) == 0) |
|
TCU_THROW(NotSupportedError, "Native pixmap doesn't support eglCreatePlatformPixmapSurfaceEXT()"); |
|
} |
|
|
|
log << TestLog::Message << "Creating pixmap surface with config ID " << id << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "init"); |
|
|
|
{ |
|
const int width = 64; |
|
const int height = 64; |
|
de::UniquePtr<eglu::NativePixmap> pixmap (pixmapFactory.createPixmap(&m_eglTestCtx.getNativeDisplay(), display, config, DE_NULL, width, height)); |
|
eglu::UniqueSurface surface (egl, display, createPixmapSurface(display, config, m_eglTestCtx.getNativeDisplay(), *pixmap, m_useLegacyCreate)); |
|
EGLint pixmapWidth = 0; |
|
EGLint pixmapHeight = 0; |
|
|
|
EGLU_CHECK_CALL(egl, querySurface(display, *surface, EGL_WIDTH, &pixmapWidth)); |
|
EGLU_CHECK_CALL(egl, querySurface(display, *surface, 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 eglu::FilterList& filters) |
|
: SimpleConfigCase(eglTestCtx, name, description, filters) |
|
{ |
|
} |
|
|
|
void executeForConfig (EGLDisplay display, EGLConfig config) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
EGLint id = eglu::getConfigID(egl, display, config); |
|
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; |
|
EGLU_CHECK_MSG(egl, "init"); |
|
|
|
// Clamp to maximums reported by implementation |
|
width = deMin32(width, eglu::getConfigAttribInt(egl, display, config, EGL_MAX_PBUFFER_WIDTH)); |
|
height = deMin32(height, eglu::getConfigAttribInt(egl, display, 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! |
|
|
|
const EGLint attribs[] = |
|
{ |
|
EGL_WIDTH, width, |
|
EGL_HEIGHT, height, |
|
EGL_TEXTURE_FORMAT, EGL_NO_TEXTURE, |
|
EGL_NONE |
|
}; |
|
|
|
EGLSurface surface = egl.createPbufferSurface(display, config, attribs); |
|
EGLU_CHECK_MSG(egl, "Failed to create pbuffer"); |
|
TCU_CHECK(surface != EGL_NO_SURFACE); |
|
egl.destroySurface(display, surface); |
|
|
|
log << TestLog::Message << " Pass" << TestLog::EndMessage; |
|
} |
|
}; |
|
|
|
} // anonymous |
|
|
|
CreateSurfaceTests::CreateSurfaceTests (EglTestContext& eglTestCtx) |
|
: TestCaseGroup(eglTestCtx, "create_surface", "Basic surface construction tests") |
|
{ |
|
} |
|
|
|
CreateSurfaceTests::~CreateSurfaceTests (void) |
|
{ |
|
} |
|
|
|
template <deUint32 Type> |
|
static bool surfaceType (const eglu::CandidateConfig& c) |
|
{ |
|
return (c.surfaceType() & Type) == Type; |
|
} |
|
|
|
void CreateSurfaceTests::init (void) |
|
{ |
|
// Window surfaces |
|
{ |
|
tcu::TestCaseGroup* windowGroup = new tcu::TestCaseGroup(m_testCtx, "window", "Window surfaces"); |
|
addChild(windowGroup); |
|
|
|
eglu::FilterList baseFilters; |
|
baseFilters << surfaceType<EGL_WINDOW_BIT>; |
|
|
|
vector<NamedFilterList> filterLists; |
|
getDefaultFilterLists(filterLists, baseFilters); |
|
|
|
for (vector<NamedFilterList>::iterator i = filterLists.begin(); i != filterLists.end(); i++) |
|
windowGroup->addChild(new CreateWindowSurfaceCase(m_eglTestCtx, i->getName(), i->getDescription(), true, *i)); |
|
} |
|
|
|
// Pixmap surfaces |
|
{ |
|
tcu::TestCaseGroup* pixmapGroup = new tcu::TestCaseGroup(m_testCtx, "pixmap", "Pixmap surfaces"); |
|
addChild(pixmapGroup); |
|
|
|
eglu::FilterList baseFilters; |
|
baseFilters << surfaceType<EGL_PIXMAP_BIT>; |
|
|
|
vector<NamedFilterList> filterLists; |
|
getDefaultFilterLists(filterLists, baseFilters); |
|
|
|
for (vector<NamedFilterList>::iterator i = filterLists.begin(); i != filterLists.end(); i++) |
|
pixmapGroup->addChild(new CreatePixmapSurfaceCase(m_eglTestCtx, i->getName(), i->getDescription(), true, *i)); |
|
} |
|
|
|
// Pbuffer surfaces |
|
{ |
|
tcu::TestCaseGroup* pbufferGroup = new tcu::TestCaseGroup(m_testCtx, "pbuffer", "Pbuffer surfaces"); |
|
addChild(pbufferGroup); |
|
|
|
eglu::FilterList baseFilters; |
|
baseFilters << surfaceType<EGL_PBUFFER_BIT>; |
|
|
|
vector<NamedFilterList> filterLists; |
|
getDefaultFilterLists(filterLists, baseFilters); |
|
|
|
for (vector<NamedFilterList>::iterator i = filterLists.begin(); i != filterLists.end(); i++) |
|
pbufferGroup->addChild(new CreatePbufferSurfaceCase(m_eglTestCtx, i->getName(), i->getDescription(), *i)); |
|
} |
|
|
|
// 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 baseFilters; |
|
baseFilters << surfaceType<EGL_WINDOW_BIT>; |
|
|
|
vector<NamedFilterList> filterLists; |
|
getDefaultFilterLists(filterLists, baseFilters); |
|
|
|
for (vector<NamedFilterList>::iterator i = filterLists.begin(); i != filterLists.end(); i++) |
|
windowGroup->addChild(new CreateWindowSurfaceCase(m_eglTestCtx, i->getName(), i->getDescription(), false, *i)); |
|
} |
|
|
|
// 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 baseFilters; |
|
baseFilters << surfaceType<EGL_PIXMAP_BIT>; |
|
|
|
vector<NamedFilterList> filterLists; |
|
getDefaultFilterLists(filterLists, baseFilters); |
|
|
|
for (vector<NamedFilterList>::iterator i = filterLists.begin(); i != filterLists.end(); i++) |
|
pixmapGroup->addChild(new CreatePixmapSurfaceCase(m_eglTestCtx, i->getName(), i->getDescription(), false, *i)); |
|
} |
|
} |
|
|
|
} // egl |
|
} // deqp
|
|
|