[Tizen] Skip Rendering if native texture not prepared

We should not render the program if texture was not prepared.
Also, if CreateResource failed, mEglImageExtensions might be nullptr.
So we need to make a nullptr check if CreateResource failed, and try to
call other API, like PrepareTexture().

Change-Id: Ic22ba6500faec496f94e6cc2f0cfdcd502bf3999
Signed-off-by: Eunki Hong <eunkiki.hong@samsung.com>

diff --git a/dali/internal/graphics/gles-impl/gles-context.cpp b/dali/internal/graphics/gles-impl/gles-context.cpp
index b7e829be976f354a036d5e0424884285270030e5..58fc94f3e76bc3c480077a57aba82888213346a6 100644 (file)
--- a/dali/internal/graphics/gles-impl/gles-context.cpp
+++ b/dali/internal/graphics/gles-impl/gles-context.cpp
@@ -360,6 +360,8 @@ void Context::Flush(bool reset, const GLES::DrawCallDescriptor& drawCall, GLES::
   uint32_t currentSampler = 0;
   uint32_t currentElement = 0;
 
+  bool needDraw = true;
+
   // @warning Assume that binding.binding is strictly linear in the same order as mCurrentTextureBindings
   // elements. This avoids having to sort the bindings.
   for(const auto& binding : mImpl->mCurrentTextureBindings)
@@ -375,7 +377,11 @@ void Context::Flush(bool reset, const GLES::DrawCallDescriptor& drawCall, GLES::
     // Texture may not have been initialized yet...(tbm_surface timing issue?)
     if(!texture->GetGLTexture())
     {
-      texture->InitializeResource();
+      if(DALI_UNLIKELY(!texture->InitializeResource()))
+      {
+        DALI_LOG_ERROR("[ERROR] NativeImage might invalid! Do not render it\n");
+        needDraw = false;
+      }
     }
 
     // Warning, this may cause glWaitSync to occur on the GPU, or glClientWaitSync to block the CPU.
@@ -469,70 +475,73 @@ void Context::Flush(bool reset, const GLES::DrawCallDescriptor& drawCall, GLES::
   const auto& ia = pipelineState.inputAssemblyState;
 
   // Resolve draw call
-  switch(drawCall.type)
+  if(DALI_LIKELY(needDraw))
   {
-    case DrawCallDescriptor::Type::DRAW:
+    switch(drawCall.type)
     {
-      mImpl->mGlStateCache.mFrameBufferStateCache.DrawOperation(mImpl->mGlStateCache.mColorMask,
-                                                                mImpl->mGlStateCache.DepthBufferWriteEnabled(),
-                                                                mImpl->mGlStateCache.StencilBufferWriteEnabled());
-      // For GLES3+ we use VAO, for GLES2 internal cache
-      if(!hasGLES3)
+      case DrawCallDescriptor::Type::DRAW:
       {
-        mImpl->FlushVertexAttributeLocations();
-      }
+        mImpl->mGlStateCache.mFrameBufferStateCache.DrawOperation(mImpl->mGlStateCache.mColorMask,
+                                                                  mImpl->mGlStateCache.DepthBufferWriteEnabled(),
+                                                                  mImpl->mGlStateCache.StencilBufferWriteEnabled());
+        // For GLES3+ we use VAO, for GLES2 internal cache
+        if(!hasGLES3)
+        {
+          mImpl->FlushVertexAttributeLocations();
+        }
 
-      if(drawCall.draw.instanceCount == 0)
-      {
-        gl->DrawArrays(GLESTopology(ia->topology),
-                       drawCall.draw.firstVertex,
-                       drawCall.draw.vertexCount);
+        if(drawCall.draw.instanceCount == 0)
+        {
+          gl->DrawArrays(GLESTopology(ia->topology),
+                        drawCall.draw.firstVertex,
+                        drawCall.draw.vertexCount);
+        }
+        else
+        {
+          gl->DrawArraysInstanced(GLESTopology(ia->topology),
+                                  drawCall.draw.firstVertex,
+                                  drawCall.draw.vertexCount,
+                                  drawCall.draw.instanceCount);
+        }
+        break;
       }
-      else
+      case DrawCallDescriptor::Type::DRAW_INDEXED:
       {
-        gl->DrawArraysInstanced(GLESTopology(ia->topology),
-                                drawCall.draw.firstVertex,
-                                drawCall.draw.vertexCount,
-                                drawCall.draw.instanceCount);
-      }
-      break;
-    }
-    case DrawCallDescriptor::Type::DRAW_INDEXED:
-    {
-      const auto& binding = mImpl->mCurrentIndexBufferBinding;
-      BindBuffer(GL_ELEMENT_ARRAY_BUFFER, binding.buffer->GetGLBuffer());
+        const auto& binding = mImpl->mCurrentIndexBufferBinding;
+        BindBuffer(GL_ELEMENT_ARRAY_BUFFER, binding.buffer->GetGLBuffer());
 
-      mImpl->mGlStateCache.mFrameBufferStateCache.DrawOperation(mImpl->mGlStateCache.mColorMask,
-                                                                mImpl->mGlStateCache.DepthBufferWriteEnabled(),
-                                                                mImpl->mGlStateCache.StencilBufferWriteEnabled());
+        mImpl->mGlStateCache.mFrameBufferStateCache.DrawOperation(mImpl->mGlStateCache.mColorMask,
+                                                                  mImpl->mGlStateCache.DepthBufferWriteEnabled(),
+                                                                  mImpl->mGlStateCache.StencilBufferWriteEnabled());
 
-      // For GLES3+ we use VAO, for GLES2 internal cache
-      if(!hasGLES3)
-      {
-        mImpl->FlushVertexAttributeLocations();
-      }
+        // For GLES3+ we use VAO, for GLES2 internal cache
+        if(!hasGLES3)
+        {
+          mImpl->FlushVertexAttributeLocations();
+        }
 
-      auto indexBufferFormat = GLIndexFormat(binding.format).format;
-      if(drawCall.drawIndexed.instanceCount == 0)
-      {
-        gl->DrawElements(GLESTopology(ia->topology),
-                         drawCall.drawIndexed.indexCount,
-                         indexBufferFormat,
-                         reinterpret_cast<void*>(binding.offset));
+        auto indexBufferFormat = GLIndexFormat(binding.format).format;
+        if(drawCall.drawIndexed.instanceCount == 0)
+        {
+          gl->DrawElements(GLESTopology(ia->topology),
+                          drawCall.drawIndexed.indexCount,
+                          indexBufferFormat,
+                          reinterpret_cast<void*>(binding.offset));
+        }
+        else
+        {
+          gl->DrawElementsInstanced(GLESTopology(ia->topology),
+                                    drawCall.drawIndexed.indexCount,
+                                    indexBufferFormat,
+                                    reinterpret_cast<void*>(binding.offset),
+                                    drawCall.drawIndexed.instanceCount);
+        }
+        break;
       }
-      else
+      case DrawCallDescriptor::Type::DRAW_INDEXED_INDIRECT:
       {
-        gl->DrawElementsInstanced(GLESTopology(ia->topology),
-                                  drawCall.drawIndexed.indexCount,
-                                  indexBufferFormat,
-                                  reinterpret_cast<void*>(binding.offset),
-                                  drawCall.drawIndexed.instanceCount);
+        break;
       }
-      break;
-    }
-    case DrawCallDescriptor::Type::DRAW_INDEXED_INDIRECT:
-    {
-      break;
     }
   }
 

diff --git a/dali/internal/imaging/tizen/native-image-source-impl-tizen.cpp b/dali/internal/imaging/tizen/native-image-source-impl-tizen.cpp
index 570ff179be1ec47878e26dfcfa59be30871b5eae..0f8318ff91764dd61a4fcfc3aac70553fadcee44 100644 (file)
--- a/dali/internal/imaging/tizen/native-image-source-impl-tizen.cpp
+++ b/dali/internal/imaging/tizen/native-image-source-impl-tizen.cpp
@@ -446,6 +446,7 @@ void NativeImageSourceTizen::DestroyResource()
   std::scoped_lock lock(mMutex);
   if(mEglImageKHR)
   {
+    DALI_ASSERT_DEBUG(mEglImageExtensions);
     mEglImageExtensions->DestroyImageKHR(mEglImageKHR);
 
     mEglImageKHR = NULL;
@@ -459,7 +460,10 @@ void NativeImageSourceTizen::DestroyResource()
 
 uint32_t NativeImageSourceTizen::TargetTexture()
 {
-  mEglImageExtensions->TargetTextureKHR(mEglImageKHR);
+  if(DALI_LIKELY(mEglImageExtensions && mEglImageKHR))
+  {
+    mEglImageExtensions->TargetTextureKHR(mEglImageKHR);
+  }
 
   return 0;
 }
@@ -471,8 +475,12 @@ void NativeImageSourceTizen::PrepareTexture()
   {
     // Destroy previous eglImage because use for new one.
     // if mEglImageKHR is not to be NULL here, it will not be updated with a new eglImage.
-    mEglImageExtensions->DestroyImageKHR(mEglImageKHR);
-    mEglImageKHR = NULL;
+    if(mEglImageKHR)
+    {
+      DALI_ASSERT_DEBUG(mEglImageExtensions);
+      mEglImageExtensions->DestroyImageKHR(mEglImageKHR);
+      mEglImageKHR = NULL;
+    }
 
     if(CreateResource())
     {