Merge branch 'master' into master

CMakeLists.txt

@@ -5,8 +5,8 @@ include(CTest)
 include(GNUInstallDirs)
 
 if (NOT CMAKE_BUILD_TYPE)
-    message(STATUS "No build type selected, default to release")
-    set(CMAKE_BUILD_TYPE "release")
+    message(STATUS "No build type selected, default to RelWithDebInfo")
+    set(CMAKE_BUILD_TYPE "RelWithDebInfo")
 endif()
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)

README.md

@@ -75,7 +75,7 @@ $ anbox-installer
 
 This will guide you through the installation process.
 
-**NOTE:** Anbox is currently in a **pre-alpha development state**. Don't expect a
+**NOTE:** Anbox is currently in a **alpha development state**. Don't expect a
 fully working system for a production system with all features you need. You will
 for sure see bugs and crashes. If you do so, please don't hestitate and report them!
 

debian/compat

@@ -1 +1 @@
-7
+9

debian/control

@@ -2,8 +2,8 @@ Source: anbox
 Section: misc
 Priority: optional
 Maintainer: Simon Fels <morphis@gravedo.de>
-Build-Depends: debhelper (>= 7), dkms, dh-systemd
-Standards-Version: 3.9.7
+Build-Depends: debhelper (>= 9), dkms, dh-systemd
+Standards-Version: 4.1.3
 Homepage: http://anbox.io
 Vcs-Browser: https://github.com/anbox/anbox
 Vcs-Git: https://github.com/anbox/anbox.git

external/android-emugl/host/libs/Translator/GLES_V2/GLESv2Imp.cpp

@@ -1048,8 +1048,10 @@ GL_APICALL void  GL_APIENTRY glGetIntegerv(GLenum pname, GLint* params){
     if (ctx->glGetIntegerv(pname,params))
     {
         if (destroyCtx)
+        {
             deleteGLESContext(ctx);
             return;
+        }
     }
   
     bool es2 = ctx->getCaps()->GL_ARB_ES2_COMPATIBILITY;

external/android-emugl/host/tools/emugen/ApiGen.cpp

@@ -1158,8 +1158,7 @@ int ApiGen::genDecoderImpl(const std::string &filename)
                         varoffset.c_str(),
                         varoffset.c_str(),
                         varoffset.c_str(),
-                        classname.c_str(),
-                        e->name().c_str()
+                        classname.c_str()
                         );
 
                 varoffset += " + 4";

external/android-emugl/host/tools/emugen/EntryPoint.cpp

