// INTERNAL INCLUDES
#include <dali/internal/graphics/common/egl-image-extensions.h>
-#include <dali/internal/graphics/gles20/egl-graphics.h>
+#include <dali/internal/graphics/gles/egl-graphics.h>
#include <dali/internal/adaptor/common/adaptor-impl.h>
namespace Dali
}
-NativeImageSourceQueueTizen* NativeImageSourceQueueTizen::New( unsigned int width, unsigned int height, Dali::NativeImageSourceQueue::ColorDepth depth, Any nativeImageSourceQueue )
+NativeImageSourceQueueTizen* NativeImageSourceQueueTizen::New( uint32_t width, uint32_t height, Dali::NativeImageSourceQueue::ColorDepth depth, Any nativeImageSourceQueue )
{
NativeImageSourceQueueTizen* image = new NativeImageSourceQueueTizen( width, height, depth, nativeImageSourceQueue );
DALI_ASSERT_DEBUG( image && "NativeImageSourceQueueTizen allocation failed." );
return image;
}
-NativeImageSourceQueueTizen::NativeImageSourceQueueTizen( unsigned int width, unsigned int height, Dali::NativeImageSourceQueue::ColorDepth depth, Any nativeImageSourceQueue )
-: mWidth( width ),
+NativeImageSourceQueueTizen::NativeImageSourceQueueTizen( uint32_t width, uint32_t height, Dali::NativeImageSourceQueue::ColorDepth depth, Any nativeImageSourceQueue )
+: mMutex(),
+ mWidth( width ),
mHeight( height ),
mTbmQueue( NULL ),
mConsumeSurface( NULL ),
mEglImages(),
+ mEglGraphics( NULL ),
mEglImageExtensions( NULL ),
mOwnTbmQueue( false ),
mBlendingRequired( false )
DALI_ASSERT_ALWAYS( Adaptor::IsAvailable() );
GraphicsInterface* graphics = &( Adaptor::GetImplementation( Adaptor::Get() ).GetGraphicsInterface() );
- auto eglGraphics = static_cast<EglGraphics *>(graphics);
-
- mEglImageExtensions = eglGraphics->GetImageExtensions();
-
- DALI_ASSERT_DEBUG( mEglImageExtensions );
+ mEglGraphics = static_cast<EglGraphics *>(graphics);
mTbmQueue = GetSurfaceFromAny( nativeImageSourceQueue );
{
if( mOwnTbmQueue )
{
- DestroyQueue();
+ if( mTbmQueue != NULL )
+ {
+ tbm_surface_queue_destroy( mTbmQueue );
+ }
}
}
void NativeImageSourceQueueTizen::Initialize( Dali::NativeImageSourceQueue::ColorDepth depth )
{
- if( mTbmQueue != NULL || mWidth == 0 || mHeight == 0 )
+ if( mWidth == 0 || mHeight == 0 )
{
return;
}
- int format = TBM_FORMAT_ARGB8888;
-
- switch( depth )
+ if( mTbmQueue == NULL )
{
- case Dali::NativeImageSourceQueue::COLOR_DEPTH_DEFAULT:
- case Dali::NativeImageSourceQueue::COLOR_DEPTH_32:
- {
- format = TBM_FORMAT_ARGB8888;
- mBlendingRequired = true;
- break;
- }
- case Dali::NativeImageSourceQueue::COLOR_DEPTH_24:
+ int format = TBM_FORMAT_ARGB8888;
+
+ switch( depth )
{
- format = TBM_FORMAT_RGB888;
- mBlendingRequired = false;
- break;
+ case Dali::NativeImageSourceQueue::COLOR_DEPTH_DEFAULT:
+ case Dali::NativeImageSourceQueue::COLOR_DEPTH_32:
+ {
+ format = TBM_FORMAT_ARGB8888;
+ mBlendingRequired = true;
+ break;
+ }
+ case Dali::NativeImageSourceQueue::COLOR_DEPTH_24:
+ {
+ format = TBM_FORMAT_RGB888;
+ mBlendingRequired = false;
+ break;
+ }
+ default:
+ {
+ DALI_LOG_WARNING( "Wrong color depth.\n" );
+ return;
+ }
}
- default:
+
+ mTbmQueue = tbm_surface_queue_create( TBM_SURFACE_QUEUE_SIZE, mWidth, mHeight, format, 0 );
+ if( !mTbmQueue )
{
- DALI_LOG_WARNING( "Wrong color depth.\n" );
+ DALI_LOG_ERROR( "NativeImageSourceQueueTizen::Initialize: tbm_surface_queue_create is failed! [%p]\n", mTbmQueue );
return;
}
- }
-
- mTbmQueue = tbm_surface_queue_create( TBM_SURFACE_QUEUE_SIZE, mWidth, mHeight, format, 0 );
- mOwnTbmQueue = true;
+ mOwnTbmQueue = true;
+ }
}
tbm_surface_queue_h NativeImageSourceQueueTizen::GetSurfaceFromAny( Any source ) const
return Any( mTbmQueue );
}
-void NativeImageSourceQueueTizen::SetSource( Any source )
+void NativeImageSourceQueueTizen::SetSize( uint32_t width, uint32_t height )
{
- if( mOwnTbmQueue )
- {
- DestroyQueue();
- }
+ Dali::Mutex::ScopedLock lock( mMutex );
- mTbmQueue = GetSurfaceFromAny( source );
+ tbm_surface_queue_reset( mTbmQueue, width, height, tbm_surface_queue_get_format( mTbmQueue ) );
- if( mTbmQueue != NULL )
+ mWidth = width;
+ mHeight = height;
+
+ ResetEglImageList();
+}
+
+void NativeImageSourceQueueTizen::IgnoreSourceImage()
+{
+ Dali::Mutex::ScopedLock lock( mMutex );
+ tbm_surface_h surface;
+
+ if( tbm_surface_queue_can_acquire( mTbmQueue, 0 ) )
{
- mBlendingRequired = CheckBlending( tbm_surface_queue_get_format( mTbmQueue ) );
- mWidth = tbm_surface_queue_get_width( mTbmQueue );
- mHeight = tbm_surface_queue_get_height( mTbmQueue );
+ if( tbm_surface_queue_acquire( mTbmQueue, &surface ) != TBM_SURFACE_QUEUE_ERROR_NONE )
+ {
+ DALI_LOG_ERROR( "NativeImageSourceQueueTizen::IgnoreSourceImage: Failed to aquire a tbm_surface\n" );
+ return;
+ }
+
+ if( tbm_surface_internal_is_valid( surface ) )
+ {
+ tbm_surface_queue_release( mTbmQueue, surface );
+ }
}
}
-bool NativeImageSourceQueueTizen::GlExtensionCreate()
+bool NativeImageSourceQueueTizen::CreateResource()
{
+ mEglImageExtensions = mEglGraphics->GetImageExtensions();
+ DALI_ASSERT_DEBUG( mEglImageExtensions );
+
return true;
}
-void NativeImageSourceQueueTizen::GlExtensionDestroy()
+void NativeImageSourceQueueTizen::DestroyResource()
{
- for( auto&& iter : mEglImages )
- {
- mEglImageExtensions->DestroyImageKHR( iter.second );
+ Dali::Mutex::ScopedLock lock( mMutex );
- tbm_surface_internal_unref( iter.first );
- }
- mEglImages.clear();
+ ResetEglImageList();
}
-unsigned int NativeImageSourceQueueTizen::TargetTexture()
+uint32_t NativeImageSourceQueueTizen::TargetTexture()
{
return 0;
}
void NativeImageSourceQueueTizen::PrepareTexture()
{
- tbm_surface_h oldSurface = mConsumeSurface;
+ Dali::Mutex::ScopedLock lock( mMutex );
- bool needToWait = ( mConsumeSurface == NULL ) ? true : false;
+ tbm_surface_h oldSurface = mConsumeSurface;
- if( tbm_surface_queue_can_acquire( mTbmQueue, needToWait ) )
+ if( tbm_surface_queue_can_acquire( mTbmQueue, 0 ) )
{
if( tbm_surface_queue_acquire( mTbmQueue, &mConsumeSurface ) != TBM_SURFACE_QUEUE_ERROR_NONE )
{
DALI_LOG_ERROR( "Failed to aquire a tbm_surface\n" );
return;
}
- }
- if( oldSurface && oldSurface != mConsumeSurface )
- {
- if( tbm_surface_internal_is_valid( oldSurface ) )
+ if( oldSurface )
{
- tbm_surface_queue_release( mTbmQueue, oldSurface );
+ if( tbm_surface_internal_is_valid( oldSurface ) )
+ {
+ tbm_surface_queue_release( mTbmQueue, oldSurface );
+ }
}
- }
- if( mConsumeSurface )
- {
- bool existing = false;
- for( auto&& iter : mEglImages )
+ if( mConsumeSurface )
{
- if( iter.first == mConsumeSurface )
+ bool existing = false;
+ for( auto&& iter : mEglImages )
{
- // Find the surface in the existing list
- existing = true;
- mEglImageExtensions->TargetTextureKHR( iter.second );
- break;
+ if( iter.first == mConsumeSurface )
+ {
+ // Find the surface in the existing list
+ existing = true;
+ mEglImageExtensions->TargetTextureKHR( iter.second );
+ break;
+ }
}
- }
- if( !existing )
- {
- // Push the surface
- tbm_surface_internal_ref( mConsumeSurface );
+ if( !existing )
+ {
+ // Push the surface
+ tbm_surface_internal_ref( mConsumeSurface );
- void* eglImageKHR = mEglImageExtensions->CreateImageKHR( reinterpret_cast< EGLClientBuffer >( mConsumeSurface ) );
- mEglImageExtensions->TargetTextureKHR( eglImageKHR );
+ void* eglImageKHR = mEglImageExtensions->CreateImageKHR( reinterpret_cast< EGLClientBuffer >( mConsumeSurface ) );
+ mEglImageExtensions->TargetTextureKHR( eglImageKHR );
- mEglImages.push_back( EglImagePair( mConsumeSurface, eglImageKHR) );
+ mEglImages.push_back( EglImagePair( mConsumeSurface, eglImageKHR) );
+ }
}
}
}
-const char* NativeImageSourceQueueTizen::GetCustomFragmentPreFix()
+const char* NativeImageSourceQueueTizen::GetCustomFragmentPrefix() const
{
return FRAGMENT_PREFIX;
}
-const char* NativeImageSourceQueueTizen::GetCustomSamplerTypename()
+const char* NativeImageSourceQueueTizen::GetCustomSamplerTypename() const
{
return SAMPLER_TYPE;
}
-int NativeImageSourceQueueTizen::GetEglImageTextureTarget()
+int NativeImageSourceQueueTizen::GetTextureTarget() const
{
return GL_TEXTURE_EXTERNAL_OES;
}
-void NativeImageSourceQueueTizen::DestroyQueue()
+Any NativeImageSourceQueueTizen::GetNativeImageHandle() const
+{
+ return nullptr;
+}
+
+bool NativeImageSourceQueueTizen::SourceChanged() const
+{
+ return false;
+}
+
+
+
+void NativeImageSourceQueueTizen::ResetEglImageList()
{
if( mConsumeSurface )
{
- tbm_surface_internal_unref( mConsumeSurface );
-
if( tbm_surface_internal_is_valid( mConsumeSurface ) )
{
tbm_surface_queue_release( mTbmQueue, mConsumeSurface );
}
+ mConsumeSurface = NULL;
}
- if( mTbmQueue != NULL )
+ for( auto&& iter : mEglImages )
{
- tbm_surface_queue_destroy( mTbmQueue );
- }
+ mEglImageExtensions->DestroyImageKHR( iter.second );
- mTbmQueue = NULL;
- mOwnTbmQueue = false;
+ tbm_surface_internal_unref( iter.first );
+ }
+ mEglImages.clear();
}
bool NativeImageSourceQueueTizen::CheckBlending( int format )
projects / platform / core / uifw / dali-adaptor.git / blobdiff