adaptors/tizen/native-image-source-queue-impl-tizen.cpp

   1 /*
   2  * Copyright (c) 2018 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 <native-image-source-queue-impl-tizen.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/integration-api/debug.h>
  23 #include <dali/integration-api/gl-defines.h>
  24 #include <tbm_surface_internal.h>
  25
  26 // INTERNAL INCLUDES
  27 #include <gl/egl-image-extensions.h>
  28 #include <gl/egl-factory.h>
  29 #include <adaptor-impl.h>
  30
  31 namespace Dali
  32 {
  33
  34 namespace Internal
  35 {
  36
  37 namespace Adaptor
  38 {
  39
  40 namespace
  41 {
  42 #define TBM_SURFACE_QUEUE_SIZE  3
  43
  44 const char* FRAGMENT_PREFIX = "#extension GL_OES_EGL_image_external:require\n";
  45 const char* SAMPLER_TYPE = "samplerExternalOES";
  46
  47 int FORMATS_BLENDING_REQUIRED[] = {
  48   TBM_FORMAT_ARGB4444, TBM_FORMAT_ABGR4444,
  49   TBM_FORMAT_RGBA4444, TBM_FORMAT_BGRA4444,
  50   TBM_FORMAT_RGBX5551, TBM_FORMAT_BGRX5551,
  51   TBM_FORMAT_ARGB1555, TBM_FORMAT_ABGR1555,
  52   TBM_FORMAT_RGBA5551, TBM_FORMAT_BGRA5551,
  53   TBM_FORMAT_ARGB8888, TBM_FORMAT_ABGR8888,
  54   TBM_FORMAT_RGBA8888, TBM_FORMAT_BGRA8888,
  55   TBM_FORMAT_ARGB2101010, TBM_FORMAT_ABGR2101010,
  56   TBM_FORMAT_RGBA1010102, TBM_FORMAT_BGRA1010102
  57 };
  58
  59 const int NUM_FORMATS_BLENDING_REQUIRED = 18;
  60
  61 }
  62
  63 NativeImageSourceQueueTizen* NativeImageSourceQueueTizen::New( unsigned int width, unsigned int height, Dali::NativeImageSourceQueue::ColorDepth depth, Any nativeImageSourceQueue )
  64 {
  65   NativeImageSourceQueueTizen* image = new NativeImageSourceQueueTizen( width, height, depth, nativeImageSourceQueue );
  66   DALI_ASSERT_DEBUG( image && "NativeImageSourceQueueTizen allocation failed." );
  67
  68   if( image )
  69   {
  70     image->Initialize( depth );
  71   }
  72
  73   return image;
  74 }
  75
  76 NativeImageSourceQueueTizen::NativeImageSourceQueueTizen( unsigned int width, unsigned int height, Dali::NativeImageSourceQueue::ColorDepth depth, Any nativeImageSourceQueue )
  77 : mWidth( width ),
  78   mHeight( height ),
  79   mTbmQueue( NULL ),
  80   mConsumeSurface( NULL ),
  81   mEglImages(),
  82   mEglImageExtensions( NULL ),
  83   mOwnTbmQueue( false ),
  84   mBlendingRequired( false )
  85 {
  86   DALI_ASSERT_ALWAYS( Adaptor::IsAvailable() );
  87   EglFactory& eglFactory = Adaptor::GetImplementation( Adaptor::Get() ).GetEGLFactory();
  88   mEglImageExtensions = eglFactory.GetImageExtensions();
  89   DALI_ASSERT_DEBUG( mEglImageExtensions );
  90
  91   mTbmQueue = GetSurfaceFromAny( nativeImageSourceQueue );
  92
  93   if( mTbmQueue != NULL )
  94   {
  95     mBlendingRequired = CheckBlending( tbm_surface_queue_get_format( mTbmQueue ) );
  96     mWidth = tbm_surface_queue_get_width( mTbmQueue );
  97     mHeight = tbm_surface_queue_get_height( mTbmQueue );
  98   }
  99 }
 100
 101 NativeImageSourceQueueTizen::~NativeImageSourceQueueTizen()
 102 {
 103   if( mOwnTbmQueue )
 104   {
 105     DestroyQueue();
 106   }
 107 }
 108
 109 void NativeImageSourceQueueTizen::Initialize( Dali::NativeImageSourceQueue::ColorDepth depth )
 110 {
 111   if( mTbmQueue != NULL || mWidth == 0 || mHeight == 0 )
 112   {
 113     return;
 114   }
 115
 116   int format = TBM_FORMAT_ARGB8888;
 117
 118   switch( depth )
 119   {
 120     case Dali::NativeImageSourceQueue::COLOR_DEPTH_DEFAULT:
 121     case Dali::NativeImageSourceQueue::COLOR_DEPTH_32:
 122     {
 123       format = TBM_FORMAT_ARGB8888;
 124       mBlendingRequired = true;
 125       break;
 126     }
 127     case Dali::NativeImageSourceQueue::COLOR_DEPTH_24:
 128     {
 129       format = TBM_FORMAT_RGB888;
 130       mBlendingRequired = false;
 131       break;
 132     }
 133     default:
 134     {
 135       DALI_LOG_WARNING( "Wrong color depth.\n" );
 136       return;
 137     }
 138   }
 139
 140   mTbmQueue = tbm_surface_queue_create( TBM_SURFACE_QUEUE_SIZE, mWidth, mHeight, format, 0 );
 141
 142   mOwnTbmQueue = true;
 143 }
 144
 145 tbm_surface_queue_h NativeImageSourceQueueTizen::GetSurfaceFromAny( Any source ) const
 146 {
 147   if( source.Empty() )
 148   {
 149     return NULL;
 150   }
 151
 152   if( source.GetType() == typeid( tbm_surface_queue_h ) )
 153   {
 154     return AnyCast< tbm_surface_queue_h >( source );
 155   }
 156   else
 157   {
 158     return NULL;
 159   }
 160 }
 161
 162 Any NativeImageSourceQueueTizen::GetNativeImageSourceQueue() const
 163 {
 164   return Any( mTbmQueue );
 165 }
 166
 167 void NativeImageSourceQueueTizen::SetSource( Any source )
 168 {
 169   if( mOwnTbmQueue )
 170   {
 171     DestroyQueue();
 172   }
 173
 174   mTbmQueue = GetSurfaceFromAny( source );
 175
 176   if( mTbmQueue != NULL )
 177   {
 178     mBlendingRequired = CheckBlending( tbm_surface_queue_get_format( mTbmQueue ) );
 179     mWidth = tbm_surface_queue_get_width( mTbmQueue );
 180     mHeight = tbm_surface_queue_get_height( mTbmQueue );
 181   }
 182 }
 183
 184 bool NativeImageSourceQueueTizen::GlExtensionCreate()
 185 {
 186   return true;
 187 }
 188
 189 void NativeImageSourceQueueTizen::GlExtensionDestroy()
 190 {
 191   for( auto&& iter : mEglImages )
 192   {
 193     mEglImageExtensions->DestroyImageKHR( iter.second );
 194
 195     tbm_surface_internal_unref( iter.first );
 196   }
 197   mEglImages.clear();
 198 }
 199
 200 unsigned int NativeImageSourceQueueTizen::TargetTexture()
 201 {
 202   return 0;
 203 }
 204
 205 void NativeImageSourceQueueTizen::PrepareTexture()
 206 {
 207   tbm_surface_h oldSurface = mConsumeSurface;
 208
 209   bool needToWait = ( mConsumeSurface == NULL ) ? true : false;
 210
 211   if( tbm_surface_queue_can_acquire( mTbmQueue, needToWait ) )
 212   {
 213     if( tbm_surface_queue_acquire( mTbmQueue, &mConsumeSurface ) != TBM_SURFACE_QUEUE_ERROR_NONE )
 214     {
 215       DALI_LOG_ERROR( "Failed to aquire a tbm_surface\n" );
 216       return;
 217     }
 218   }
 219
 220   if( oldSurface && oldSurface != mConsumeSurface )
 221   {
 222     if( tbm_surface_internal_is_valid( oldSurface ) )
 223     {
 224       tbm_surface_queue_release( mTbmQueue, oldSurface );
 225     }
 226   }
 227
 228   if( mConsumeSurface )
 229   {
 230     bool existing = false;
 231     for( auto&& iter : mEglImages )
 232     {
 233       if( iter.first == mConsumeSurface )
 234       {
 235         // Find the surface in the existing list
 236         existing = true;
 237         mEglImageExtensions->TargetTextureKHR( iter.second );
 238         break;
 239       }
 240     }
 241
 242     if( !existing )
 243     {
 244       // Push the surface
 245       tbm_surface_internal_ref( mConsumeSurface );
 246
 247       void* eglImageKHR = mEglImageExtensions->CreateImageKHR( reinterpret_cast< EGLClientBuffer >( mConsumeSurface ) );
 248       mEglImageExtensions->TargetTextureKHR( eglImageKHR );
 249
 250       mEglImages.push_back( EglImagePair( mConsumeSurface, eglImageKHR) );
 251     }
 252   }
 253 }
 254
 255 const char* NativeImageSourceQueueTizen::GetCustomFragmentPreFix()
 256 {
 257   return FRAGMENT_PREFIX;
 258 }
 259
 260 const char* NativeImageSourceQueueTizen::GetCustomSamplerTypename()
 261 {
 262   return SAMPLER_TYPE;
 263 }
 264
 265 int NativeImageSourceQueueTizen::GetEglImageTextureTarget()
 266 {
 267   return GL_TEXTURE_EXTERNAL_OES;
 268 }
 269
 270 void NativeImageSourceQueueTizen::SetDestructorNotification(void* notification)
 271 {
 272 }
 273
 274 void NativeImageSourceQueueTizen::DestroyQueue()
 275 {
 276   if( mConsumeSurface )
 277   {
 278     tbm_surface_internal_unref( mConsumeSurface );
 279
 280     if( tbm_surface_internal_is_valid( mConsumeSurface ) )
 281     {
 282       tbm_surface_queue_release( mTbmQueue, mConsumeSurface );
 283     }
 284   }
 285
 286   if( mTbmQueue != NULL )
 287   {
 288     tbm_surface_queue_destroy( mTbmQueue );
 289   }
 290
 291   mTbmQueue = NULL;
 292   mOwnTbmQueue = false;
 293 }
 294
 295 bool NativeImageSourceQueueTizen::CheckBlending( int format )
 296 {
 297   for( int i = 0; i < NUM_FORMATS_BLENDING_REQUIRED; ++i )
 298   {
 299     if( format == FORMATS_BLENDING_REQUIRED[i] )
 300     {
 301       return true;
 302     }
 303   }
 304
 305   return false;
 306 }
 307
 308 } // namespace Adaptor
 309
 310 } // namespace internal
 311
 312 } // namespace Dali