| /* |
| * Copyright (C) 2018 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. |
| */ |
| #undef NDEBUG |
| |
| #include "Context.h" |
| #include "EglConfig.h" |
| #include "EglContext.h" |
| #include "EglImage.h" |
| #include "EglSurface.h" |
| #include "EglSync.h" |
| |
| #include <cassert> |
| #include <cerrno> |
| #include <cstring> |
| #include <string> |
| |
| #include <unistd.h> |
| |
| #include <GLES/gl.h> |
| #include <GLES/glext.h> |
| |
| #include <OpenGLESDispatch/EGLDispatch.h> |
| #include <OpenGLESDispatch/GLESv1Dispatch.h> |
| #include <OpenGLESDispatch/GLESv3Dispatch.h> |
| |
| #include "virgl_hw.h" |
| |
| #include "RenderControl.h" |
| |
| #include <hardware/gralloc.h> |
| #include <hardware/gralloc1.h> |
| #include <nativebase/nativebase.h> |
| #include <system/window.h> |
| |
| static void incRefANWB(android_native_base_t* base) { |
| ANativeWindowBuffer* anwb = reinterpret_cast<ANativeWindowBuffer*>(base); |
| anwb->layerCount++; |
| } |
| |
| static void decRefANWB(android_native_base_t* base) { |
| ANativeWindowBuffer* anwb = reinterpret_cast<ANativeWindowBuffer*>(base); |
| if (anwb->layerCount > 0) { |
| anwb->layerCount--; |
| if (anwb->layerCount == 0) |
| delete anwb; |
| } |
| } |
| struct FakeANativeWindowBuffer : public ANativeWindowBuffer { |
| FakeANativeWindowBuffer() { |
| ANativeWindowBuffer(); |
| |
| common.incRef = incRefANWB; |
| common.decRef = decRefANWB; |
| layerCount = 0U; |
| } |
| }; |
| |
| static void incRefANW(android_native_base_t* base) { |
| ANativeWindow* anw = reinterpret_cast<ANativeWindow*>(base); |
| anw->oem[0]++; |
| } |
| |
| static void decRefANW(android_native_base_t* base) { |
| ANativeWindow* anw = reinterpret_cast<ANativeWindow*>(base); |
| if (anw->oem[0] > 0) { |
| anw->oem[0]--; |
| if (anw->oem[0] == 0) |
| delete anw; |
| } |
| } |
| |
| static int setSwapInterval(ANativeWindow*, int) { |
| printf("%s: not implemented\n", __func__); |
| return 0; |
| } |
| |
| static int dequeueBuffer_DEPRECATED(ANativeWindow* window, ANativeWindowBuffer** buffer) { |
| if (!window->oem[1]) |
| return -EINVAL; |
| *buffer = reinterpret_cast<ANativeWindowBuffer*>(window->oem[1]); |
| window->oem[1] = 0; |
| return 0; |
| } |
| |
| static int lockBuffer_DEPRECATED(ANativeWindow*, ANativeWindowBuffer*) { |
| printf("%s: not implemented\n", __func__); |
| return 0; |
| } |
| |
| static int queueBuffer_DEPRECATED(ANativeWindow*, ANativeWindowBuffer*) { |
| printf("%s: not implemented\n", __func__); |
| return 0; |
| } |
| |
| static int query(const ANativeWindow* window, int what, int* value) { |
| switch (what) { |
| case NATIVE_WINDOW_WIDTH: |
| return static_cast<int>(window->oem[2]); |
| case NATIVE_WINDOW_HEIGHT: |
| return static_cast<int>(window->oem[3]); |
| default: |
| return -EINVAL; |
| } |
| } |
| |
| static int perform(ANativeWindow*, int, ...) { |
| printf("%s: not implemented\n", __func__); |
| return 0; |
| } |
| |
| static int cancelBuffer_DEPRECATED(ANativeWindow*, ANativeWindowBuffer*) { |
| printf("%s: not implemented\n", __func__); |
| return 0; |
| } |
| |
| static int dequeueBuffer(ANativeWindow* window, ANativeWindowBuffer** buffer, int* fenceFd) { |
| *fenceFd = -1; |
| return dequeueBuffer_DEPRECATED(window, buffer); |
| } |
| |
| static int queueBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd) { |
| if (fenceFd >= 0) |
| close(fenceFd); |
| return queueBuffer_DEPRECATED(window, buffer); |
| } |
| |
| static int cancelBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd) { |
| if (fenceFd >= 0) |
| close(fenceFd); |
| return cancelBuffer_DEPRECATED(window, buffer); |
| } |
| |
| struct FakeANativeWindow : public ANativeWindow { |
| FakeANativeWindow(uint32_t width, uint32_t height) { |
| ANativeWindow(); |
| |
| common.incRef = incRefANW; |
| common.decRef = decRefANW; |
| oem[0] = 0; |
| oem[2] = static_cast<intptr_t>(width); |
| oem[3] = static_cast<intptr_t>(height); |
| |
| this->setSwapInterval = ::setSwapInterval; |
| this->dequeueBuffer_DEPRECATED = ::dequeueBuffer_DEPRECATED; |
| this->lockBuffer_DEPRECATED = ::lockBuffer_DEPRECATED; |
| this->queueBuffer_DEPRECATED = ::queueBuffer_DEPRECATED; |
| this->query = ::query; |
| this->perform = ::perform; |
| this->cancelBuffer_DEPRECATED = ::cancelBuffer_DEPRECATED; |
| this->dequeueBuffer = ::dequeueBuffer; |
| this->queueBuffer = ::queueBuffer; |
| this->cancelBuffer = ::cancelBuffer; |
| } |
| }; |
| |
| // Helpers |
| |
| static ANativeWindowBuffer* resourceToANWB(Resource* res) { |
| ANativeWindowBuffer* buffer = new (std::nothrow) FakeANativeWindowBuffer(); |
| if (!buffer) |
| return nullptr; |
| |
| buffer->width = res->args.width; |
| buffer->height = res->args.height; |
| buffer->stride = res->args.width; |
| buffer->handle = reinterpret_cast<const native_handle_t*>(res->args.handle); |
| buffer->usage_deprecated = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN | |
| GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER; |
| buffer->usage = |
| GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN | GRALLOC1_CONSUMER_USAGE_CPU_WRITE_OFTEN | |
| GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE | GRALLOC1_PRODUCER_USAGE_CPU_READ_OFTEN | |
| GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN | GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET; |
| |
| switch (res->args.format) { |
| case VIRGL_FORMAT_B8G8R8A8_UNORM: |
| buffer->format = HAL_PIXEL_FORMAT_BGRA_8888; |
| break; |
| case VIRGL_FORMAT_B5G6R5_UNORM: |
| buffer->format = HAL_PIXEL_FORMAT_RGB_565; |
| break; |
| case VIRGL_FORMAT_R8G8B8A8_UNORM: |
| buffer->format = HAL_PIXEL_FORMAT_RGBA_8888; |
| break; |
| case VIRGL_FORMAT_R8G8B8X8_UNORM: |
| buffer->format = HAL_PIXEL_FORMAT_RGBX_8888; |
| break; |
| default: |
| delete buffer; |
| return nullptr; |
| } |
| |
| return buffer; |
| } |
| |
| // RenderControl |
| |
| static GLint rcGetRendererVersion() { |
| return 1; // seems to be hard-coded |
| } |
| |
| static EGLint rcGetEGLVersion(void* ctx_, EGLint* major, EGLint* minor) { |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| return s_egl.eglInitialize(rc->dpy, major, minor); |
| } |
| |
| static EGLint rcQueryEGLString(void* ctx_, EGLenum name, void* buffer, EGLint bufferSize) { |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| const char* str = s_egl.eglQueryString(rc->dpy, name); |
| if (!str) |
| str = ""; |
| |
| if (strlen(str) > (size_t)bufferSize) { |
| memset(buffer, 0, bufferSize); |
| return -strlen(str); |
| } |
| |
| char* strOut = static_cast<char*>(buffer); |
| strncpy(strOut, str, bufferSize - 1); |
| strOut[bufferSize - 1] = 0; |
| |
| return strlen(strOut) + 1U; |
| } |
| |
| static std::string replaceESVersionString(const std::string& prev, const char* const newver) { |
| // Do not touch ES 1.x contexts (they will all be 1.1 anyway) |
| if (prev.find("ES-CM") != std::string::npos) |
| return prev; |
| |
| size_t esStart = prev.find("ES "); |
| size_t esEnd = prev.find(" ", esStart + 3); |
| |
| // Do not change out-of-spec version strings. |
| if (esStart == std::string::npos || esEnd == std::string::npos) |
| return prev; |
| |
| std::string res = prev.substr(0, esStart + 3); |
| res += newver; |
| res += prev.substr(esEnd); |
| return res; |
| } |
| |
| static EGLint rcGetGLString(void* ctx_, EGLenum name, void* buffer, EGLint bufferSize) { |
| std::string glStr; |
| |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| if (rc->ctx->ctx) { |
| const char* str = nullptr; |
| switch (rc->ctx->ctx->api) { |
| case EglContext::GLESApi::GLESApi_CM: |
| str = reinterpret_cast<const char*>(s_gles1.glGetString(name)); |
| break; |
| default: |
| str = reinterpret_cast<const char*>(s_gles3.glGetString(name)); |
| break; |
| } |
| if (str) |
| glStr += str; |
| } |
| |
| // FIXME: Should probably filter the extensions list like the emulator |
| // does. We need to handle ES2 on ES3 compatibility for older |
| // Android versions, as well as filter out unsupported features. |
| |
| if (name == GL_EXTENSIONS) { |
| glStr += ChecksumCalculator::getMaxVersionStr(); |
| glStr += " "; |
| |
| // FIXME: Hard-coded to 3.0 for now. We should attempt to detect 3.1. |
| glStr += "ANDROID_EMU_gles_max_version_3_0"; |
| glStr += " "; |
| } |
| |
| // FIXME: Add support for async swap and the fence_sync extensions |
| |
| // We don't support GLDMA; use VIRTGPU_RESOURCE_CREATE and a combination of |
| // VIRTGPU_TRANSFER_TO_HOST and VIRTGPU_TRANSFER_FROM_HOST. |
| |
| // FIXME: Add support for 'no host error' |
| |
| if (name == GL_VERSION) |
| glStr = replaceESVersionString(glStr, "3.0"); |
| |
| int nextBufferSize = glStr.size() + 1; |
| |
| if (!buffer || nextBufferSize > bufferSize) |
| return -nextBufferSize; |
| |
| snprintf((char*)buffer, nextBufferSize, "%s", glStr.c_str()); |
| return nextBufferSize; |
| } |
| |
| static EGLint rcGetNumConfigs(uint32_t* numAttribs) { |
| *numAttribs = EglConfig::kNumAttribs; |
| return EglConfig::vec.size(); |
| } |
| |
| static EGLint rcGetConfigs(uint32_t bufSize, GLuint* buffer) { |
| size_t configAttribBytes = sizeof(EglConfig::kAttribs); |
| size_t nConfigs = EglConfig::vec.size(); |
| size_t sizeNeeded = configAttribBytes + nConfigs * configAttribBytes; |
| |
| if (bufSize < sizeNeeded) |
| return -sizeNeeded; |
| |
| memcpy(buffer, &EglConfig::kAttribs, configAttribBytes); |
| size_t offset = EglConfig::kNumAttribs; |
| for (auto const& config : EglConfig::vec) { |
| memcpy(&buffer[offset], config->attribs, configAttribBytes); |
| offset += EglConfig::kNumAttribs; |
| } |
| |
| return nConfigs; |
| } |
| |
| static EGLint rcChooseConfig(void* ctx_, EGLint* attribs, uint32_t, uint32_t* config_ints, |
| uint32_t configs_size) { |
| EGLint num_config; |
| EGLConfig configs[configs_size]; |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| EGLBoolean ret = s_egl.eglChooseConfig(rc->dpy, attribs, configs, configs_size, &num_config); |
| if (!ret) |
| num_config = 0; |
| |
| if (configs_size) { |
| for (EGLint i = 0; i < num_config; i++) { |
| config_ints[i] = ~0U; |
| EGLint config_id; |
| if (s_egl.eglGetConfigAttrib(rc->dpy, configs[i], EGL_CONFIG_ID, &config_id)) { |
| for (size_t i = 0; i < EglConfig::vec.size(); i++) { |
| if (EglConfig::vec[i]->attribs[4] == config_id) |
| config_ints[i] = i; |
| } |
| } |
| if (config_ints[i] == ~0U) { |
| num_config = 0; |
| break; |
| } |
| } |
| if (!num_config) |
| memset(config_ints, 0, configs_size * sizeof(uint32_t)); |
| } |
| |
| return num_config; |
| } |
| |
| static EGLint rcGetFBParam(EGLint) { |
| printf("%s: not implemented\n", __func__); |
| return 0; |
| } |
| |
| static uint32_t rcCreateContext(void* ctx_, uint32_t config_, uint32_t share_, uint32_t glVersion) { |
| // clang-format off |
| EGLint attrib_list[] = { |
| EGL_CONTEXT_CLIENT_VERSION, 0, |
| EGL_CONTEXT_MINOR_VERSION_KHR, 0, |
| EGL_NONE |
| }; |
| // clang-format on |
| switch (glVersion) { |
| case EglContext::GLESApi::GLESApi_CM: |
| attrib_list[1] = 1; |
| attrib_list[3] = 1; |
| break; |
| case EglContext::GLESApi::GLESApi_2: |
| attrib_list[1] = 2; |
| break; |
| case EglContext::GLESApi::GLESApi_3_0: |
| attrib_list[1] = 3; |
| break; |
| case EglContext::GLESApi::GLESApi_3_1: |
| attrib_list[1] = 3; |
| attrib_list[3] = 1; |
| break; |
| } |
| if (!attrib_list[1]) |
| return 0U; |
| |
| if (config_ > EglConfig::vec.size()) |
| return 0U; |
| EglConfig const* config = EglConfig::vec[config_]; |
| |
| EGLContext share_context = EGL_NO_CONTEXT; |
| if (share_ > 0) { |
| std::map<uint32_t, EglContext*>::iterator context_it; |
| context_it = EglContext::map.find(share_); |
| if (context_it == EglContext::map.end()) |
| return 0U; |
| |
| EglContext const* share = context_it->second; |
| share_context = share->context; |
| } |
| |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| EGLContext context_ = |
| s_egl.eglCreateContext(rc->dpy, config->config, share_context, attrib_list); |
| if (context_ == EGL_NO_CONTEXT) |
| return 0U; |
| |
| EglContext* context = new (std::nothrow) |
| EglContext(context_, rc->ctx->handle, (enum EglContext::GLESApi)glVersion); |
| if (!context) { |
| s_egl.eglDestroyContext(rc->dpy, context_); |
| return 0U; |
| } |
| |
| return context->id; |
| } |
| |
| static void rcDestroyContext(void* ctx_, uint32_t ctx) { |
| std::map<uint32_t, EglContext*>::iterator it; |
| it = EglContext::map.find(ctx); |
| if (it == EglContext::map.end()) |
| return; |
| |
| EglContext* context = it->second; |
| |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| s_egl.eglDestroyContext(rc->dpy, context->context); |
| context->context = EGL_NO_CONTEXT; |
| if (context->disposable()) |
| delete context; |
| } |
| |
| static uint32_t rcCreateWindowSurface(void* ctx_, uint32_t config_, uint32_t width, |
| uint32_t height) { |
| if (config_ > EglConfig::vec.size()) |
| return 0U; |
| |
| EglConfig const* config = EglConfig::vec[config_]; |
| |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| EglSurface* surface = |
| new (std::nothrow) EglSurface(config->config, rc->ctx->handle, width, height); |
| if (!surface) |
| return 0U; |
| |
| return surface->id; |
| } |
| |
| static void rcDestroyWindowSurface(void* ctx_, uint32_t surface_) { |
| std::map<uint32_t, EglSurface*>::iterator it; |
| it = EglSurface::map.find(surface_); |
| if (it == EglSurface::map.end()) |
| return; |
| |
| EglSurface* surface = it->second; |
| |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| s_egl.eglDestroySurface(rc->dpy, surface->surface); |
| surface->surface = EGL_NO_SURFACE; |
| if (surface->disposable()) { |
| delete surface->window; |
| delete surface; |
| } |
| } |
| |
| static uint32_t rcCreateColorBuffer(uint32_t, uint32_t, GLenum) { |
| // NOTE: This CreateColorBuffer implementation is a no-op which returns a |
| // special surface ID to indicate that a pbuffer surface should be |
| // created. This is necessary because the emulator does not create a |
| // true pbuffer, it always creates a fake one. We don't want this. |
| return ~1U; |
| } |
| |
| static void rcOpenColorBuffer(uint32_t) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void rcCloseColorBuffer(uint32_t) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void rcSetWindowColorBuffer(void* ctx_, uint32_t windowSurface, uint32_t colorBuffer) { |
| std::map<uint32_t, EglSurface*>::iterator surface_it; |
| surface_it = EglSurface::map.find(windowSurface); |
| if (surface_it == EglSurface::map.end()) |
| return; |
| |
| EglSurface* surface = surface_it->second; |
| |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| |
| if (colorBuffer == ~1U) { |
| EGLint const attrib_list[] = { EGL_WIDTH, (EGLint)surface->width, EGL_HEIGHT, |
| (EGLint)surface->height, EGL_NONE }; |
| assert(surface->surface == EGL_NO_SURFACE && "Pbuffer set twice"); |
| surface->surface = s_egl.eglCreatePbufferSurface(rc->dpy, surface->config, attrib_list); |
| } else { |
| std::map<uint32_t, Resource*>::iterator resource_it; |
| resource_it = Resource::map.find(colorBuffer); |
| if (resource_it == Resource::map.end()) |
| return; |
| |
| Resource* res = resource_it->second; |
| ANativeWindowBuffer* buffer = resourceToANWB(res); |
| if (!buffer) |
| return; |
| |
| if (surface->surface == EGL_NO_SURFACE) { |
| surface->window = |
| new (std::nothrow) FakeANativeWindow(res->args.width, res->args.height); |
| if (!surface->window) |
| return; |
| |
| NativeWindowType native_window = reinterpret_cast<NativeWindowType>(surface->window); |
| surface->window->oem[1] = (intptr_t)buffer; |
| surface->surface = |
| s_egl.eglCreateWindowSurface(rc->dpy, surface->config, native_window, nullptr); |
| } else { |
| surface->window->oem[1] = (intptr_t)buffer; |
| s_egl.eglSwapBuffers(rc->dpy, surface->surface); |
| } |
| } |
| } |
| |
| static int rcFlushWindowColorBuffer(uint32_t windowSurface) { |
| std::map<uint32_t, EglSurface*>::iterator it; |
| it = EglSurface::map.find(windowSurface); |
| return it == EglSurface::map.end() ? -1 : 0; |
| } |
| |
| static EGLint rcMakeCurrent(void* ctx_, uint32_t context_, uint32_t drawSurf, uint32_t readSurf) { |
| std::map<uint32_t, EglContext*>::iterator context_it; |
| context_it = EglContext::map.find(context_); |
| if (context_it == EglContext::map.end()) |
| return EGL_FALSE; |
| |
| EglContext* context = context_it->second; |
| |
| std::map<uint32_t, EglSurface*>::iterator surface_it; |
| surface_it = EglSurface::map.find(drawSurf); |
| if (surface_it == EglSurface::map.end()) |
| return EGL_FALSE; |
| |
| EglSurface* draw_surface = surface_it->second; |
| |
| surface_it = EglSurface::map.find(readSurf); |
| if (surface_it == EglSurface::map.end()) |
| return EGL_FALSE; |
| |
| EglSurface* read_surface = surface_it->second; |
| |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| |
| EglSurface* old_draw_surface = draw_surface->bind(rc->ctx->handle, false); |
| if (old_draw_surface) |
| old_draw_surface->unbind(false); |
| |
| EglSurface* old_read_surface = read_surface->bind(rc->ctx->handle, true); |
| if (old_read_surface) |
| old_read_surface->unbind(true); |
| |
| EglContext* old_context = context->bind(rc->ctx->handle); |
| if (old_context) |
| old_context->unbind(); |
| |
| EGLBoolean ret = s_egl.eglMakeCurrent(rc->dpy, draw_surface->surface, read_surface->surface, |
| context->context); |
| if (!ret) { |
| // If eglMakeCurrent fails, it's specified *not* to have unbound the |
| // previous contexts or surfaces, but many implementations do. This bug |
| // isn't worked around here, and we just assume the implementations obey |
| // the spec. |
| context->unbind(); |
| if (old_context) |
| old_context->bind(rc->ctx->handle); |
| read_surface->unbind(true); |
| if (old_read_surface) |
| old_read_surface->bind(rc->ctx->handle, true); |
| draw_surface->unbind(false); |
| if (old_draw_surface) |
| old_draw_surface->bind(rc->ctx->handle, false); |
| } else { |
| if (old_context && old_context->disposable()) |
| delete old_context; |
| if (old_read_surface && old_read_surface->disposable()) |
| delete old_read_surface; |
| if (old_draw_surface && old_draw_surface->disposable()) |
| delete old_draw_surface; |
| rc->ctx->unbind(); |
| rc->ctx->bind(context); |
| } |
| |
| return (EGLint)ret; |
| } |
| |
| static void rcFBPost(uint32_t) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static void rcFBSetSwapInterval(void* ctx_, EGLint interval) { |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| s_egl.eglSwapInterval(rc->dpy, interval); |
| } |
| |
| static void rcBindTexture(void* ctx_, uint32_t colorBuffer) { |
| std::map<uint32_t, Resource*>::iterator it; |
| it = Resource::map.find(colorBuffer); |
| if (it == Resource::map.end()) |
| return; |
| |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| Resource* res = it->second; |
| if (!res->image) { |
| ANativeWindowBuffer* buffer = resourceToANWB(res); |
| if (!buffer) |
| return; |
| |
| EGLClientBuffer client_buffer = static_cast<EGLClientBuffer>(buffer); |
| EGLImageKHR image = s_egl.eglCreateImageKHR( |
| rc->dpy, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID, client_buffer, nullptr); |
| if (image == EGL_NO_IMAGE_KHR) |
| return; |
| |
| EglImage* img = new (std::nothrow) EglImage(rc->dpy, image, s_egl.eglDestroyImageKHR); |
| if (!img) { |
| s_egl.eglDestroyImageKHR(rc->dpy, image); |
| return; |
| } |
| |
| // FIXME: House keeping, because we won't get asked to delete the image |
| // object otherwise, so we need to keep a reference to it.. |
| res->image = img; |
| } |
| |
| if (rc->ctx->ctx->api == EglContext::GLESApi::GLESApi_CM) { |
| // FIXME: Unconditional use of GL_TEXTURE_2D here is wrong |
| s_gles1.glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, res->image->image); |
| } else { |
| // FIXME: Unconditional use of GL_TEXTURE_2D here is wrong |
| s_gles3.glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, res->image->image); |
| } |
| } |
| |
| static void rcBindRenderbuffer(void* ctx_, uint32_t colorBuffer) { |
| std::map<uint32_t, Resource*>::iterator it; |
| it = Resource::map.find(colorBuffer); |
| if (it == Resource::map.end()) |
| return; |
| |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| Resource* res = it->second; |
| if (!res->image) { |
| ANativeWindowBuffer* buffer = resourceToANWB(res); |
| if (!buffer) |
| return; |
| |
| EGLClientBuffer client_buffer = static_cast<EGLClientBuffer>(buffer); |
| EGLImageKHR image = s_egl.eglCreateImageKHR( |
| rc->dpy, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID, client_buffer, nullptr); |
| if (image == EGL_NO_IMAGE_KHR) |
| return; |
| |
| EglImage* img = new (std::nothrow) EglImage(rc->dpy, image, s_egl.eglDestroyImageKHR); |
| if (!img) { |
| s_egl.eglDestroyImageKHR(rc->dpy, image); |
| return; |
| } |
| |
| // FIXME: House keeping, because we won't get asked to delete the image |
| // object otherwise, so we need to keep a reference to it.. |
| res->image = img; |
| } |
| |
| if (rc->ctx->ctx->api == EglContext::GLESApi::GLESApi_CM) { |
| s_gles1.glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER_OES, res->image->image); |
| } else { |
| s_gles3.glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER_OES, res->image->image); |
| } |
| } |
| |
| static EGLint rcColorBufferCacheFlush(uint32_t, EGLint, int) { |
| printf("%s: not implemented\n", __func__); |
| return 0; |
| } |
| |
| static void rcReadColorBuffer(uint32_t, GLint, GLint, GLint, GLint, GLenum, GLenum, void*) { |
| printf("%s: not implemented\n", __func__); |
| } |
| |
| static int rcUpdateColorBuffer(uint32_t, GLint, GLint, GLint, GLint, GLenum, GLenum, void*) { |
| printf("%s: not implemented\n", __func__); |
| return 0; |
| } |
| |
| static int rcOpenColorBuffer2(uint32_t) { |
| printf("%s: not implemented\n", __func__); |
| return 0; |
| } |
| |
| static uint32_t rcCreateClientImage(void* ctx_, uint32_t context_, EGLenum target, GLuint buffer_) { |
| std::map<uint32_t, EglContext*>::iterator it; |
| it = EglContext::map.find(context_); |
| if (it == EglContext::map.end()) |
| return 0U; |
| |
| EglContext* context = it->second; |
| |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| EGLClientBuffer buffer = reinterpret_cast<EGLClientBuffer>(buffer_); |
| EGLImageKHR image = s_egl.eglCreateImageKHR(rc->dpy, context, target, buffer, nullptr); |
| EglImage* img = new (std::nothrow) EglImage(rc->dpy, image, s_egl.eglDestroyImageKHR); |
| if (!img) { |
| s_egl.eglDestroyImageKHR(rc->dpy, image); |
| return 0U; |
| } |
| |
| return img->id; |
| } |
| |
| static int rcDestroyClientImage(uint32_t image_) { |
| std::map<uint32_t, EglImage*>::iterator it; |
| it = EglImage::map.find(image_); |
| if (it == EglImage::map.end()) |
| return EGL_FALSE; |
| |
| EglImage* image = it->second; |
| |
| delete image; |
| return EGL_TRUE; |
| } |
| |
| static void rcSelectChecksumHelper(void* ctx_, uint32_t protocol, uint32_t) { |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| rc->ctx->checksum_calc.setVersion(protocol); |
| } |
| |
| static void rcCreateSyncKHR(void* ctx_, EGLenum type, EGLint* attribs, uint32_t, int, |
| uint64_t* glsync_out, uint64_t* syncthread_out) { |
| *syncthread_out = 0ULL; |
| |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| EGLSyncKHR sync = s_egl.eglCreateSyncKHR(rc->dpy, type, attribs); |
| if (sync == EGL_NO_SYNC_KHR) { |
| *glsync_out = 0ULL; |
| return; |
| } |
| |
| EglSync* syn = new (std::nothrow) EglSync(sync); |
| if (!syn) { |
| s_egl.eglDestroySyncKHR(rc->dpy, sync); |
| *glsync_out = 0ULL; |
| return; |
| } |
| |
| *glsync_out = syn->id; |
| } |
| |
| static EGLint rcClientWaitSyncKHR(void* ctx_, uint64_t sync_, EGLint flags, uint64_t timeout) { |
| std::map<uint64_t, EglSync*>::iterator it; |
| it = EglSync::map.find(sync_); |
| if (it == EglSync::map.end()) |
| return EGL_CONDITION_SATISFIED_KHR; |
| |
| EglSync* sync = it->second; |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| return s_egl.eglClientWaitSyncKHR(rc->dpy, sync->sync, flags, timeout); |
| } |
| |
| static void rcFlushWindowColorBufferAsync(uint32_t windowSurface) { |
| // No-op |
| } |
| |
| static int rcDestroySyncKHR(void* ctx_, uint64_t sync_) { |
| std::map<uint64_t, EglSync*>::iterator it; |
| it = EglSync::map.find(sync_); |
| if (it == EglSync::map.end()) |
| return EGL_FALSE; |
| |
| EglSync* sync = it->second; |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| return s_egl.eglDestroySyncKHR(rc->dpy, sync->sync); |
| } |
| |
| static void rcSetPuid(void* ctx_, uint64_t proto) { |
| union { |
| uint64_t proto; |
| struct { |
| int pid; |
| int tid; |
| } id; |
| } puid; |
| |
| puid.proto = proto; |
| |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| rc->ctx->setPidTid(puid.id.pid, puid.id.tid); |
| } |
| |
| static int rcUpdateColorBufferDMA(uint32_t, GLint, GLint, GLint, GLint, GLenum, GLenum, void*, |
| uint32_t) { |
| printf("%s: not implemented\n", __func__); |
| return 0; |
| } |
| |
| static uint32_t rcCreateColorBufferDMA(uint32_t, uint32_t, GLenum, int) { |
| printf("%s: not implemented\n", __func__); |
| return 0U; |
| } |
| |
| static void rcWaitSyncKHR(void* ctx_, uint64_t sync_, EGLint flags) { |
| std::map<uint64_t, EglSync*>::iterator it; |
| it = EglSync::map.find(sync_); |
| if (it == EglSync::map.end()) |
| return; |
| |
| EglSync* sync = it->second; |
| RenderControl* rc = static_cast<RenderControl*>(ctx_); |
| // FIXME: No eglWaitSyncKHR support in SwiftShader |
| // This call will BLOCK when it should be asynchronous! |
| s_egl.eglClientWaitSyncKHR(rc->dpy, sync->sync, flags, EGL_FOREVER_KHR); |
| } |
| |
| RenderControl::RenderControl(Context* ctx_, EGLDisplay dpy_) { |
| rcGetRendererVersion = ::rcGetRendererVersion; |
| rcGetEGLVersion_dec = ::rcGetEGLVersion; |
| rcQueryEGLString_dec = ::rcQueryEGLString; |
| rcGetGLString_dec = ::rcGetGLString; |
| rcGetNumConfigs = ::rcGetNumConfigs; |
| rcGetConfigs = ::rcGetConfigs; |
| rcChooseConfig_dec = ::rcChooseConfig; |
| rcGetFBParam = ::rcGetFBParam; |
| rcCreateContext_dec = ::rcCreateContext; |
| rcDestroyContext_dec = ::rcDestroyContext; |
| rcCreateWindowSurface_dec = ::rcCreateWindowSurface; |
| rcDestroyWindowSurface_dec = ::rcDestroyWindowSurface; |
| rcCreateColorBuffer = ::rcCreateColorBuffer; |
| rcOpenColorBuffer = ::rcOpenColorBuffer; |
| rcCloseColorBuffer = ::rcCloseColorBuffer; |
| rcSetWindowColorBuffer_dec = ::rcSetWindowColorBuffer; |
| rcFlushWindowColorBuffer = ::rcFlushWindowColorBuffer; |
| rcMakeCurrent_dec = ::rcMakeCurrent; |
| rcFBPost = ::rcFBPost; |
| rcFBSetSwapInterval_dec = ::rcFBSetSwapInterval; |
| rcBindTexture_dec = ::rcBindTexture; |
| rcBindRenderbuffer_dec = ::rcBindRenderbuffer; |
| rcColorBufferCacheFlush = ::rcColorBufferCacheFlush; |
| rcReadColorBuffer = ::rcReadColorBuffer; |
| rcUpdateColorBuffer = ::rcUpdateColorBuffer; |
| rcOpenColorBuffer2 = ::rcOpenColorBuffer2; |
| rcCreateClientImage_dec = ::rcCreateClientImage; |
| rcDestroyClientImage = ::rcDestroyClientImage; |
| rcSelectChecksumHelper_dec = ::rcSelectChecksumHelper; |
| rcCreateSyncKHR_dec = ::rcCreateSyncKHR; |
| rcClientWaitSyncKHR_dec = ::rcClientWaitSyncKHR; |
| rcFlushWindowColorBufferAsync = ::rcFlushWindowColorBufferAsync; |
| rcDestroySyncKHR_dec = ::rcDestroySyncKHR; |
| rcSetPuid_dec = ::rcSetPuid; |
| rcUpdateColorBufferDMA = ::rcUpdateColorBufferDMA; |
| rcCreateColorBufferDMA = ::rcCreateColorBufferDMA; |
| rcWaitSyncKHR_dec = ::rcWaitSyncKHR; |
| |
| dpy = dpy_; |
| ctx = ctx_; |
| } |