@@ -99,7 +99,7 @@ bool EntryPoint::parse(unsigned int lc, const std::string & str)
         std::string vartype, varname;
         if (!parseParameterDeclaration(field, &vartype, &varname, &error)) {
             fprintf(stderr,
-                    "line: %d: Parsing error in field <%s>\n",
+                    "line: %d: Parsing error in field <%s>, error: %s\n",
                     lc,
                     field.c_str(),
                     error.c_str());

scripts/clean-build.sh

@@ -56,8 +56,8 @@ cleanup
 mkdir build || rm -rf build/*
 cd build
 cmake ..
-make -j10
-make test
+VERBOSE=1 make -j10
+VERBOSE=1 make test
 cd ..
 
 cleanup

scripts/gen-emugl-entries.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python2
 
 # Copyright 2015 The Android Open Source Project
 #

src/anbox/graphics/emugl/RenderControl.cpp

@@ -26,9 +26,9 @@
 #include "external/android-emugl/shared/OpenglCodecCommon/ChecksumCalculatorThreadInfo.h"
 #include "external/android-emugl/host/include/OpenGLESDispatch/EGLDispatch.h"
 
-
 #include <map>
 #include <string>
+#include <sstream>
 
 static const GLint rendererVersion = 1;
 static std::shared_ptr<anbox::graphics::LayerComposer> composer;
@@ -55,53 +55,61 @@ static EGLint rcGetEGLVersion(EGLint *major, EGLint *minor) {
   return EGL_TRUE;
 }
 
-static EGLint rcQueryEGLString(EGLenum name, void *buffer, EGLint bufferSize) {
+static std::string filter_extensions(const std::string& extensions, const std::vector<std::string>& whitelist) {
+  std::stringstream approved_extensions;
+  auto extension_list = anbox::utils::string_split(extensions, ' ');
+  for (const auto& ext : extension_list) {
+    if (std::find(whitelist.begin(), whitelist.end(), ext) == whitelist.end())
+      continue;
+
+    if (approved_extensions.tellp() > 0)
+      approved_extensions << " ";
+
+    approved_extensions << ext;
+  }
+  return approved_extensions.str();
+}
+
+static EGLint rcQueryEGLString(EGLenum name, void* buffer, EGLint bufferSize) {
   if (!renderer)
     return 0;
 
-  auto result = s_egl.eglQueryString(renderer->getDisplay(), name);
-  if (!result)
+  std::string result = s_egl.eglQueryString(renderer->getDisplay(), name);
+  if (result.empty())
     return 0;
 
-  std::string approved_result = result;
-
-  // We need to drop a few extensions from the list reported by the driver
-  // as not all are well enough support by our EGL/GLES stack.
   if (name == EGL_EXTENSIONS) {
-    std::vector<std::string> common_unsupported_extensions = {
-      // Leads to crashes on the Android side when SurfaceFlinger initializes
-      // EGL/GLES and it queries surfaces for available attributes.
-      "EGL_EXT_buffer_age"
+    // We need to drop a few extensions from the list reported by the driver
+    // as not all are well enough support by our EGL implementation.
+    std::vector<std::string> whitelisted_extensions = {
+      "EGL_KHR_image_base",
+      "EGL_KHR_gl_texture_2D_image",
     };
-
-    for (const auto &extension : common_unsupported_extensions) {
-      size_t start_pos = approved_result.find(extension);
-      if (start_pos == std::string::npos) continue;
-      approved_result.replace(start_pos, extension.length(), "");
-    }
+    result = filter_extensions(result, whitelisted_extensions);
   }
 
-  int len = approved_result.length() + 1;
+  int len = result.length() + 1;
   if (!buffer || len > bufferSize) {
     return -len;
   }
 
-  strcpy(static_cast<char *>(buffer), approved_result.c_str());
+  strcpy(static_cast<char*>(buffer), result.c_str());
   return len;
 }
 
-static EGLint rcGetGLString(EGLenum name, void *buffer, EGLint bufferSize) {
-  RenderThreadInfo *tInfo = RenderThreadInfo::get();
+static EGLint rcGetGLString(EGLenum name, void* buffer, EGLint bufferSize) {
+  RenderThreadInfo* tInfo = RenderThreadInfo::get();
   std::string result;
 
   if (tInfo && tInfo->currContext) {
-    const char *str = nullptr;
+    const char* str = nullptr;
     if (tInfo->currContext->isGL2())
-      str = reinterpret_cast<const char *>(s_gles2.glGetString(name));
+      str = reinterpret_cast<const char*>(s_gles2.glGetString(name));
     else
-      str = reinterpret_cast<const char *>(s_gles1.glGetString(name));
+      str = reinterpret_cast<const char*>(s_gles1.glGetString(name));
 
-    if (str) result += str;
+    if (str)
+      result += str;
   }
 
   // We're forcing version 2.0 no matter what the host provides as
@@ -113,27 +121,37 @@ static EGLint rcGetGLString(EGLenum name, void *buffer, EGLint bufferSize) {
   if (name == GL_VERSION)
     result = "OpenGL ES 2.0";
   else if (name == GL_EXTENSIONS) {
-    std::string approved_extensions = result;
-    std::vector<std::string> unsupported_extensions = {
-        // Leaving this enabled gives crippeled text rendering when
-        // using the host mesa GLES drivers.
-        "GL_EXT_unpack_subimage",
+    // We need to drop a few extensions from the list reported by the driver
+    // as not all are well enough support by our GL implementation.
+    std::vector<std::string> whitelisted_extensions = {
+      "GL_OES_EGL_image",
+      "GL_OES_EGL_image_external",
+      "GL_OES_depth24",
+      "GL_OES_depth32",
+      "GL_OES_element_index_uint",
+      "GL_OES_texture_float",
+      "GL_OES_texture_float_linear",
+      "GL_OES_compressed_paletted_texture",
+      "GL_OES_compressed_ETC1_RGB8_texture",
+      "GL_OES_depth_texture",
+      "GL_OES_texture_half_float",
+      "GL_OES_texture_half_float_linear",
+      "GL_OES_packed_depth_stencil",
+      "GL_OES_vertex_half_float",
+      "GL_OES_standard_derivatives",
+      "GL_OES_texture_npot",
+      "GL_OES_rgb8_rgba8",
     };
 
-    for (const auto &extension : unsupported_extensions) {
-      size_t start_pos = approved_extensions.find(extension);
-      if (start_pos == std::string::npos) continue;
-      approved_extensions.replace(start_pos, extension.length(), "");
-    }
-
-    result = approved_extensions;
+    result = filter_extensions(result, whitelisted_extensions);
   }
 
   int nextBufferSize = result.size() + 1;
 
-  if (!buffer || nextBufferSize > bufferSize) return -nextBufferSize;
+  if (!buffer || nextBufferSize > bufferSize)
+    return -nextBufferSize;
 
-  snprintf(static_cast<char *>(buffer), nextBufferSize, "%s", result.c_str());
+  snprintf(static_cast<char*>(buffer), nextBufferSize, "%s", result.c_str());
   return nextBufferSize;
 }