dali/internal/graphics/gles-impl/gles-graphics-texture.cpp

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include "gles-graphics-texture.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/integration-api/debug.h>
  23 #include <dali/integration-api/gl-abstraction.h>
  24 #include <dali/integration-api/gl-defines.h>
  25 #include <vector>
  26
  27 // INTERNAL INCLUDES
  28 #include "egl-graphics-controller.h"
  29 #include "gles-graphics-sampler.h"
  30 #include "gles-graphics-types.h"
  31
  32 namespace
  33 {
  34 // These match the GL specification
  35 //const int32_t GL_MINIFY_DEFAULT  = GL_NEAREST_MIPMAP_LINEAR;
  36 //const int32_t GL_MAGNIFY_DEFAULT = GL_LINEAR;
  37 const int32_t GL_WRAP_DEFAULT = GL_CLAMP_TO_EDGE;
  38
  39 // These are the Dali defaults
  40 const int32_t DALI_MINIFY_DEFAULT  = GL_LINEAR;
  41 const int32_t DALI_MAGNIFY_DEFAULT = GL_LINEAR;
  42 } // namespace
  43
  44 namespace Dali::Graphics::GLES
  45 {
  46 struct ColorConversion
  47 {
  48   Format srcFormat;
  49   Format destFormat;
  50   std::vector<uint8_t> (*pConversionFunc)(const void*, uint32_t, uint32_t, uint32_t, uint32_t);
  51   void (*pConversionWriteFunc)(const void*, uint32_t, uint32_t, uint32_t, uint32_t, void*);
  52 };
  53
  54 inline void WriteRGB32ToRGBA32(const void* pData, uint32_t sizeInBytes, uint32_t width, uint32_t height, uint32_t rowStride, void* pOutput)
  55 {
  56   auto inData  = reinterpret_cast<const uint8_t*>(pData);
  57   auto outData = reinterpret_cast<uint8_t*>(pOutput);
  58   auto outIdx  = 0u;
  59   for(auto i = 0u; i < sizeInBytes; i += 3)
  60   {
  61     outData[outIdx]     = inData[i];
  62     outData[outIdx + 1] = inData[i + 1];
  63     outData[outIdx + 2] = inData[i + 2];
  64     outData[outIdx + 3] = 0xff;
  65     outIdx += 4;
  66   }
  67 }
  68
  69 /**
  70  * Converts RGB to RGBA
  71  */
  72 inline std::vector<uint8_t> ConvertRGB32ToRGBA32(const void* pData, uint32_t sizeInBytes, uint32_t width, uint32_t height, uint32_t rowStride)
  73 {
  74   std::vector<uint8_t> rgbaBuffer{};
  75   rgbaBuffer.resize(width * height * 4);
  76   WriteRGB32ToRGBA32(pData, sizeInBytes, width, height, rowStride, &rgbaBuffer[0]);
  77   return rgbaBuffer;
  78 }
  79
  80 /**
  81  * Format conversion table
  82  */
  83 static const std::vector<ColorConversion> COLOR_CONVERSION_TABLE = {
  84   {Format::R8G8B8_UNORM, Format::R8G8B8A8_UNORM, ConvertRGB32ToRGBA32, WriteRGB32ToRGBA32}};
  85
  86 /**
  87  * Constructor
  88  */
  89 Texture::Texture(const Graphics::TextureCreateInfo& createInfo, Graphics::EglGraphicsController& controller)
  90 : TextureResource(createInfo, controller)
  91 {
  92   // If there is any data, move it into staging buffer
  93   if(mCreateInfo.data && mCreateInfo.dataSize)
  94   {
  95     mStagingBuffer.resize(size_t(mCreateInfo.dataSize));
  96     std::copy(reinterpret_cast<char*>(mCreateInfo.data),
  97               reinterpret_cast<char*>(mCreateInfo.data) + mCreateInfo.dataSize,
  98               mStagingBuffer.begin());
  99   }
 100
 101   // Add texture to the Resource queue
 102   mController.AddTexture(*this);
 103 }
 104
 105 bool Texture::InitializeResource()
 106 {
 107   if(mCreateInfo.nativeImagePtr)
 108   {
 109     return InitializeNativeImage();
 110   }
 111   return InitializeTexture();
 112 }
 113
 114 bool Texture::InitializeNativeImage()
 115 {
 116   auto   gl = mController.GetGL();
 117   GLuint texture{0};
 118
 119   if(!gl)
 120   {
 121     // Do nothing during shutdown
 122     return false;
 123   }
 124
 125   NativeImageInterfacePtr nativeImage = mCreateInfo.nativeImagePtr;
 126   bool                    created     = nativeImage->CreateResource();
 127   mGlTarget                           = nativeImage->GetTextureTarget();
 128   if(created)
 129   {
 130     gl->GenTextures(1, &texture);
 131     gl->BindTexture(mGlTarget, texture);
 132
 133     gl->PixelStorei(GL_UNPACK_ALIGNMENT, 1); // We always use tightly packed data
 134
 135     // Apply default sampling parameters
 136     gl->TexParameteri(mGlTarget, GL_TEXTURE_MIN_FILTER, DALI_MINIFY_DEFAULT);
 137     gl->TexParameteri(mGlTarget, GL_TEXTURE_MAG_FILTER, DALI_MAGNIFY_DEFAULT);
 138     gl->TexParameteri(mGlTarget, GL_TEXTURE_WRAP_S, GL_WRAP_DEFAULT);
 139     gl->TexParameteri(mGlTarget, GL_TEXTURE_WRAP_T, GL_WRAP_DEFAULT);
 140
 141     // platform specific implementation decides on what GL extension to use
 142     if(nativeImage->TargetTexture() != 0u)
 143     {
 144       gl->DeleteTextures(1, &texture);
 145       nativeImage->DestroyResource();
 146       texture = 0u;
 147       created = false;
 148     }
 149     else
 150     {
 151       mTextureId = texture;
 152     }
 153   }
 154   else
 155   {
 156     DALI_LOG_ERROR("Native Image: InitializeNativeImage, CreateResource() failed\n");
 157   }
 158
 159   return created; // WARNING! May be false! Needs handling! (Well, initialized on bind)
 160 }
 161
 162 bool Texture::InitializeTexture()
 163 {
 164   auto gl = mController.GetGL();
 165   if(!gl)
 166   {
 167     // Do nothing during shutdown
 168     return false;
 169   }
 170
 171   GLuint texture{0};
 172
 173   mGlTarget = GLTextureTarget(mCreateInfo.textureType).target;
 174
 175   switch(mCreateInfo.textureType)
 176   {
 177     // Texture 2D
 178     case Graphics::TextureType::TEXTURE_2D:
 179     {
 180       Graphics::GLES::GLTextureFormatType format(mCreateInfo.format);
 181
 182       // TODO: find better condition, with this test the L8 doesn't work
 183       if(1) //format.format && format.type)
 184       {
 185         // Bind texture
 186         gl->GenTextures(1, &texture);
 187         gl->BindTexture(GL_TEXTURE_2D, texture);
 188
 189         // Allocate memory for the texture
 190         gl->TexImage2D(GL_TEXTURE_2D,
 191                        0,
 192                        format.format,
 193                        mCreateInfo.size.width,
 194                        mCreateInfo.size.height,
 195                        0,
 196                        format.format,
 197                        format.type,
 198                        (mCreateInfo.data ? mStagingBuffer.data() : nullptr));
 199
 200         // Clear staging buffer if there was any
 201         mStagingBuffer.clear();
 202         mTextureId = texture;
 203
 204         // Default texture filtering (to be set later via command buffer binding)
 205         gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, Graphics::GLES::GLSamplerFilterAndMipMapMode(Graphics::SamplerFilter::LINEAR, SamplerMipmapMode::NONE));
 206         gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, Graphics::GLES::GLSamplerFilterAndMipMapMode(Graphics::SamplerFilter::LINEAR, SamplerMipmapMode::NONE));
 207         gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_WRAP_DEFAULT);
 208         gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_WRAP_DEFAULT);
 209       }
 210       break;
 211     }
 212     // Texture Cubemap
 213     case Graphics::TextureType::TEXTURE_CUBEMAP:
 214     {
 215       Graphics::GLES::GLTextureFormatType format(mCreateInfo.format);
 216
 217       if(format.format && format.type)
 218       {
 219         // Bind texture
 220         gl->GenTextures(1, &texture);
 221         gl->BindTexture(GL_TEXTURE_CUBE_MAP, texture);
 222         gl->PixelStorei(GL_UNPACK_ALIGNMENT, 1); // We always use tightly packed data
 223
 224         gl->TexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, Graphics::GLES::GLSamplerFilterAndMipMapMode(Graphics::SamplerFilter::LINEAR, SamplerMipmapMode::NONE));
 225         gl->TexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, Graphics::GLES::GLSamplerFilterAndMipMapMode(Graphics::SamplerFilter::LINEAR, SamplerMipmapMode::NONE));
 226         gl->TexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_WRAP_DEFAULT);
 227         gl->TexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_WRAP_DEFAULT);
 228
 229         // Allocate memory for the texture
 230         for(uint32_t i = 0; i < 6; ++i)
 231         {
 232           gl->TexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i,
 233                          0,
 234                          format.format,
 235                          mCreateInfo.size.width,
 236                          mCreateInfo.size.height,
 237                          0,
 238                          format.format,
 239                          format.type,
 240                          (mCreateInfo.data ? mStagingBuffer.data() : nullptr));
 241         }
 242
 243         // Clear staging buffer if there was any
 244         mStagingBuffer.clear();
 245
 246         mTextureId = texture;
 247
 248         gl->TexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_WRAP_DEFAULT);
 249       }
 250       break;
 251     }
 252     default:
 253     {
 254       // nothing?
 255     }
 256   }
 257   return true;
 258 }
 259
 260 void Texture::DestroyResource()
 261 {
 262   auto gl = mController.GetGL();
 263   if(!gl)
 264   {
 265     return;
 266   }
 267
 268   // This is a proper destructor
 269   if(mTextureId)
 270   {
 271     gl->DeleteTextures(1, &mTextureId);
 272   }
 273   if(mCreateInfo.nativeImagePtr)
 274   {
 275     mCreateInfo.nativeImagePtr->DestroyResource();
 276   }
 277 }
 278
 279 void Texture::DiscardResource()
 280 {
 281   mController.DiscardResource(this);
 282 }
 283
 284 void Texture::Bind(const TextureBinding& binding) const
 285 {
 286   auto gl = mController.GetGL();
 287   if(!gl)
 288   {
 289     // Do nothing during shutdown
 290     return;
 291   }
 292
 293   gl->ActiveTexture(GL_TEXTURE0 + binding.binding);
 294   gl->BindTexture(mGlTarget, mTextureId);
 295
 296   // For GLES2 if there is a sampler set in the binding
 297   if(binding.sampler)
 298   {
 299     // Non-default.
 300     auto*       sampler           = static_cast<const GLES::Sampler*>(binding.sampler);
 301     const auto& samplerCreateInfo = sampler->GetCreateInfo();
 302
 303     auto mipMapMode = samplerCreateInfo.mipMapMode;
 304
 305     gl->TexParameteri(mGlTarget, GL_TEXTURE_MIN_FILTER, GLSamplerFilterAndMipMapMode(samplerCreateInfo.minFilter, mipMapMode).glFilter);
 306     gl->TexParameteri(mGlTarget, GL_TEXTURE_MAG_FILTER, GLSamplerFilter(samplerCreateInfo.magFilter).glFilter);
 307     gl->TexParameteri(mGlTarget, GL_TEXTURE_WRAP_S, GLAddressMode(samplerCreateInfo.addressModeU).texParameter);
 308     gl->TexParameteri(mGlTarget, GL_TEXTURE_WRAP_T, GLAddressMode(samplerCreateInfo.addressModeV).texParameter);
 309     if(mGlTarget == GL_TEXTURE_CUBE_MAP)
 310     {
 311       gl->TexParameteri(mGlTarget, GL_TEXTURE_WRAP_R, GLAddressMode(samplerCreateInfo.addressModeW).texParameter);
 312     }
 313   }
 314   else
 315   {
 316     gl->TexParameteri(mGlTarget, GL_TEXTURE_MIN_FILTER, DALI_MINIFY_DEFAULT);
 317     gl->TexParameteri(mGlTarget, GL_TEXTURE_MAG_FILTER, DALI_MAGNIFY_DEFAULT);
 318     gl->TexParameteri(mGlTarget, GL_TEXTURE_WRAP_S, GL_WRAP_DEFAULT);
 319     gl->TexParameteri(mGlTarget, GL_TEXTURE_WRAP_T, GL_WRAP_DEFAULT);
 320     if(mGlTarget == GL_TEXTURE_CUBE_MAP)
 321     {
 322       gl->TexParameteri(mGlTarget, GL_TEXTURE_WRAP_R, GL_WRAP_DEFAULT);
 323     }
 324   }
 325
 326   if(mMaxMipMapLevel)
 327   {
 328     gl->TexParameteri(mGlTarget, GL_TEXTURE_MAX_LEVEL, mMaxMipMapLevel);
 329   }
 330 }
 331
 332 void Texture::Prepare()
 333 {
 334   NativeImageInterfacePtr nativeImage = mCreateInfo.nativeImagePtr;
 335   if(nativeImage)
 336   {
 337     if(nativeImage->SourceChanged())
 338     {
 339       // Update size
 340       uint32_t width  = mCreateInfo.nativeImagePtr->GetWidth();
 341       uint32_t height = mCreateInfo.nativeImagePtr->GetHeight();
 342       mCreateInfo.SetSize({width, height}); // Size may change
 343     }
 344
 345     nativeImage->PrepareTexture();
 346   }
 347 }
 348
 349 /**
 350  * This function tests whether format is supported by the driver. If possible it applies
 351  * format conversion to suitable supported pixel format.
 352  */
 353 bool Texture::TryConvertPixelData(const void* pData, Graphics::Format srcFormat, Graphics::Format destFormat, uint32_t sizeInBytes, uint32_t width, uint32_t height, std::vector<uint8_t>& outputBuffer)
 354 {
 355   // No need to convert
 356   if(srcFormat == destFormat)
 357   {
 358     return false;
 359   }
 360
 361   auto it = std::find_if(COLOR_CONVERSION_TABLE.begin(), COLOR_CONVERSION_TABLE.end(), [&](auto& item) {
 362     return item.srcFormat == srcFormat && item.destFormat == destFormat;
 363   });
 364
 365   // No suitable format, return empty array
 366   if(it == COLOR_CONVERSION_TABLE.end())
 367   {
 368     return false;
 369   }
 370   auto begin = reinterpret_cast<const uint8_t*>(pData);
 371
 372   outputBuffer = std::move(it->pConversionFunc(begin, sizeInBytes, width, height, 0u));
 373   return !outputBuffer.empty();
 374 }
 375
 376 } // namespace Dali::Graphics::GLES