framework/platform/android/tcuAndroidPlatform.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program Tester Core
   3  * ----------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Android EGL platform.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "tcuAndroidPlatform.hpp"
  25 #include "tcuAndroidUtil.hpp"
  26 #include "gluRenderContext.hpp"
  27 #include "egluNativeDisplay.hpp"
  28 #include "egluNativeWindow.hpp"
  29 #include "egluGLContextFactory.hpp"
  30 #include "egluUtil.hpp"
  31 #include "eglwLibrary.hpp"
  32 #include "eglwEnums.hpp"
  33 #include "tcuFunctionLibrary.hpp"
  34 #include "vkWsiPlatform.hpp"
  35
  36 // Assume no call translation is needed
  37 #include <android/native_window.h>
  38 struct egl_native_pixmap_t;
  39 DE_STATIC_ASSERT(sizeof(eglw::EGLNativeDisplayType) == sizeof(void*));
  40 DE_STATIC_ASSERT(sizeof(eglw::EGLNativePixmapType) == sizeof(struct egl_native_pixmap_t*));
  41 DE_STATIC_ASSERT(sizeof(eglw::EGLNativeWindowType) == sizeof(ANativeWindow*));
  42
  43 namespace tcu
  44 {
  45 namespace Android
  46 {
  47
  48 using namespace eglw;
  49
  50 static const eglu::NativeDisplay::Capability    DISPLAY_CAPABILITIES    = eglu::NativeDisplay::CAPABILITY_GET_DISPLAY_LEGACY;
  51 static const eglu::NativeWindow::Capability             WINDOW_CAPABILITIES             = (eglu::NativeWindow::Capability)(eglu::NativeWindow::CAPABILITY_CREATE_SURFACE_LEGACY |
  52                                                                                                                                                                                                                    eglu::NativeWindow::CAPABILITY_SET_SURFACE_SIZE |
  53                                                                                                                                                                                                                    eglu::NativeWindow::CAPABILITY_GET_SCREEN_SIZE);
  54
  55 class NativeDisplay : public eglu::NativeDisplay
  56 {
  57 public:
  58                                                                         NativeDisplay                   (void) : eglu::NativeDisplay(DISPLAY_CAPABILITIES), m_library("libEGL.so") {}
  59         virtual                                                 ~NativeDisplay                  (void) {}
  60
  61         virtual EGLNativeDisplayType    getLegacyNative                 (void)                  { return EGL_DEFAULT_DISPLAY;   }
  62         virtual const eglw::Library&    getLibrary                              (void) const    { return m_library;                             }
  63
  64 private:
  65         eglw::DefaultLibrary                    m_library;
  66 };
  67
  68 class NativeDisplayFactory : public eglu::NativeDisplayFactory
  69 {
  70 public:
  71                                                                         NativeDisplayFactory    (WindowRegistry& windowRegistry);
  72                                                                         ~NativeDisplayFactory   (void) {}
  73
  74         virtual eglu::NativeDisplay*    createDisplay                   (const EGLAttrib* attribList) const;
  75 };
  76
  77 class NativeWindow : public eglu::NativeWindow
  78 {
  79 public:
  80                                                                         NativeWindow                    (Window* window, int width, int height, int32_t format);
  81         virtual                                                 ~NativeWindow                   (void);
  82
  83         virtual EGLNativeWindowType             getLegacyNative                 (void)                  { return m_window->getNativeWindow();   }
  84         IVec2                                                   getScreenSize                   (void) const    { return m_window->getSize();                   }
  85
  86         void                                                    setSurfaceSize                  (IVec2 size);
  87
  88         virtual void                                    processEvents                   (void);
  89
  90 private:
  91         Window*                                                 m_window;
  92         int32_t                                                 m_format;
  93 };
  94
  95 class NativeWindowFactory : public eglu::NativeWindowFactory
  96 {
  97 public:
  98                                                                         NativeWindowFactory             (WindowRegistry& windowRegistry);
  99                                                                         ~NativeWindowFactory    (void);
 100
 101         virtual eglu::NativeWindow*             createWindow                    (eglu::NativeDisplay* nativeDisplay, const eglu::WindowParams& params) const;
 102         virtual eglu::NativeWindow*             createWindow                    (eglu::NativeDisplay* nativeDisplay, EGLDisplay display, EGLConfig config, const EGLAttrib* attribList, const eglu::WindowParams& params) const;
 103
 104 private:
 105         virtual eglu::NativeWindow*             createWindow                    (const eglu::WindowParams& params, int32_t format) const;
 106
 107         WindowRegistry&                                 m_windowRegistry;
 108 };
 109
 110 // NativeWindow
 111
 112 NativeWindow::NativeWindow (Window* window, int width, int height, int32_t format)
 113         : eglu::NativeWindow    (WINDOW_CAPABILITIES)
 114         , m_window                              (window)
 115         , m_format                              (format)
 116 {
 117         // Set up buffers.
 118         setSurfaceSize(IVec2(width, height));
 119 }
 120
 121 NativeWindow::~NativeWindow (void)
 122 {
 123         m_window->release();
 124 }
 125
 126 void NativeWindow::processEvents (void)
 127 {
 128         if (m_window->isPendingDestroy())
 129                 throw eglu::WindowDestroyedError("Window has been destroyed");
 130 }
 131
 132 void NativeWindow::setSurfaceSize (tcu::IVec2 size)
 133 {
 134         m_window->setBuffersGeometry(size.x() != eglu::WindowParams::SIZE_DONT_CARE ? size.x() : 0,
 135                                                                  size.y() != eglu::WindowParams::SIZE_DONT_CARE ? size.y() : 0,
 136                                                                  m_format);
 137 }
 138
 139 // NativeWindowFactory
 140
 141 NativeWindowFactory::NativeWindowFactory (WindowRegistry& windowRegistry)
 142         : eglu::NativeWindowFactory     ("default", "Default display", WINDOW_CAPABILITIES)
 143         , m_windowRegistry                      (windowRegistry)
 144 {
 145 }
 146
 147 NativeWindowFactory::~NativeWindowFactory (void)
 148 {
 149 }
 150
 151 eglu::NativeWindow* NativeWindowFactory::createWindow (eglu::NativeDisplay* nativeDisplay, const eglu::WindowParams& params) const
 152 {
 153         DE_UNREF(nativeDisplay);
 154         return createWindow(params, WINDOW_FORMAT_RGBA_8888);
 155 }
 156
 157 eglu::NativeWindow* NativeWindowFactory::createWindow (eglu::NativeDisplay* nativeDisplay, EGLDisplay display, EGLConfig config, const EGLAttrib* attribList, const eglu::WindowParams& params) const
 158 {
 159         const int32_t format = (int32_t)eglu::getConfigAttribInt(nativeDisplay->getLibrary(), display, config, EGL_NATIVE_VISUAL_ID);
 160         DE_UNREF(nativeDisplay && attribList);
 161         return createWindow(params, format);
 162 }
 163
 164 eglu::NativeWindow* NativeWindowFactory::createWindow (const eglu::WindowParams& params, int32_t format) const
 165 {
 166         Window* window = m_windowRegistry.tryAcquireWindow();
 167
 168         if (!window)
 169                 throw ResourceError("Native window is not available", DE_NULL, __FILE__, __LINE__);
 170
 171         return new NativeWindow(window, params.width, params.height, format);
 172 }
 173
 174 // NativeDisplayFactory
 175
 176 NativeDisplayFactory::NativeDisplayFactory (WindowRegistry& windowRegistry)
 177         : eglu::NativeDisplayFactory("default", "Default display", DISPLAY_CAPABILITIES)
 178 {
 179         m_nativeWindowRegistry.registerFactory(new NativeWindowFactory(windowRegistry));
 180 }
 181
 182 eglu::NativeDisplay* NativeDisplayFactory::createDisplay (const EGLAttrib* attribList) const
 183 {
 184         DE_UNREF(attribList);
 185         return new NativeDisplay();
 186 }
 187
 188 // Vulkan
 189
 190 class VulkanLibrary : public vk::Library
 191 {
 192 public:
 193         VulkanLibrary (void)
 194                 : m_library     ("libvulkan.so")
 195                 , m_driver      (m_library)
 196         {
 197         }
 198
 199         const vk::PlatformInterface& getPlatformInterface (void) const
 200         {
 201                 return m_driver;
 202         }
 203
 204 private:
 205         const tcu::DynamicFunctionLibrary       m_library;
 206         const vk::PlatformDriver                        m_driver;
 207 };
 208
 209 DE_STATIC_ASSERT(sizeof(vk::pt::AndroidNativeWindowPtr) == sizeof(ANativeWindow*));
 210
 211 class VulkanWindow : public vk::wsi::AndroidWindowInterface
 212 {
 213 public:
 214         VulkanWindow (tcu::Android::Window& window)
 215                 : vk::wsi::AndroidWindowInterface       (vk::pt::AndroidNativeWindowPtr(window.getNativeWindow()))
 216                 , m_window                                                      (window)
 217         {
 218         }
 219
 220         ~VulkanWindow (void)
 221         {
 222                 m_window.release();
 223         }
 224
 225 private:
 226         tcu::Android::Window&   m_window;
 227 };
 228
 229 class VulkanDisplay : public vk::wsi::Display
 230 {
 231 public:
 232         VulkanDisplay (WindowRegistry& windowRegistry)
 233                 : m_windowRegistry(windowRegistry)
 234         {
 235         }
 236
 237         vk::wsi::Window* createWindow (const Maybe<UVec2>& initialSize) const
 238         {
 239                 Window* const   window  = m_windowRegistry.tryAcquireWindow();
 240
 241                 if (window)
 242                 {
 243                         try
 244                         {
 245                                 if (initialSize)
 246                                         window->setBuffersGeometry((int)initialSize->x(), (int)initialSize->y(), WINDOW_FORMAT_RGBA_8888);
 247
 248                                 return new VulkanWindow(*window);
 249                         }
 250                         catch (...)
 251                         {
 252                                 window->release();
 253                                 throw;
 254                         }
 255                 }
 256                 else
 257                         TCU_THROW(ResourceError, "Native window is not available");
 258         }
 259
 260 private:
 261         WindowRegistry&         m_windowRegistry;
 262 };
 263
 264 static size_t getTotalSystemMemory (ANativeActivity* activity)
 265 {
 266         const size_t    MiB             = (size_t)(1<<20);
 267
 268         try
 269         {
 270                 const size_t    cddRequiredSize = getCDDRequiredSystemMemory(activity);
 271
 272                 print("Device has at least %.2f MiB total system memory per Android CDD\n", double(cddRequiredSize) / double(MiB));
 273
 274                 return cddRequiredSize;
 275         }
 276         catch (const std::exception& e)
 277         {
 278                 // Use relatively high fallback size to encourage CDD-compliant behavior
 279                 const size_t    fallbackSize    = (sizeof(void*) == sizeof(deUint64)) ? 2048*MiB : 1024*MiB;
 280
 281                 print("WARNING: Failed to determine system memory size required by CDD: %s\n", e.what());
 282                 print("WARNING: Using fall-back size of %.2f MiB\n", double(fallbackSize) / double(MiB));
 283
 284                 return fallbackSize;
 285         }
 286 }
 287
 288 // Platform
 289
 290 Platform::Platform (NativeActivity& activity)
 291         : m_activity                    (activity)
 292         , m_totalSystemMemory   (getTotalSystemMemory(activity.getNativeActivity()))
 293 {
 294         m_nativeDisplayFactoryRegistry.registerFactory(new NativeDisplayFactory(m_windowRegistry));
 295         m_contextFactoryRegistry.registerFactory(new eglu::GLContextFactory(m_nativeDisplayFactoryRegistry));
 296 }
 297
 298 Platform::~Platform (void)
 299 {
 300 }
 301
 302 bool Platform::processEvents (void)
 303 {
 304         m_windowRegistry.garbageCollect();
 305         return true;
 306 }
 307
 308 vk::Library* Platform::createLibrary (void) const
 309 {
 310         return new VulkanLibrary();
 311 }
 312
 313 void Platform::describePlatform (std::ostream& dst) const
 314 {
 315         tcu::Android::describePlatform(m_activity.getNativeActivity(), dst);
 316 }
 317
 318 void Platform::getMemoryLimits (vk::PlatformMemoryLimits& limits) const
 319 {
 320         // Worst-case estimates
 321         const size_t    MiB                             = (size_t)(1<<20);
 322         const size_t    baseMemUsage    = 400*MiB;
 323         const double    safeUsageRatio  = 0.25;
 324
 325         limits.totalSystemMemory                                        = de::max((size_t)(double(deInt64(m_totalSystemMemory)-deInt64(baseMemUsage)) * safeUsageRatio), 16*MiB);
 326
 327         // Assume UMA architecture
 328         limits.totalDeviceLocalMemory                           = 0;
 329
 330         // Reasonable worst-case estimates
 331         limits.deviceMemoryAllocationGranularity        = 64*1024;
 332         limits.devicePageSize                                           = 4096;
 333         limits.devicePageTableEntrySize                         = 8;
 334         limits.devicePageTableHierarchyLevels           = 3;
 335 }
 336
 337 vk::wsi::Display* Platform::createWsiDisplay (vk::wsi::Type wsiType) const
 338 {
 339         if (wsiType == vk::wsi::TYPE_ANDROID)
 340                 return new VulkanDisplay(const_cast<WindowRegistry&>(m_windowRegistry));
 341         else
 342                 TCU_THROW(NotSupportedError, "WSI type not supported on Android");
 343 }
 344
 345 } // Android
 346 } // tcu