Android emulator opengl - unit test host side renderer

This adds 'ut_renderer' - a host side unit test renderer. ut_renderer is used to
take a command stream over a socket connection and render it into an opengl window.
The renderer uses the GLESv1_dec decoder library and the ut_rendercontrol api to parse
the command stream.
The ut_renderer uses an external (plug-in) opengl impelementation.

Change-Id: I77794044ca9ca8a75a66a95a248eac384710aafe

tools/emulator/opengl/tests/ut_renderer/Renderer.cpp

@@ -0,0 +1,181 @@
+/*
+* Copyright (C) 2011 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.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "RenderingThread.h"
+#include "Renderer.h"
+
+// include operating-system dependent windowing system impelemntation
+#ifdef _WIN32
+#    error "WINDOWS IS NOT SUPPORTED AT THE MOMENT"
+#elif defined __APPLE__
+#    error "Apple OS-X IS NOT SUPPORTED"
+#elif defined (__unix__)
+# include "X11Windowing.h"
+#endif
+
+
+
+
+
+Renderer * Renderer::m_instance = NULL;
+
+Renderer * Renderer::instance()
+{
+    if (m_instance == NULL) m_instance = new Renderer;
+    return m_instance;
+}
+
+Renderer::Renderer()
+{
+    // Unix specific, use your platform specific windowing implementation
+#ifdef __unix__
+    m_nw = new X11Windowing;
+#endif
+
+    m_dpy = eglGetDisplay(m_nw->getNativeDisplay());
+    EGLint major, minor;
+    eglInitialize(m_dpy, &major, &minor);
+    fprintf(stderr, "egl initialized : %d.%d\n", major, minor);
+}
+
+int Renderer::createSurface(RenderingThread *thread, const ClientHandle & handle)
+{
+    android::Mutex::Autolock(this->m_mutex);
+
+    assert(m_surfaces.find(handle) == m_surfaces.end());
+    if (handle.handle == 0) {
+        fprintf(stderr, "trying to create surface for EGL_NO_SURFACE !!!\n");
+        return -1;
+    } else {
+        RendererSurface  *surface = RendererSurface::create(m_dpy, RendererSurface::CONFIG_DEPTH, m_nw);
+        if (surface == NULL) {
+            printf("failed to create surface !!\n");
+            return -1;
+        }
+        m_surfaces.insert(SurfaceMap::value_type(handle, surface));
+    }
+    return 0;
+}
+
+int Renderer::destroySurface(RenderingThread *thread, const ClientHandle &handle)
+{
+    android::Mutex::Autolock(this->m_mutex);
+
+    SurfaceMap::iterator i = m_surfaces.find(handle);
+    if (i == m_surfaces.end()) {
+        printf("removing surface that doesn't exists\n");
+        return -1;
+    }
+    if (i->second->destroy(m_nw)) {
+        m_surfaces.erase(handle);
+    }
+    return 0;
+}
+
+int Renderer::createContext(RenderingThread *thread, const ClientHandle &handle, ClientHandle shareCtx)
+{
+    android::Mutex::Autolock(this->m_mutex);
+
+    assert(m_ctxs.find(handle) == m_ctxs.end());
+    RendererContext *shared = NULL;
+    if (shareCtx.handle != 0) {
+        ContextMap::iterator sctx = m_ctxs.find(shareCtx);
+        if (sctx != m_ctxs.end()) {
+            shared = sctx->second;
+        }
+    }
+
+    RendererContext *ctx =
+        RendererContext::create(m_dpy,
+                                RendererSurface::getEglConfig(m_dpy, RendererSurface::CONFIG_DEPTH),
+                                shared);
+    if (ctx == NULL) {
+        fprintf(stderr, "failed to create context\n");
+        return -1;
+    }
+    m_ctxs.insert(ContextMap::value_type(handle, ctx));
+    return 0;
+}
+
+int Renderer::destroyContext(RenderingThread *thread, const ClientHandle &handle)
+{
+    android::Mutex::Autolock(this->m_mutex);
+
+    ContextMap::iterator i = m_ctxs.find(handle);
+    if (i == m_ctxs.end()) {
+        printf("removing context that doesn't exists\n");
+        return -1;
+    }
+    if (i->second->destroy()) {
+        m_ctxs.erase(handle);
+    }
+    return 0;
+}
+
+int Renderer::makeCurrent(RenderingThread *thread,
+                          const ClientHandle &drawSurface,
+                          const ClientHandle &readSurface,
+                          const ClientHandle & ctx)
+{
+    android::Mutex::Autolock(this->m_mutex);
+
+    RendererContext *currentContext = thread->currentContext();
+
+    ContextMap::iterator c = m_ctxs.find(ctx);
+    EGLContext eglContext;
+    if (ctx.handle != 0 && c != m_ctxs.end()) {
+        if (c->second != currentContext) {
+            // new context is set
+            if (currentContext != NULL) currentContext->unref();
+            c->second->ref();
+            eglContext = c->second->eglContext();
+            thread->setCurrentContext(c->second);
+            thread->glDecoder().setContextData(&c->second->decoderContextData());
+        } else {
+            // same context is already set
+            eglContext = c->second->eglContext();
+        }
+    } else {
+        eglContext = EGL_NO_CONTEXT;
+        if (currentContext != NULL) currentContext->unref();
+        thread->setCurrentContext(NULL);
+        thread->glDecoder().setContextData(NULL);
+    }
+
+    EGLSurface draw = EGL_NO_SURFACE;
+    EGLSurface read = EGL_NO_SURFACE;
+    SurfaceMap::iterator i;
+    i = m_surfaces.find(drawSurface);   if (i != m_surfaces.end()) draw = i->second->eglSurface();
+    i = m_surfaces.find(readSurface);   if (i != m_surfaces.end()) read = i->second->eglSurface();
+
+    return eglMakeCurrent(m_dpy, draw, read, eglContext);
+}
+
+int Renderer::swapBuffers(RenderingThread *thread,
+                          const ClientHandle &surface)
+{
+    android::Mutex::Autolock(this->m_mutex);
+
+    SurfaceMap::iterator s = m_surfaces.find(surface);
+    if (s == m_surfaces.end()) {
+        fprintf(stderr, "swapping buffers for non existing surface\n");
+        return -1;
+    }
+    return eglSwapBuffers(m_dpy, s->second->eglSurface());
+}