vcl/source/opengl/OpenGLHelper.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <vcl/opengl/GLMHelper.hxx>
  11 #include <vcl/opengl/OpenGLHelper.hxx>
  12
  13 #include <osl/file.hxx>
  14 #include <osl/mutex.hxx>
  15 #include <rtl/bootstrap.hxx>
  16 #include <rtl/digest.h>
  17 #include <rtl/strbuf.hxx>
  18 #include <rtl/ustring.hxx>
  19 #include <config_folders.h>
  20 #include <vcl/salbtype.hxx>
  21 #include <vcl/bmpacc.hxx>
  22 #include <boost/scoped_array.hpp>
  23 #include <vcl/pngwrite.hxx>
  24 #include <vcl/graph.hxx>
  25 #include <vcl/svapp.hxx>
  26 #include <officecfg/Office/Common.hxx>
  27 #include <com/sun/star/util/XFlushable.hpp>
  28 #include <com/sun/star/configuration/theDefaultProvider.hpp>
  29
  30 #include <stdarg.h>
  31 #include <vector>
  32 #include <deque>
  33 #include <unordered_map>
  34
  35 #include "svdata.hxx"
  36 #include "salgdi.hxx"
  37 #include "salinst.hxx"
  38 #include "opengl/zone.hxx"
  39 #include "opengl/watchdog.hxx"
  40 #include <osl/conditn.h>
  41 #include <vcl/opengl/OpenGLWrapper.hxx>
  42 #include <vcl/opengl/OpenGLContext.hxx>
  43
  44 #if defined UNX && !defined MACOSX && !defined IOS && !defined ANDROID
  45 #include "opengl/x11/X11DeviceInfo.hxx"
  46 #elif defined (_WIN32)
  47 #include "opengl/win/WinDeviceInfo.hxx"
  48 #endif
  49
  50 static bool volatile gbInShaderCompile = false;
  51 sal_uInt64 volatile OpenGLZone::gnEnterCount = 0;
  52 sal_uInt64 volatile OpenGLZone::gnLeaveCount = 0;
  53
  54 namespace {
  55
  56 using namespace rtl;
  57
  58 OUString getShaderFolder()
  59 {
  60     OUString aUrl("$BRAND_BASE_DIR/" LIBO_ETC_FOLDER);
  61     rtl::Bootstrap::expandMacros(aUrl);
  62
  63     return aUrl + "/opengl/";
  64 }
  65
  66 OString loadShader(const OUString& rFilename)
  67 {
  68     OUString aFileURL = getShaderFolder() + rFilename +".glsl";
  69     osl::File aFile(aFileURL);
  70     SAL_INFO("vcl.opengl", "Reading " << aFileURL);
  71     if(aFile.open(osl_File_OpenFlag_Read) == osl::FileBase::E_None)
  72     {
  73         sal_uInt64 nSize = 0;
  74         aFile.getSize(nSize);
  75         boost::scoped_array<char> content(new char[nSize+1]);
  76         sal_uInt64 nBytesRead = 0;
  77         aFile.read(content.get(), nSize, nBytesRead);
  78         assert(nSize == nBytesRead);
  79         content.get()[nBytesRead] = 0;
  80         return OString(content.get());
  81     }
  82     else
  83     {
  84         SAL_WARN("vcl.opengl", "could not load the file: " << aFileURL);
  85     }
  86
  87     return OString();
  88 }
  89
  90 OString& getShaderSource(const OUString& rFilename)
  91 {
  92     static std::unordered_map<OUString, OString, OUStringHash> aMap;
  93     static osl::Mutex aMutex;
  94     osl::MutexGuard aGuard(aMutex);
  95
  96     if (aMap.find(rFilename) == aMap.end())
  97     {
  98         aMap[rFilename] = loadShader(rFilename);
  99     }
 100
 101     return aMap[rFilename];
 102 }
 103
 104 }
 105
 106 namespace {
 107     int LogCompilerError(GLuint nId, const rtl::OUString &rDetail,
 108                          const rtl::OUString &rName, bool bShaderNotProgram)
 109     {
 110         OpenGLZone aZone;
 111
 112         int InfoLogLength = 0;
 113
 114         CHECK_GL_ERROR();
 115
 116         if (bShaderNotProgram)
 117             glGetShaderiv (nId, GL_INFO_LOG_LENGTH, &InfoLogLength);
 118         else
 119             glGetProgramiv(nId, GL_INFO_LOG_LENGTH, &InfoLogLength);
 120
 121         CHECK_GL_ERROR();
 122
 123         if ( InfoLogLength > 0 )
 124         {
 125             std::vector<char> ErrorMessage(InfoLogLength+1);
 126             if (bShaderNotProgram)
 127                 glGetShaderInfoLog (nId, InfoLogLength, NULL, &ErrorMessage[0]);
 128             else
 129                 glGetProgramInfoLog(nId, InfoLogLength, NULL, &ErrorMessage[0]);
 130             CHECK_GL_ERROR();
 131
 132             ErrorMessage.push_back('\0');
 133             SAL_WARN("vcl.opengl", rDetail << " shader " << nId << " compile for " << rName << " failed : " << &ErrorMessage[0]);
 134         }
 135         else
 136             SAL_WARN("vcl.opengl", rDetail << " shader: " << rName << " compile " << nId << " failed without error log");
 137         return 0;
 138     }
 139 }
 140
 141 static void addPreamble(OString& rShaderSource, const OString& rPreamble)
 142 {
 143     if (rPreamble.isEmpty())
 144         return;
 145
 146     OString aVersionStr("#version");
 147     int nVersionStrStartPos = rShaderSource.indexOf(aVersionStr, 0);
 148
 149     if (nVersionStrStartPos == -1)
 150     {
 151         rShaderSource = rPreamble + "\n" + rShaderSource;
 152     }
 153     else
 154     {
 155         int nVersionStrEndPos = rShaderSource.indexOf('\n', nVersionStrStartPos);
 156
 157         SAL_WARN_IF(nVersionStrEndPos == -1, "vcl.opengl", "syntax error in shader");
 158
 159         if (nVersionStrEndPos == -1)
 160             nVersionStrEndPos = nVersionStrStartPos + 8;
 161
 162         OString aVersionLine = rShaderSource.copy(0, nVersionStrEndPos - nVersionStrStartPos);
 163         OString aShaderBody = rShaderSource.copy(nVersionStrEndPos - nVersionStrStartPos);
 164
 165         rShaderSource = aVersionLine + "\n" + rPreamble + "\n" + aShaderBody;
 166     }
 167 }
 168
 169 namespace
 170 {
 171     static const sal_uInt32 GLenumSize = sizeof(GLenum);
 172
 173     OString getHexString(const sal_uInt8* pData, sal_uInt32 nLength)
 174     {
 175         static const char* pHexData = "0123456789ABCDEF";
 176
 177         bool bIsZero = true;
 178         OStringBuffer aHexStr;
 179         for(size_t i = 0; i < nLength; ++i)
 180         {
 181             sal_uInt8 val = pData[i];
 182             if( val != 0 )
 183                 bIsZero = false;
 184             aHexStr.append( pHexData[ val & 0xf ] );
 185             aHexStr.append( pHexData[ val >> 4 ] );
 186         }
 187         if( bIsZero )
 188             return OString();
 189         else
 190             return aHexStr.makeStringAndClear();
 191     }
 192
 193     OString generateMD5(const void* pData, size_t length)
 194     {
 195         sal_uInt8 pBuffer[RTL_DIGEST_LENGTH_MD5];
 196         rtlDigestError aError = rtl_digest_MD5(pData, length,
 197                 pBuffer, RTL_DIGEST_LENGTH_MD5);
 198         SAL_WARN_IF(aError != rtl_Digest_E_None, "vcl.opengl", "md5 generation failed");
 199
 200         return getHexString(pBuffer, RTL_DIGEST_LENGTH_MD5);
 201     }
 202
 203     OString getStringDigest( const OUString& rVertexShaderName,
 204                              const OUString& rFragmentShaderName,
 205                              const OString& rPreamble )
 206     {
 207         // read shaders source
 208         OString aVertexShaderSource = getShaderSource( rVertexShaderName );
 209         OString aFragmentShaderSource = getShaderSource( rFragmentShaderName );
 210
 211         // get info about the graphic device
 212 #if defined( SAL_UNX ) && !defined( MACOSX ) && !defined( IOS )&& !defined( ANDROID )
 213         static const X11OpenGLDeviceInfo aInfo;
 214         static const OString aDeviceInfo (
 215                 aInfo.GetOS() +
 216                 aInfo.GetOSRelease() +
 217                 aInfo.GetRenderer() +
 218                 aInfo.GetVendor() +
 219                 aInfo.GetVersion() );
 220 #elif defined( _WIN32 )
 221         static const WinOpenGLDeviceInfo aInfo;
 222         static const OString aDeviceInfo (
 223                 OUStringToOString( aInfo.GetAdapterVendorID(), RTL_TEXTENCODING_UTF8 ) +
 224                 OUStringToOString( aInfo.GetAdapterDeviceID(), RTL_TEXTENCODING_UTF8 ) +
 225                 OUStringToOString( aInfo.GetDriverVersion(), RTL_TEXTENCODING_UTF8 ) +
 226                 OString::number( aInfo.GetWindowsVersion() ) );
 227 #else
 228         static const OString aDeviceInfo (
 229                 OString( (const char*)(glGetString(GL_VENDOR)) ) +
 230                 OString( (const char*)(glGetString(GL_RENDERER)) ) +
 231                 OString( (const char*)(glGetString(GL_VERSION)) ) );
 232 #endif
 233
 234         OString aMessage;
 235         aMessage += rPreamble;
 236         aMessage += aVertexShaderSource;
 237         aMessage += aFragmentShaderSource;
 238         aMessage += aDeviceInfo;
 239
 240         return generateMD5(aMessage.getStr(), aMessage.getLength());
 241     }
 242
 243     OString getCacheFolder()
 244     {
 245         OUString url("${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE("bootstrap") ":UserInstallation}/cache/");
 246         rtl::Bootstrap::expandMacros(url);
 247
 248         osl::Directory::create(url);
 249
 250         return rtl::OUStringToOString(url, RTL_TEXTENCODING_UTF8);
 251     }
 252
 253
 254     bool writeProgramBinary( const OString& rBinaryFileName,
 255                              const std::vector<sal_uInt8>& rBinary )
 256     {
 257         osl::File aFile(rtl::OStringToOUString(rBinaryFileName, RTL_TEXTENCODING_UTF8));
 258         osl::FileBase::RC eStatus = aFile.open(
 259                 osl_File_OpenFlag_Write | osl_File_OpenFlag_Create );
 260
 261         if( eStatus != osl::FileBase::E_None )
 262         {
 263             // when file already exists we do not have to save it:
 264             // we can be sure that the binary to save is exactly equal
 265             // to the already saved binary, since they have the same hash value
 266             if( eStatus == osl::FileBase::E_EXIST )
 267             {
 268                 SAL_WARN( "vcl.opengl",
 269                         "No binary program saved. A file with the same hash already exists: '" << rBinaryFileName << "'" );
 270                 return true;
 271             }
 272             return false;
 273         }
 274
 275         sal_uInt64 nBytesWritten = 0;
 276         aFile.write( rBinary.data(), rBinary.size(), nBytesWritten );
 277
 278         assert( rBinary.size() == nBytesWritten );
 279
 280         return true;
 281     }
 282
 283     bool readProgramBinary( const OString& rBinaryFileName,
 284                             std::vector<sal_uInt8>& rBinary )
 285     {
 286         osl::File aFile( rtl::OStringToOUString( rBinaryFileName, RTL_TEXTENCODING_UTF8 ) );
 287         if(aFile.open( osl_File_OpenFlag_Read ) == osl::FileBase::E_None)
 288         {
 289             sal_uInt64 nSize = 0;
 290             aFile.getSize( nSize );
 291             rBinary.resize( nSize );
 292             sal_uInt64 nBytesRead = 0;
 293             aFile.read( rBinary.data(), nSize, nBytesRead );
 294             assert( nSize == nBytesRead );
 295             SAL_WARN("vcl.opengl", "Loading file: '" << rBinaryFileName << "': success" );
 296             return true;
 297         }
 298         else
 299         {
 300             SAL_WARN("vcl.opengl", "Loading file: '" << rBinaryFileName << "': FAIL");
 301         }
 302
 303         return false;
 304     }
 305
 306     OString createFileName( const OUString& rVertexShaderName,
 307                             const OUString& rFragmentShaderName,
 308                             const OString& rDigest )
 309     {
 310         OString aFileName;
 311         aFileName += getCacheFolder();
 312         aFileName += rtl::OUStringToOString( rVertexShaderName, RTL_TEXTENCODING_UTF8 ) + "-";
 313         aFileName += rtl::OUStringToOString( rFragmentShaderName, RTL_TEXTENCODING_UTF8 ) + "-";
 314         aFileName += rDigest + ".bin";
 315         return aFileName;
 316     }
 317
 318     GLint loadProgramBinary( GLuint nProgramID, const OString& rBinaryFileName )
 319     {
 320         GLint nResult = GL_FALSE;
 321         GLenum nBinaryFormat;
 322         std::vector<sal_uInt8> aBinary;
 323         if( readProgramBinary( rBinaryFileName, aBinary ) && aBinary.size() > GLenumSize )
 324         {
 325             GLint nBinaryLength = aBinary.size() - GLenumSize;
 326
 327             // Extract binary format
 328             sal_uInt8* pBF = (sal_uInt8*)(&nBinaryFormat);
 329             for( size_t i = 0; i < GLenumSize; ++i )
 330             {
 331                 pBF[i] = aBinary[nBinaryLength + i];
 332             }
 333
 334             // Load the program
 335             glProgramBinary( nProgramID, nBinaryFormat, (void*)(aBinary.data()), nBinaryLength );
 336
 337             // Check the program
 338             glGetProgramiv(nProgramID, GL_LINK_STATUS, &nResult);
 339         }
 340         return nResult;
 341     }
 342
 343     void saveProgramBinary( GLint nProgramID, const OString& rBinaryFileName )
 344     {
 345         GLint nBinaryLength = 0;
 346         GLenum nBinaryFormat = GL_NONE;
 347
 348         glGetProgramiv( nProgramID, GL_PROGRAM_BINARY_LENGTH, &nBinaryLength );
 349         if( !( nBinaryLength > 0 ) )
 350         {
 351             SAL_WARN( "vcl.opengl", "Binary size is zero" );
 352             return;
 353         }
 354
 355         std::vector<sal_uInt8> aBinary( nBinaryLength + GLenumSize );
 356
 357         glGetProgramBinary( nProgramID, nBinaryLength, NULL, &nBinaryFormat, (void*)(aBinary.data()) );
 358
 359         const sal_uInt8* pBF = (const sal_uInt8*)(&nBinaryFormat);
 360         aBinary.insert( aBinary.end(), pBF, pBF + GLenumSize );
 361
 362         SAL_INFO("vcl.opengl", "Program id: " << nProgramID );
 363         SAL_INFO("vcl.opengl", "Binary length: " << nBinaryLength );
 364         SAL_INFO("vcl.opengl", "Binary format: " << nBinaryFormat );
 365
 366         if( !writeProgramBinary( rBinaryFileName, aBinary ) )
 367             SAL_WARN("vcl.opengl", "Writing binary file '" << rBinaryFileName << "': FAIL");
 368         else
 369             SAL_WARN("vcl.opengl", "Writing binary file '" << rBinaryFileName << "': success");
 370     }
 371 }
 372
 373 rtl::OString OpenGLHelper::GetDigest( const OUString& rVertexShaderName,
 374                                       const OUString& rFragmentShaderName,
 375                                       const OString& rPreamble )
 376 {
 377     return getStringDigest(rVertexShaderName, rFragmentShaderName, rPreamble);
 378 }
 379
 380 GLint OpenGLHelper::LoadShaders(const OUString& rVertexShaderName,
 381                                 const OUString& rFragmentShaderName,
 382                                 const OString& preamble,
 383                                 const OString& rDigest)
 384 {
 385     OpenGLZone aZone;
 386
 387     gbInShaderCompile = true;
 388
 389     // create the program object
 390     GLint ProgramID = glCreateProgram();
 391
 392     // read shaders from file
 393     OString aVertexShaderSource = getShaderSource(rVertexShaderName);
 394     OString aFragmentShaderSource = getShaderSource(rFragmentShaderName);
 395
 396
 397     GLint bBinaryResult = GL_FALSE;
 398     if( GLEW_ARB_get_program_binary && !rDigest.isEmpty() )
 399     {
 400         OString aFileName =
 401                 createFileName(rVertexShaderName, rFragmentShaderName, rDigest);
 402         bBinaryResult = loadProgramBinary(ProgramID, aFileName);
 403         VCL_GL_INFO("vcl.opengl", "Load binary shader from '" << aFileName << "'" << bBinaryResult);
 404         CHECK_GL_ERROR();
 405     }
 406
 407     if( bBinaryResult != GL_FALSE )
 408         return ProgramID;
 409
 410     VCL_GL_INFO("vcl.opengl", "Load shader: vertex " << rVertexShaderName << " fragment " << rFragmentShaderName);
 411     // Create the shaders
 412     GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
 413     GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
 414
 415     GLint Result = GL_FALSE;
 416
 417     // Compile Vertex Shader
 418     if( !preamble.isEmpty())
 419         addPreamble( aVertexShaderSource, preamble );
 420     char const * VertexSourcePointer = aVertexShaderSource.getStr();
 421     glShaderSource(VertexShaderID, 1, &VertexSourcePointer , NULL);
 422     glCompileShader(VertexShaderID);
 423
 424     // Check Vertex Shader
 425     glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
 426     if (!Result)
 427         return LogCompilerError(VertexShaderID, "vertex",
 428                                 rVertexShaderName, true);
 429
 430     // Compile Fragment Shader
 431     if( !preamble.isEmpty())
 432         addPreamble( aFragmentShaderSource, preamble );
 433     char const * FragmentSourcePointer = aFragmentShaderSource.getStr();
 434     glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer , NULL);
 435     glCompileShader(FragmentShaderID);
 436
 437     // Check Fragment Shader
 438     glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
 439     if (!Result)
 440         return LogCompilerError(FragmentShaderID, "fragment",
 441                                 rFragmentShaderName, true);
 442
 443     // Link the program
 444     glAttachShader(ProgramID, VertexShaderID);
 445     glAttachShader(ProgramID, FragmentShaderID);
 446
 447     if( GLEW_ARB_get_program_binary && !rDigest.isEmpty() )
 448     {
 449         glProgramParameteri(ProgramID, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
 450         glLinkProgram(ProgramID);
 451         glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
 452         if (!Result)
 453         {
 454             SAL_WARN("vcl.opengl", "linking failed: " << Result );
 455             return LogCompilerError(ProgramID, "program", "<both>", false);
 456         }
 457         OString aFileName =
 458                 createFileName(rVertexShaderName, rFragmentShaderName, rDigest);
 459         saveProgramBinary(ProgramID, aFileName);
 460     }
 461     else
 462     {
 463         glLinkProgram(ProgramID);
 464     }
 465
 466     glDeleteShader(VertexShaderID);
 467     glDeleteShader(FragmentShaderID);
 468
 469     // Check the program
 470     glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
 471     if (!Result)
 472         return LogCompilerError(ProgramID, "program", "<both>", false);
 473
 474     CHECK_GL_ERROR();
 475
 476     // Ensure we bump our counts before we leave the shader zone.
 477     { OpenGLZone aMakeProgress; }
 478     gbInShaderCompile = false;
 479
 480     return ProgramID;
 481 }
 482
 483 void OpenGLHelper::ConvertBitmapExToRGBATextureBuffer(const BitmapEx& rBitmapEx, sal_uInt8* o_pRGBABuffer, const bool bFlip)
 484 {
 485     long nBmpWidth = rBitmapEx.GetSizePixel().Width();
 486     long nBmpHeight = rBitmapEx.GetSizePixel().Height();
 487
 488     Bitmap aBitmap (rBitmapEx.GetBitmap());
 489     AlphaMask aAlpha (rBitmapEx.GetAlpha());
 490     Bitmap::ScopedReadAccess pReadAccces( aBitmap );
 491     AlphaMask::ScopedReadAccess pAlphaReadAccess( aAlpha );
 492     size_t i = 0;
 493     for (long ny = (bFlip ? nBmpHeight - 1 : 0); (bFlip ? ny >= 0 : ny < nBmpHeight); (bFlip ? ny-- : ny++))
 494     {
 495         Scanline pAScan = pAlphaReadAccess ? pAlphaReadAccess->GetScanline(ny) : 0;
 496         for(long nx = 0; nx < nBmpWidth; nx++)
 497         {
 498             BitmapColor aCol = pReadAccces->GetColor( ny, nx );
 499             o_pRGBABuffer[i++] = aCol.GetRed();
 500             o_pRGBABuffer[i++] = aCol.GetGreen();
 501             o_pRGBABuffer[i++] = aCol.GetBlue();
 502             o_pRGBABuffer[i++] = pAScan ? 255 - *pAScan++ : 255;
 503         }
 504     }
 505 }
 506
 507 void OpenGLHelper::renderToFile(long nWidth, long nHeight, const OUString& rFileName)
 508 {
 509     OpenGLZone aZone;
 510
 511     boost::scoped_array<sal_uInt8> pBuffer(new sal_uInt8[nWidth*nHeight*4]);
 512     glReadPixels(0, 0, nWidth, nHeight, GL_BGRA, GL_UNSIGNED_BYTE, pBuffer.get());
 513     BitmapEx aBitmap = ConvertBGRABufferToBitmapEx(pBuffer.get(), nWidth, nHeight);
 514     try {
 515         vcl::PNGWriter aWriter( aBitmap );
 516         SvFileStream sOutput( rFileName, StreamMode::WRITE );
 517         aWriter.Write( sOutput );
 518         sOutput.Close();
 519     } catch (...) {
 520         SAL_WARN("vcl.opengl", "Error writing png to " << rFileName);
 521     }
 522
 523     CHECK_GL_ERROR();
 524 }
 525
 526 BitmapEx OpenGLHelper::ConvertBGRABufferToBitmapEx(const sal_uInt8* const pBuffer, long nWidth, long nHeight)
 527 {
 528     assert(pBuffer);
 529     Bitmap aBitmap( Size(nWidth, nHeight), 24 );
 530     AlphaMask aAlpha( Size(nWidth, nHeight) );
 531
 532     {
 533         Bitmap::ScopedWriteAccess pWriteAccess( aBitmap );
 534         AlphaMask::ScopedWriteAccess pAlphaWriteAccess( aAlpha );
 535
 536         size_t nCurPos = 0;
 537         for( int y = 0; y < nHeight; ++y)
 538         {
 539             Scanline pScan = pWriteAccess->GetScanline(y);
 540             Scanline pAlphaScan = pAlphaWriteAccess->GetScanline(y);
 541             for( int x = 0; x < nWidth; ++x )
 542             {
 543                 *pScan++ = pBuffer[nCurPos];
 544                 *pScan++ = pBuffer[nCurPos+1];
 545                 *pScan++ = pBuffer[nCurPos+2];
 546
 547                 nCurPos += 3;
 548                 *pAlphaScan++ = static_cast<sal_uInt8>( 255 - pBuffer[nCurPos++] );
 549             }
 550         }
 551     }
 552     return BitmapEx(aBitmap, aAlpha);
 553 }
 554
 555 const char* OpenGLHelper::GLErrorString(GLenum errorCode)
 556 {
 557     static const struct {
 558         GLenum code;
 559         const char *string;
 560     } errors[]=
 561     {
 562         /* GL */
 563         {GL_NO_ERROR, "no error"},
 564         {GL_INVALID_ENUM, "invalid enumerant"},
 565         {GL_INVALID_VALUE, "invalid value"},
 566         {GL_INVALID_OPERATION, "invalid operation"},
 567         {GL_STACK_OVERFLOW, "stack overflow"},
 568         {GL_STACK_UNDERFLOW, "stack underflow"},
 569         {GL_OUT_OF_MEMORY, "out of memory"},
 570         {GL_INVALID_FRAMEBUFFER_OPERATION, "invalid framebuffer operation"},
 571
 572         {0, NULL }
 573     };
 574
 575     int i;
 576
 577     for (i=0; errors[i].string; i++)
 578     {
 579         if (errors[i].code == errorCode)
 580         {
 581             return errors[i].string;
 582         }
 583      }
 584
 585     return NULL;
 586 }
 587
 588 std::ostream& operator<<(std::ostream& rStrm, const glm::vec4& rPos)
 589 {
 590     rStrm << "( " << rPos[0] << ", " << rPos[1] << ", " << rPos[2] << ", " << rPos[3] << ")";
 591     return rStrm;
 592 }
 593
 594 std::ostream& operator<<(std::ostream& rStrm, const glm::vec3& rPos)
 595 {
 596     rStrm << "( " << rPos[0] << ", " << rPos[1] << ", " << rPos[2] << ")";
 597     return rStrm;
 598 }
 599
 600 std::ostream& operator<<(std::ostream& rStrm, const glm::mat4& rMatrix)
 601 {
 602     for(int i = 0; i < 4; ++i)
 603     {
 604         rStrm << "\n( ";
 605         for(int j = 0; j < 4; ++j)
 606         {
 607             rStrm << rMatrix[j][i];
 608             rStrm << " ";
 609         }
 610         rStrm << ")\n";
 611     }
 612     return rStrm;
 613 }
 614
 615 void OpenGLHelper::createFramebuffer(long nWidth, long nHeight, GLuint& nFramebufferId,
 616         GLuint& nRenderbufferDepthId, GLuint& nRenderbufferColorId, bool bRenderbuffer)
 617 {
 618     OpenGLZone aZone;
 619
 620     // create a renderbuffer for depth attachment
 621     glGenRenderbuffers(1, &nRenderbufferDepthId);
 622     glBindRenderbuffer(GL_RENDERBUFFER, nRenderbufferDepthId);
 623     glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, nWidth, nHeight);
 624     glBindRenderbuffer(GL_RENDERBUFFER, 0);
 625
 626     if(bRenderbuffer)
 627     {
 628         // create a renderbuffer for color attachment
 629         glGenRenderbuffers(1, &nRenderbufferColorId);
 630         glBindRenderbuffer(GL_RENDERBUFFER, nRenderbufferColorId);
 631         glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, nWidth, nHeight);
 632         glBindRenderbuffer(GL_RENDERBUFFER, 0);
 633     }
 634     else
 635     {
 636         glGenTextures(1, &nRenderbufferColorId);
 637         glBindTexture(GL_TEXTURE_2D, nRenderbufferColorId);
 638         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 639         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
 640         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 641         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 642         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, nWidth, nHeight, 0,
 643                              GL_RGBA, GL_UNSIGNED_BYTE, 0);
 644         glBindTexture(GL_TEXTURE_2D, 0);
 645
 646         glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
 647                 GL_TEXTURE_2D, nRenderbufferColorId, 0);
 648     }
 649
 650     // create a framebuffer object and attach renderbuffer
 651     glGenFramebuffers(1, &nFramebufferId);
 652     glCheckFramebufferStatus(GL_FRAMEBUFFER);
 653     glBindFramebuffer(GL_FRAMEBUFFER, nFramebufferId);
 654     // attach a renderbuffer to FBO color attachment point
 655     glBindRenderbuffer(GL_RENDERBUFFER, nRenderbufferColorId);
 656     glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, nRenderbufferColorId);
 657     glCheckFramebufferStatus(GL_FRAMEBUFFER);
 658     // attach a renderbuffer to depth attachment point
 659     glBindRenderbuffer(GL_RENDERBUFFER, nRenderbufferDepthId);
 660     glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, nRenderbufferDepthId);
 661     GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
 662     if (status != GL_FRAMEBUFFER_COMPLETE)
 663     {
 664         SAL_WARN("vcl.opengl", "invalid framebuffer status");
 665     }
 666     glBindRenderbuffer(GL_RENDERBUFFER, 0);
 667     glBindFramebuffer(GL_FRAMEBUFFER, 0);
 668
 669     CHECK_GL_ERROR();
 670 }
 671
 672 float OpenGLHelper::getGLVersion()
 673 {
 674     float fVersion = 1.0;
 675     const GLubyte* aVersion = glGetString( GL_VERSION );
 676     if( aVersion && aVersion[0] )
 677     {
 678         fVersion = aVersion[0] - '0';
 679         if( aVersion[1] == '.' && aVersion[2] )
 680         {
 681             fVersion += (aVersion[2] - '0')/10.0;
 682         }
 683     }
 684
 685     CHECK_GL_ERROR();
 686     return fVersion;
 687 }
 688
 689 void OpenGLHelper::checkGLError(const char* pFile, size_t nLine)
 690 {
 691     OpenGLZone aZone;
 692
 693     int nErrors = 0;
 694     for (;;)
 695     {
 696         GLenum glErr = glGetError();
 697         if (glErr == GL_NO_ERROR)
 698         {
 699             break;
 700         }
 701         const char* sError = OpenGLHelper::GLErrorString(glErr);
 702
 703         if (sError)
 704             SAL_WARN("vcl.opengl", "GL Error #" << glErr << "(" << sError << ") in File " << pFile << " at line: " << nLine);
 705         else
 706             SAL_WARN("vcl.opengl", "GL Error #" << glErr << " (no message available) in File " << pFile << " at line: " << nLine);
 707
 708         // tdf#93798 - apitrace appears to sometimes cause issues with an infinite loop here.
 709         if (++nErrors >= 8)
 710         {
 711             SAL_WARN("vcl.opengl", "Breaking potentially recursive glGetError loop");
 712             break;
 713         }
 714     }
 715 }
 716
 717 bool OpenGLHelper::isDeviceBlacklisted()
 718 {
 719     static bool bSet = false;
 720     static bool bBlacklisted = true; // assume the worst
 721     if (!bSet)
 722     {
 723         OpenGLZone aZone;
 724
 725 #if defined UNX && !defined MACOSX && !defined IOS && !defined ANDROID
 726         X11OpenGLDeviceInfo aInfo;
 727         bBlacklisted = aInfo.isDeviceBlocked();
 728         SAL_INFO("vcl.opengl", "blacklisted: " << bBlacklisted);
 729 #elif defined( _WIN32 )
 730         WinOpenGLDeviceInfo aInfo;
 731         bBlacklisted = aInfo.isDeviceBlocked();
 732 #else
 733         bBlacklisted = false;
 734 #endif
 735         bSet = true;
 736     }
 737
 738     return bBlacklisted;
 739 }
 740
 741 bool OpenGLHelper::supportsVCLOpenGL()
 742 {
 743     static bool bDisableGL = !!getenv("SAL_DISABLEGL");
 744     bool bBlacklisted = isDeviceBlacklisted();
 745
 746     if (bDisableGL || bBlacklisted)
 747         return false;
 748     else
 749         return true;
 750 }
 751
 752 void OpenGLZone::enter() { gnEnterCount++; }
 753 void OpenGLZone::leave() { gnLeaveCount++; }
 754
 755 namespace {
 756     static volatile bool gbWatchdogFiring = false;
 757     static oslCondition gpWatchdogExit = NULL;
 758     static rtl::Reference<OpenGLWatchdogThread> gxWatchdog;
 759 }
 760
 761 OpenGLWatchdogThread::OpenGLWatchdogThread()
 762     : salhelper::Thread("OpenGL Watchdog")
 763 {
 764 }
 765
 766 void OpenGLWatchdogThread::execute()
 767 {
 768     // delays to take various actions in 1/4 of a second increments.
 769     static const int nDisableEntries[2] = { 6 /* 1.5s */, 20 /* 5s */ };
 770     static const int nAbortAfter[2]     = { 20 /* 10s */, 120 /* 30s */ };
 771
 772     int nUnchanged = 0; // how many unchanged nEnters
 773
 774     TimeValue aHalfSecond;
 775     aHalfSecond.Seconds = 0;
 776     aHalfSecond.Nanosec = 1000*1000*1000/4;
 777
 778     bool bAbortFired = false;
 779
 780     do {
 781         sal_uInt64 nLastEnters = OpenGLZone::gnEnterCount;
 782
 783         osl_waitCondition(gpWatchdogExit, &aHalfSecond);
 784
 785         if (OpenGLZone::isInZone())
 786         {
 787             int nType = 0;
 788             // The shader compiler can take a long time, first time.
 789             if (gbInShaderCompile)
 790                 nType = 1;
 791
 792             if (nLastEnters == OpenGLZone::gnEnterCount)
 793                 nUnchanged++;
 794             else
 795                 nUnchanged = 0;
 796             SAL_INFO("vcl.opengl", "GL watchdog - unchanged " <<
 797                      nUnchanged << " enter count " <<
 798                      OpenGLZone::gnEnterCount << " type " <<
 799                      (nType ? "in shader" : "normal gl") <<
 800                      "breakpoints mid: " << nDisableEntries[nType] <<
 801                      " max " << nAbortAfter[nType]);
 802
 803             // Not making progress
 804             if (nUnchanged >= nDisableEntries[nType])
 805             {
 806                 static bool bFired = false;
 807                 if (!bFired)
 808                 {
 809                     gbWatchdogFiring = true;
 810                     SAL_WARN("vcl.opengl", "Watchdog triggered: hard disable GL");
 811                     OpenGLZone::hardDisable();
 812                     gbWatchdogFiring = false;
 813                 }
 814                 bFired = true;
 815
 816                 // we can hang using VCL in the abort handling -> be impatient
 817                 if (bAbortFired)
 818                 {
 819                     SAL_WARN("vcl.opengl", "Watchdog gave up: hard exiting");
 820                     _exit(1);
 821                 }
 822             }
 823
 824             // Not making even more progress
 825             if (nUnchanged >= nAbortAfter[nType])
 826             {
 827                 if (!bAbortFired)
 828                 {
 829                     SAL_WARN("vcl.opengl", "Watchdog gave up: aborting");
 830                     gbWatchdogFiring = true;
 831                     nUnchanged = 0;
 832                     std::abort();
 833                 }
 834                 bAbortFired = true;
 835             }
 836         }
 837         else
 838         {
 839             nUnchanged = 0;
 840         }
 841     } while (!osl_checkCondition(gpWatchdogExit));
 842 }
 843
 844 void OpenGLWatchdogThread::start()
 845 {
 846     assert (gxWatchdog == NULL);
 847     gpWatchdogExit = osl_createCondition();
 848     gxWatchdog = rtl::Reference<OpenGLWatchdogThread>(new OpenGLWatchdogThread());
 849     gxWatchdog->launch();
 850 }
 851
 852 void OpenGLWatchdogThread::stop()
 853 {
 854     if (gbWatchdogFiring)
 855         return; // in watchdog thread
 856
 857     if (gpWatchdogExit)
 858         osl_setCondition(gpWatchdogExit);
 859
 860     if (gxWatchdog.is())
 861     {
 862         gxWatchdog->join();
 863         gxWatchdog.clear();
 864     }
 865
 866     if (gpWatchdogExit)
 867         osl_destroyCondition(gpWatchdogExit);
 868     gpWatchdogExit = NULL;
 869 }
 870
 871 /**
 872  * Called from a signal handler or watchdog thread if we get
 873  * a crash or hang in some GL code.
 874  */
 875 void OpenGLZone::hardDisable()
 876 {
 877     // protect ourselves from double calling etc.
 878     static bool bDisabled = false;
 879     if (!bDisabled)
 880     {
 881         bDisabled = true;
 882
 883         // Disable the OpenGL support
 884         std::shared_ptr<comphelper::ConfigurationChanges> xChanges(
 885             comphelper::ConfigurationChanges::create());
 886         officecfg::Office::Common::VCL::UseOpenGL::set(false,  xChanges);
 887         xChanges->commit();
 888
 889         // Force synchronous config write
 890         css::uno::Reference< css::util::XFlushable >(
 891             css::configuration::theDefaultProvider::get(
 892                 comphelper::getProcessComponentContext()),
 893             css::uno::UNO_QUERY_THROW)->flush();
 894
 895         OpenGLWatchdogThread::stop();
 896     }
 897 }
 898
 899 bool OpenGLHelper::isVCLOpenGLEnabled()
 900 {
 901     /**
 902      * The !bSet part should only be called once! Changing the results in the same
 903      * run will mix OpenGL and normal rendering.
 904      */
 905     static bool bSet = false;
 906     static bool bEnable = false;
 907     static bool bForceOpenGL = false;
 908
 909     // If we are a console app, then we don't use OpenGL
 910     if ( Application::IsConsoleOnly() )
 911         return false;
 912
 913     if (bSet)
 914     {
 915         return bForceOpenGL || bEnable;
 916     }
 917     /*
 918      * There are a number of cases that these environment variables cover:
 919      *  * SAL_FORCEGL forces OpenGL independent of any other option
 920      *  * SAL_DISABLEGL or a blacklisted driver avoid the use of OpenGL if SAL_FORCEGL is not set
 921      *  * SAL_ENABLEGL overrides VCL_HIDE_WINDOWS and the configuration variable
 922      *  * the configuration variable is checked if no environment variable is set
 923      */
 924
 925     bSet = true;
 926     bForceOpenGL = !!getenv("SAL_FORCEGL") || officecfg::Office::Common::VCL::ForceOpenGL::get();
 927
 928     bool bRet = false;
 929     if (bForceOpenGL)
 930         bRet = true;
 931
 932     else if (!supportsVCLOpenGL())
 933         bRet = false;
 934     else
 935     {
 936         static bool bEnableGLEnv = !!getenv("SAL_ENABLEGL");
 937
 938         bEnable = bEnableGLEnv;
 939
 940         static bool bDuringBuild = getenv("VCL_HIDE_WINDOWS");
 941         if (bDuringBuild && !bEnable /* env. enable overrides */)
 942             bEnable = false;
 943         else if (officecfg::Office::Common::VCL::UseOpenGL::get())
 944             bEnable = true;
 945
 946         bRet = bEnable;
 947     }
 948     if (bRet)
 949     {
 950         if (!getenv("SAL_DISABLE_GL_WATCHDOG"))
 951             OpenGLWatchdogThread::start();
 952         ImplGetSVData()->maWinData.mbNoSaveBackground = true;
 953     }
 954
 955     return bRet;
 956 }
 957
 958 bool OpenGLWrapper::isVCLOpenGLEnabled()
 959 {
 960     return OpenGLHelper::isVCLOpenGLEnabled();
 961 }
 962
 963 void OpenGLHelper::debugMsgStream(const char *pArea, std::ostringstream const &pStream)
 964 {
 965     debugMsgPrint(pArea, "%s", pStream.str().c_str());
 966 }
 967
 968 void OpenGLHelper::debugMsgPrint(const char *pArea, const char *pFormat, ...)
 969 {
 970     va_list aArgs;
 971     va_start (aArgs, pFormat);
 972
 973     char pStr[1044];
 974 #ifdef _WIN32
 975 #define vsnprintf _vsnprintf
 976 #endif
 977     vsnprintf(pStr, sizeof(pStr), pFormat, aArgs);
 978     pStr[sizeof(pStr)-20] = '\0';
 979
 980     bool bHasContext = OpenGLContext::hasCurrent();
 981     if (!bHasContext)
 982         strcat(pStr, "- no GL context");
 983
 984     SAL_INFO(pArea, pStr);
 985
 986     if (bHasContext)
 987     {
 988         OpenGLZone aZone;
 989
 990         if (GLEW_KHR_debug)
 991             glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION,
 992                                  GL_DEBUG_TYPE_OTHER,
 993                                  1, // one[sic] id is as good as another ?
 994                                  // GL_DEBUG_SEVERITY_NOTIFICATION for >= GL4.3 ?
 995                                  GL_DEBUG_SEVERITY_LOW,
 996                                  strlen(pStr), pStr);
 997         else if (GLEW_AMD_debug_output)
 998             glDebugMessageInsertAMD(GL_DEBUG_CATEGORY_APPLICATION_AMD,
 999                                     GL_DEBUG_SEVERITY_LOW_AMD,
1000                                     1, // one[sic] id is as good as another ?
1001                                     strlen(pStr), pStr);
1002     }
1003
1004     va_end (aArgs);
1005 }
1006
1007 #if defined UNX && !defined MACOSX && !defined IOS && !defined ANDROID && !defined(LIBO_HEADLESS)
1008
1009 bool OpenGLHelper::GetVisualInfo(Display* pDisplay, int nScreen, XVisualInfo& rVI)
1010 {
1011     OpenGLZone aZone;
1012
1013     XVisualInfo* pVI;
1014     int aAttrib[] = { GLX_RGBA,
1015                       GLX_RED_SIZE, 8,
1016                       GLX_GREEN_SIZE, 8,
1017                       GLX_BLUE_SIZE, 8,
1018                       GLX_DEPTH_SIZE, 24,
1019                       GLX_STENCIL_SIZE, 8,
1020                       None };
1021
1022     pVI = glXChooseVisual( pDisplay, nScreen, aAttrib );
1023     if( !pVI )
1024         return false;
1025
1026     rVI = *pVI;
1027     XFree( pVI );
1028
1029     CHECK_GL_ERROR();
1030     return true;
1031 }
1032
1033 GLXFBConfig OpenGLHelper::GetPixmapFBConfig( Display* pDisplay, bool& bInverted )
1034 {
1035     OpenGLZone aZone;
1036
1037     int nScreen = DefaultScreen( pDisplay );
1038     GLXFBConfig *aFbConfigs;
1039     int i, nFbConfigs, nValue;
1040
1041     aFbConfigs = glXGetFBConfigs( pDisplay, nScreen, &nFbConfigs );
1042     for( i = 0; i < nFbConfigs; i++ )
1043     {
1044         glXGetFBConfigAttrib( pDisplay, aFbConfigs[i], GLX_DRAWABLE_TYPE, &nValue );
1045         if( !(nValue & GLX_PIXMAP_BIT) )
1046             continue;
1047
1048         glXGetFBConfigAttrib( pDisplay, aFbConfigs[i], GLX_BIND_TO_TEXTURE_TARGETS_EXT, &nValue );
1049         if( !(nValue & GLX_TEXTURE_2D_BIT_EXT) )
1050             continue;
1051
1052         glXGetFBConfigAttrib( pDisplay, aFbConfigs[i], GLX_DEPTH_SIZE, &nValue );
1053         if( nValue != 24 )
1054             continue;
1055
1056         glXGetFBConfigAttrib( pDisplay, aFbConfigs[i], GLX_RED_SIZE, &nValue );
1057         if( nValue != 8 )
1058             continue;
1059         SAL_INFO( "vcl.opengl", "Red is " << nValue );
1060
1061         // TODO: lfrb: Make it configurable wrt RGB/RGBA
1062         glXGetFBConfigAttrib( pDisplay, aFbConfigs[i], GLX_BIND_TO_TEXTURE_RGB_EXT, &nValue );
1063         if( nValue == False )
1064         {
1065             glXGetFBConfigAttrib( pDisplay, aFbConfigs[i], GLX_BIND_TO_TEXTURE_RGBA_EXT, &nValue );
1066             if( nValue == False )
1067                 continue;
1068         }
1069
1070         glXGetFBConfigAttrib( pDisplay, aFbConfigs[i], GLX_Y_INVERTED_EXT, &nValue );
1071
1072         // Looks like that X sends GLX_DONT_CARE but this usually means "true" for most
1073         // of the X implementations. Investigation on internet pointed that this could be
1074         // safely "true" all the time (for example gnome-shell always assumes "true").
1075         bInverted = nValue == True || nValue == int(GLX_DONT_CARE);
1076
1077         break;
1078     }
1079
1080     if( i == nFbConfigs )
1081     {
1082         SAL_WARN( "vcl.opengl", "Unable to find FBconfig for pixmap texturing" );
1083         return 0;
1084     }
1085
1086     CHECK_GL_ERROR();
1087     return aFbConfigs[i];
1088 }
1089
1090 #endif
1091
1092 OutputDevice::PaintScope::PaintScope(OutputDevice *pDev)
1093     : pHandle( NULL )
1094 {
1095     if( pDev->mpGraphics || pDev->AcquireGraphics() )
1096     {
1097         OpenGLContext *pContext = pDev->mpGraphics->BeginPaint();
1098         if( pContext )
1099         {
1100             assert( pContext->mnPainting >= 0 );
1101             pContext->mnPainting++;
1102             pContext->acquire();
1103             pHandle = static_cast<void *>( pContext );
1104         }
1105     }
1106 }
1107
1108 /**
1109  * Flush all the queued rendering commands to the screen for this context.
1110  */
1111 void OutputDevice::PaintScope::flush()
1112 {
1113     if( pHandle )
1114     {
1115         OpenGLContext *pContext = static_cast<OpenGLContext *>( pHandle );
1116         pHandle = NULL;
1117         pContext->mnPainting--;
1118         assert( pContext->mnPainting >= 0 );
1119         if( pContext->mnPainting == 0 )
1120         {
1121             pContext->makeCurrent();
1122             pContext->AcquireDefaultFramebuffer();
1123             glFlush();
1124             pContext->swapBuffers();
1125             CHECK_GL_ERROR();
1126         }
1127         pContext->release();
1128     }
1129 }
1130
1131 OutputDevice::PaintScope::~PaintScope()
1132 {
1133     flush();
1134 }
1135
1136 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */