xbmc/utils/GLUtils.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "GLUtils.h"
  10
  11 #include "ServiceBroker.h"
  12 #include "log.h"
  13 #include "rendering/MatrixGL.h"
  14 #include "rendering/RenderSystem.h"
  15 #include "settings/AdvancedSettings.h"
  16 #include "settings/SettingsComponent.h"
  17 #include "utils/StringUtils.h"
  18
  19 #include <map>
  20 #include <stdexcept>
  21 #include <utility>
  22
  23 namespace
  24 {
  25
  26 #define X(VAL) std::make_pair(VAL, #VAL)
  27 std::map<GLenum, const char*> glErrors =
  28 {
  29   // please keep attributes in accordance to:
  30   // https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glGetError.xhtml
  31   X(GL_NO_ERROR),
  32   X(GL_INVALID_ENUM),
  33   X(GL_INVALID_VALUE),
  34   X(GL_INVALID_OPERATION),
  35   X(GL_INVALID_FRAMEBUFFER_OPERATION),
  36   X(GL_OUT_OF_MEMORY),
  37 #if defined(HAS_GL)
  38   X(GL_STACK_UNDERFLOW),
  39   X(GL_STACK_OVERFLOW),
  40 #endif
  41 };
  42
  43 std::map<GLenum, const char*> glErrorSource = {
  44 #if defined(HAS_GLES) && defined(TARGET_LINUX)
  45     X(GL_DEBUG_SOURCE_API_KHR),
  46     X(GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR),
  47     X(GL_DEBUG_SOURCE_SHADER_COMPILER_KHR),
  48     X(GL_DEBUG_SOURCE_THIRD_PARTY_KHR),
  49     X(GL_DEBUG_SOURCE_APPLICATION_KHR),
  50     X(GL_DEBUG_SOURCE_OTHER_KHR),
  51 #endif
  52 };
  53
  54 std::map<GLenum, const char*> glErrorType = {
  55 #if defined(HAS_GLES) && defined(TARGET_LINUX)
  56     X(GL_DEBUG_TYPE_ERROR_KHR),
  57     X(GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR),
  58     X(GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR),
  59     X(GL_DEBUG_TYPE_PORTABILITY_KHR),
  60     X(GL_DEBUG_TYPE_PERFORMANCE_KHR),
  61     X(GL_DEBUG_TYPE_OTHER_KHR),
  62     X(GL_DEBUG_TYPE_MARKER_KHR),
  63 #endif
  64 };
  65
  66 std::map<GLenum, const char*> glErrorSeverity = {
  67 #if defined(HAS_GLES) && defined(TARGET_LINUX)
  68     X(GL_DEBUG_SEVERITY_HIGH_KHR),
  69     X(GL_DEBUG_SEVERITY_MEDIUM_KHR),
  70     X(GL_DEBUG_SEVERITY_LOW_KHR),
  71     X(GL_DEBUG_SEVERITY_NOTIFICATION_KHR),
  72 #endif
  73 };
  74 #undef X
  75
  76 } // namespace
  77
  78 void KODI::UTILS::GL::GlErrorCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam)
  79 {
  80   std::string sourceStr;
  81   std::string typeStr;
  82   std::string severityStr;
  83
  84   auto glSource = glErrorSource.find(source);
  85   if (glSource != glErrorSource.end())
  86   {
  87     sourceStr = glSource->second;
  88   }
  89
  90   auto glType = glErrorType.find(type);
  91   if (glType != glErrorType.end())
  92   {
  93     typeStr = glType->second;
  94   }
  95
  96   auto glSeverity = glErrorSeverity.find(severity);
  97   if (glSeverity != glErrorSeverity.end())
  98   {
  99     severityStr = glSeverity->second;
 100   }
 101
 102   CLog::Log(LOGDEBUG, "OpenGL(ES) Debugging:\nSource: {}\nType: {}\nSeverity: {}\nID: {}\nMessage: {}", sourceStr, typeStr, severityStr, id, message);
 103 }
 104
 105 static void PrintMatrix(const GLfloat* matrix, const std::string& matrixName)
 106 {
 107   CLog::Log(LOGDEBUG, "{}:\n{:> 10.3f} {:> 10.3f} {:> 10.3f} {:> 10.3f}\n{:> 10.3f} {:> 10.3f} {:> 10.3f} {:> 10.3f}\n{:> 10.3f} {:> 10.3f} {:> 10.3f} {:> 10.3f}\n{:> 10.3f} {:> 10.3f} {:> 10.3f} {:> 10.3f}",
 108                       matrixName,
 109                       matrix[0], matrix[1], matrix[2], matrix[3],
 110                       matrix[4], matrix[5], matrix[6], matrix[7],
 111                       matrix[8], matrix[9], matrix[10], matrix[11],
 112                       matrix[12], matrix[13], matrix[14], matrix[15]);
 113 }
 114
 115 void _VerifyGLState(const char* szfile, const char* szfunction, int lineno)
 116 {
 117   GLenum err = glGetError();
 118   if (err == GL_NO_ERROR)
 119   {
 120     return;
 121   }
 122
 123   auto error = glErrors.find(err);
 124   if (error != glErrors.end())
 125   {
 126     CLog::Log(LOGERROR, "GL(ES) ERROR: {}", error->second);
 127   }
 128
 129   if (szfile && szfunction)
 130   {
 131     CLog::Log(LOGERROR, "In file: {} function: {} line: {}", szfile, szfunction, lineno);
 132   }
 133
 134   GLboolean scissors;
 135   glGetBooleanv(GL_SCISSOR_TEST, &scissors);
 136   CLog::Log(LOGDEBUG, "Scissor test enabled: {}", scissors == GL_TRUE ? "True" : "False");
 137
 138   GLfloat matrix[16];
 139   glGetFloatv(GL_SCISSOR_BOX, matrix);
 140   CLog::Log(LOGDEBUG, "Scissor box: {}, {}, {}, {}", matrix[0], matrix[1], matrix[2], matrix[3]);
 141
 142   glGetFloatv(GL_VIEWPORT, matrix);
 143   CLog::Log(LOGDEBUG, "Viewport: {}, {}, {}, {}", matrix[0], matrix[1], matrix[2], matrix[3]);
 144
 145   PrintMatrix(glMatrixProject.Get(), "Projection Matrix");
 146   PrintMatrix(glMatrixModview.Get(), "Modelview Matrix");
 147 }
 148
 149 void LogGraphicsInfo()
 150 {
 151 #if defined(HAS_GL) || defined(HAS_GLES)
 152   const char* s;
 153
 154   s = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
 155   if (s)
 156     CLog::Log(LOGINFO, "GL_VENDOR = {}", s);
 157   else
 158     CLog::Log(LOGINFO, "GL_VENDOR = NULL");
 159
 160   s = reinterpret_cast<const char*>(glGetString(GL_RENDERER));
 161   if (s)
 162     CLog::Log(LOGINFO, "GL_RENDERER = {}", s);
 163   else
 164     CLog::Log(LOGINFO, "GL_RENDERER = NULL");
 165
 166   s = reinterpret_cast<const char*>(glGetString(GL_VERSION));
 167   if (s)
 168     CLog::Log(LOGINFO, "GL_VERSION = {}", s);
 169   else
 170     CLog::Log(LOGINFO, "GL_VERSION = NULL");
 171
 172   s = reinterpret_cast<const char*>(glGetString(GL_SHADING_LANGUAGE_VERSION));
 173   if (s)
 174     CLog::Log(LOGINFO, "GL_SHADING_LANGUAGE_VERSION = {}", s);
 175   else
 176     CLog::Log(LOGINFO, "GL_SHADING_LANGUAGE_VERSION = NULL");
 177
 178     //GL_NVX_gpu_memory_info extension
 179 #define GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX          0x9047
 180 #define GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX    0x9048
 181 #define GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX  0x9049
 182 #define GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX            0x904A
 183 #define GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX            0x904B
 184
 185   if (CServiceBroker::GetRenderSystem()->IsExtSupported("GL_NVX_gpu_memory_info"))
 186   {
 187     GLint mem = 0;
 188
 189     glGetIntegerv(GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX, &mem);
 190     CLog::Log(LOGINFO, "GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX = {}", mem);
 191
 192     //this seems to be the amount of ram on the videocard
 193     glGetIntegerv(GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX, &mem);
 194     CLog::Log(LOGINFO, "GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX = {}", mem);
 195   }
 196
 197   std::string extensions;
 198 #if defined(HAS_GL)
 199   unsigned int renderVersionMajor, renderVersionMinor;
 200   CServiceBroker::GetRenderSystem()->GetRenderVersion(renderVersionMajor, renderVersionMinor);
 201   if (renderVersionMajor > 3 ||
 202       (renderVersionMajor == 3 && renderVersionMinor >= 2))
 203   {
 204     GLint n;
 205     glGetIntegerv(GL_NUM_EXTENSIONS, &n);
 206     if (n > 0)
 207     {
 208       GLint i;
 209       for (i = 0; i < n; i++)
 210       {
 211         extensions += (const char*)glGetStringi(GL_EXTENSIONS, i);
 212         extensions += " ";
 213       }
 214     }
 215   }
 216   else
 217 #endif
 218   {
 219     extensions += (const char*) glGetString(GL_EXTENSIONS);
 220   }
 221
 222   if (!extensions.empty())
 223     CLog::Log(LOGINFO, "GL_EXTENSIONS = {}", extensions);
 224   else
 225     CLog::Log(LOGINFO, "GL_EXTENSIONS = NULL");
 226
 227
 228 #else /* !HAS_GL */
 229   CLog::Log(LOGINFO, "Please define LogGraphicsInfo for your chosen graphics library");
 230 #endif /* !HAS_GL */
 231 }
 232
 233 int KODI::UTILS::GL::glFormatElementByteCount(GLenum format)
 234 {
 235   switch (format)
 236   {
 237 #ifdef HAS_GL
 238   case GL_BGRA:
 239     return 4;
 240   case GL_RED:
 241     return 1;
 242   case GL_GREEN:
 243     return 1;
 244   case GL_RG:
 245     return 2;
 246   case GL_BGR:
 247     return 3;
 248 #endif
 249   case GL_RGBA:
 250     return 4;
 251   case GL_RGB:
 252     return 3;
 253   case GL_LUMINANCE_ALPHA:
 254     return 2;
 255   case GL_LUMINANCE:
 256   case GL_ALPHA:
 257     return 1;
 258   default:
 259     CLog::Log(LOGERROR, "glFormatElementByteCount - Unknown format {}", format);
 260     return 1;
 261   }
 262 }
 263
 264 uint8_t KODI::UTILS::GL::GetChannelFromARGB(const KODI::UTILS::GL::ColorChannel colorChannel,
 265                                             const uint32_t argb)
 266 {
 267   switch (colorChannel)
 268   {
 269     case KODI::UTILS::GL::ColorChannel::A:
 270       return (argb >> 24) & 0xFF;
 271     case KODI::UTILS::GL::ColorChannel::R:
 272       return (argb >> 16) & 0xFF;
 273     case KODI::UTILS::GL::ColorChannel::G:
 274       return (argb >> 8) & 0xFF;
 275     case KODI::UTILS::GL::ColorChannel::B:
 276       return (argb >> 0) & 0xFF;
 277     default:
 278       throw std::runtime_error("KODI::UTILS::GL::GetChannelFromARGB: ColorChannel not handled");
 279   };
 280 }