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       }
 208       break;
 209     }
 210     default:
 211     {
 212       // nothing?
 213     }
 214   }
 215   return true;
 216 }
 217
 218 void Texture::DestroyResource()
 219 {
 220   auto gl = mController.GetGL();
 221   if(!gl)
 222   {
 223     return;
 224   }
 225
 226   // This is a proper destructor
 227   if(mTextureId)
 228   {
 229     gl->DeleteTextures(1, &mTextureId);
 230   }
 231   if(mCreateInfo.nativeImagePtr)
 232   {
 233     mCreateInfo.nativeImagePtr->DestroyResource();
 234   }
 235 }
 236
 237 void Texture::DiscardResource()
 238 {
 239   mController.DiscardResource(this);
 240 }
 241
 242 void Texture::Bind(const TextureBinding& binding) const
 243 {
 244   auto gl = mController.GetGL();
 245   if(!gl)
 246   {
 247     // Do nothing during shutdown
 248     return;
 249   }
 250
 251   gl->ActiveTexture(GL_TEXTURE0 + binding.binding);
 252   gl->BindTexture(mGlTarget, mTextureId);
 253
 254   // For GLES2 if there is a sampler set in the binding
 255   if(binding.sampler)
 256   {
 257     // Non-default.
 258     auto*       sampler           = static_cast<const GLES::Sampler*>(binding.sampler);
 259     const auto& samplerCreateInfo = sampler->GetCreateInfo();
 260
 261     auto mipMapMode = samplerCreateInfo.mipMapMode;
 262     mipMapMode      = Graphics::SamplerMipmapMode::NONE; // @todo Remove when mip-map generation is supported
 263
 264     gl->TexParameteri(mGlTarget, GL_TEXTURE_MIN_FILTER, GLSamplerFilterAndMipMapMode(samplerCreateInfo.minFilter, mipMapMode).glFilter);
 265     gl->TexParameteri(mGlTarget, GL_TEXTURE_MAG_FILTER, GLSamplerFilter(samplerCreateInfo.magFilter).glFilter);
 266     gl->TexParameteri(mGlTarget, GL_TEXTURE_WRAP_S, GLAddressMode(samplerCreateInfo.addressModeU).texParameter);
 267     gl->TexParameteri(mGlTarget, GL_TEXTURE_WRAP_T, GLAddressMode(samplerCreateInfo.addressModeV).texParameter);
 268     if(mGlTarget == GL_TEXTURE_CUBE_MAP)
 269     {
 270       gl->TexParameteri(mGlTarget, GL_TEXTURE_WRAP_R, GLAddressMode(samplerCreateInfo.addressModeW).texParameter);
 271     }
 272   }
 273   else
 274   {
 275     gl->TexParameteri(mGlTarget, GL_TEXTURE_MIN_FILTER, DALI_MINIFY_DEFAULT);
 276     gl->TexParameteri(mGlTarget, GL_TEXTURE_MAG_FILTER, DALI_MAGNIFY_DEFAULT);
 277     gl->TexParameteri(mGlTarget, GL_TEXTURE_WRAP_S, GL_WRAP_DEFAULT);
 278     gl->TexParameteri(mGlTarget, GL_TEXTURE_WRAP_T, GL_WRAP_DEFAULT);
 279     if(mGlTarget == GL_TEXTURE_CUBE_MAP)
 280     {
 281       gl->TexParameteri(mGlTarget, GL_TEXTURE_WRAP_R, GL_WRAP_DEFAULT);
 282     }
 283   }
 284 }
 285
 286 void Texture::Prepare()
 287 {
 288   NativeImageInterfacePtr nativeImage = mCreateInfo.nativeImagePtr;
 289   if(nativeImage)
 290   {
 291     if(nativeImage->SourceChanged())
 292     {
 293       // Update size
 294       uint32_t width  = mCreateInfo.nativeImagePtr->GetWidth();
 295       uint32_t height = mCreateInfo.nativeImagePtr->GetHeight();
 296       mCreateInfo.SetSize({width, height}); // Size may change
 297     }
 298
 299     nativeImage->PrepareTexture();
 300   }
 301 }
 302
 303 /**
 304  * This function tests whether format is supported by the driver. If possible it applies
 305  * format conversion to suitable supported pixel format.
 306  */
 307 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)
 308 {
 309   // No need to convert
 310   if(srcFormat == destFormat)
 311   {
 312     return false;
 313   }
 314
 315   auto it = std::find_if(COLOR_CONVERSION_TABLE.begin(), COLOR_CONVERSION_TABLE.end(), [&](auto& item) {
 316     return item.srcFormat == srcFormat && item.destFormat == destFormat;
 317   });
 318
 319   // No suitable format, return empty array
 320   if(it == COLOR_CONVERSION_TABLE.end())
 321   {
 322     return false;
 323   }
 324   auto begin = reinterpret_cast<const uint8_t*>(pData);
 325
 326   outputBuffer = std::move(it->pConversionFunc(begin, sizeInBytes, width, height, 0u));
 327   return !outputBuffer.empty();
 328 }
 329
 330 } // namespace Dali::Graphics::GLES