Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

285 lines (241 sloc) 9.18 kB
/**************************************************************************
*
* Copyright 2011 LunarG, Inc.
* All Rights Reserved.
*
* Based on glretrace_glx.cpp, which has
*
* Copyright 2011 Jose Fonseca
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* 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 Software.
*
* THE SOFTWARE IS 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
**************************************************************************/
#include "glproc.hpp"
#include "retrace.hpp"
#include "glretrace.hpp"
#include "os.hpp"
#ifndef EGL_OPENGL_ES_API
#define EGL_OPENGL_ES_API 0x30A0
#define EGL_OPENVG_API 0x30A1
#define EGL_OPENGL_API 0x30A2
#define EGL_CONTEXT_CLIENT_VERSION 0x3098
#endif
using namespace glretrace;
typedef std::map<unsigned long long, glws::Drawable *> DrawableMap;
typedef std::map<unsigned long long, glws::Context *> ContextMap;
typedef std::map<unsigned long long, glws::Profile> ProfileMap;
static DrawableMap drawable_map;
static ContextMap context_map;
static ProfileMap profile_map;
static unsigned int current_api = EGL_OPENGL_ES_API;
static glws::Profile last_profile = glws::PROFILE_COMPAT;
static void
createDrawable(unsigned long long orig_config, unsigned long long orig_surface);
static glws::Drawable *
getDrawable(unsigned long long surface_ptr) {
if (surface_ptr == 0) {
return NULL;
}
DrawableMap::const_iterator it;
it = drawable_map.find(surface_ptr);
if (it == drawable_map.end()) {
// In Fennec we get the egl window surface from Java which isn't
// traced, so just create a drawable if it doesn't exist in here
createDrawable(0, surface_ptr);
it = drawable_map.find(surface_ptr);
assert(it != drawable_map.end());
}
return (it != drawable_map.end()) ? it->second : NULL;
}
static glws::Context *
getContext(unsigned long long context_ptr) {
if (context_ptr == 0) {
return NULL;
}
ContextMap::const_iterator it;
it = context_map.find(context_ptr);
return (it != context_map.end()) ? it->second : NULL;
}
static void createDrawable(unsigned long long orig_config, unsigned long long orig_surface)
{
ProfileMap::iterator it = profile_map.find(orig_config);
glws::Profile profile;
// If the requested config is associated with a profile, use that
// profile. Otherwise, assume that the last used profile is what
// the user wants.
if (it != profile_map.end()) {
profile = it->second;
} else {
profile = last_profile;
}
glws::Visual *visual = glretrace::visual[profile];
glws::Drawable *drawable = glws::createDrawable(visual);
drawable_map[orig_surface] = drawable;
}
static void retrace_eglCreateWindowSurface(trace::Call &call) {
unsigned long long orig_config = call.arg(1).toUIntPtr();
unsigned long long orig_surface = call.ret->toUIntPtr();
createDrawable(orig_config, orig_surface);
}
static void retrace_eglCreatePbufferSurface(trace::Call &call) {
unsigned long long orig_config = call.arg(1).toUIntPtr();
unsigned long long orig_surface = call.ret->toUIntPtr();
createDrawable(orig_config, orig_surface);
// TODO: Respect the pbuffer dimensions too
}
static void retrace_eglDestroySurface(trace::Call &call) {
unsigned long long orig_surface = call.arg(1).toUIntPtr();
DrawableMap::iterator it;
it = drawable_map.find(orig_surface);
if (it != drawable_map.end()) {
if (it->second != drawable) {
// TODO: reference count
delete it->second;
}
drawable_map.erase(it);
}
}
static void retrace_eglBindAPI(trace::Call &call) {
current_api = call.arg(0).toUInt();
}
static void retrace_eglCreateContext(trace::Call &call) {
unsigned long long orig_context = call.ret->toUIntPtr();
unsigned long long orig_config = call.arg(1).toUIntPtr();
glws::Context *share_context = getContext(call.arg(2).toUIntPtr());
trace::Array *attrib_array = dynamic_cast<trace::Array *>(&call.arg(3));
glws::Profile profile;
switch (current_api) {
case EGL_OPENGL_API:
profile = glws::PROFILE_COMPAT;
break;
case EGL_OPENGL_ES_API:
default:
profile = glws::PROFILE_ES1;
if (attrib_array) {
for (int i = 0; i < attrib_array->values.size(); i += 2) {
int v = attrib_array->values[i]->toSInt();
if (v == EGL_CONTEXT_CLIENT_VERSION) {
v = attrib_array->values[i + 1]->toSInt();
if (v == 2)
profile = glws::PROFILE_ES2;
break;
}
}
}
break;
}
glws::Context *context = glws::createContext(glretrace::visual[profile], share_context, profile);
if (!context) {
const char *name;
switch (profile) {
case glws::PROFILE_COMPAT:
name = "OpenGL";
break;
case glws::PROFILE_ES1:
name = "OpenGL ES 1.1";
break;
case glws::PROFILE_ES2:
name = "OpenGL ES 2.0";
break;
default:
name = "unknown";
break;
}
retrace::warning(call) << "Failed to create " << name << " context.\n";
os::abort();
}
context_map[orig_context] = context;
profile_map[orig_config] = profile;
last_profile = profile;
}
static void retrace_eglDestroyContext(trace::Call &call) {
unsigned long long orig_context = call.arg(1).toUIntPtr();
ContextMap::iterator it;
it = context_map.find(orig_context);
if (it != context_map.end()) {
delete it->second;
context_map.erase(it);
}
}
static void retrace_eglMakeCurrent(trace::Call &call) {
glws::Drawable *new_drawable = getDrawable(call.arg(1).toUIntPtr());
glws::Context *new_context = getContext(call.arg(3).toUIntPtr());
if (new_drawable == drawable && new_context == context) {
return;
}
if (drawable && context) {
glFlush();
if (!double_buffer) {
frame_complete(call);
}
}
bool result = glws::makeCurrent(new_drawable, new_context);
if (new_drawable && new_context && result) {
drawable = new_drawable;
context = new_context;
} else {
drawable = NULL;
context = NULL;
}
}
static void retrace_eglSwapBuffers(trace::Call &call) {
frame_complete(call);
if (double_buffer && drawable) {
drawable->swapBuffers();
} else {
glFlush();
}
}
const retrace::Entry glretrace::egl_callbacks[] = {
{"eglGetError", &retrace::ignore},
{"eglGetDisplay", &retrace::ignore},
{"eglInitialize", &retrace::ignore},
{"eglTerminate", &retrace::ignore},
{"eglQueryString", &retrace::ignore},
{"eglGetConfigs", &retrace::ignore},
{"eglChooseConfig", &retrace::ignore},
{"eglGetConfigAttrib", &retrace::ignore},
{"eglCreateWindowSurface", &retrace_eglCreateWindowSurface},
{"eglCreatePbufferSurface", &retrace_eglCreatePbufferSurface},
//{"eglCreatePixmapSurface", &retrace::ignore},
{"eglDestroySurface", &retrace_eglDestroySurface},
{"eglQuerySurface", &retrace::ignore},
{"eglBindAPI", &retrace_eglBindAPI},
{"eglQueryAPI", &retrace::ignore},
//{"eglWaitClient", &retrace::ignore},
//{"eglReleaseThread", &retrace::ignore},
//{"eglCreatePbufferFromClientBuffer", &retrace::ignore},
//{"eglSurfaceAttrib", &retrace::ignore},
//{"eglBindTexImage", &retrace::ignore},
//{"eglReleaseTexImage", &retrace::ignore},
{"eglSwapInterval", &retrace::ignore},
{"eglCreateContext", &retrace_eglCreateContext},
{"eglDestroyContext", &retrace_eglDestroyContext},
{"eglMakeCurrent", &retrace_eglMakeCurrent},
{"eglGetCurrentContext", &retrace::ignore},
{"eglGetCurrentSurface", &retrace::ignore},
{"eglGetCurrentDisplay", &retrace::ignore},
{"eglQueryContext", &retrace::ignore},
{"eglWaitGL", &retrace::ignore},
{"eglWaitNative", &retrace::ignore},
{"eglSwapBuffers", &retrace_eglSwapBuffers},
//{"eglCopyBuffers", &retrace::ignore},
{"eglGetProcAddress", &retrace::ignore},
{NULL, NULL},
};
Jump to Line
Something went wrong with that request. Please try again.