/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/video-view/video-view.h>
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
-#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
-#include <dali-toolkit/internal/visuals/visual-string-constants.h>
-#include <dali-toolkit/internal/visuals/visual-base-impl.h>
-#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
namespace Dali
DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "looping", BOOLEAN, LOOPING )
DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "muted", BOOLEAN, MUTED )
DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "volume", MAP, VOLUME )
+DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "underlay", BOOLEAN, UNDERLAY )
+DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "playPosition", INTEGER, PLAY_POSITION )
+DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "displayMode", INTEGER, DISPLAY_MODE )
DALI_SIGNAL_REGISTRATION( Toolkit, VideoView, "finished", FINISHED_SIGNAL )
const char* const VOLUME_LEFT( "volumeLeft" );
const char* const VOLUME_RIGHT( "volumeRight" );
+
+// 3.0 TC uses RENDERING_TARGET. It should be removed in next release
const char* const RENDERING_TARGET( "renderingTarget" );
const char* const WINDOW_SURFACE_TARGET( "windowSurfaceTarget" );
const char* const NATIVE_IMAGE_TARGET( "nativeImageTarget" );
+const char* const CUSTOM_SHADER( "shader" );
+const char* const CUSTOM_VERTEX_SHADER( "vertexShader" );
+const char* const CUSTOM_FRAGMENT_SHADER( "fragmentShader" );
+const char* const DEFAULT_SAMPLER_TYPE_NAME( "sampler2D" );
+const char* const CUSTOM_SAMPLER_TYPE_NAME( "samplerExternalOES" );
+
const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
attribute mediump vec2 aPosition;\n
uniform mediump mat4 uMvpMatrix;\n
);
const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
- uniform lowp vec4 uColor;\n
- uniform lowp vec3 mixColor;\n
- uniform lowp float opacity;\n
\n
void main()\n
{\n
- gl_FragColor = vec4(mixColor, opacity)*uColor;\n
+ gl_FragColor = vec4(0.0);\n
}\n
);
-struct TriggerFunctor
-{
- TriggerFunctor( TriggerEventInterface* notification )
- : mNotification( notification )
- {
- }
-
- void operator()( bool& current, const PropertyInputContainer& inputs )
- {
- if( mNotification != NULL )
- {
- mNotification->Trigger();
- }
- }
+const char* VERTEX_SHADER_TEXTURE = DALI_COMPOSE_SHADER(
+ attribute mediump vec2 aPosition;\n
+ varying mediump vec2 vTexCoord;\n
+ uniform mediump mat4 uMvpMatrix;\n
+ uniform mediump vec3 uSize;\n
+ varying mediump vec2 sTexCoordRect;\n
+ void main()\n
+ {\n
+ gl_Position = uMvpMatrix * vec4(aPosition * uSize.xy, 0.0, 1.0);\n
+ vTexCoord = aPosition + vec2(0.5);\n
+ }\n
+);
- TriggerEventInterface* mNotification;
-};
+const char* FRAGMENT_SHADER_TEXTURE = DALI_COMPOSE_SHADER(
+ uniform lowp vec4 uColor;\n
+ varying mediump vec2 vTexCoord;\n
+ uniform samplerExternalOES sTexture;\n
+ void main()\n
+ {\n
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
+ }\n
+);
} // anonymous namepsace
VideoView::VideoView()
: Control( ControlBehaviour( ACTOR_BEHAVIOUR_DEFAULT | DISABLE_STYLE_CHANGE_SIGNALS ) ),
- mUpdateTriggerPropertyIndex( Property::INVALID_INDEX),
- mNotification( NULL ),
mCurrentVideoPlayPosition( 0 ),
- mIsNativeImageTarget( true ),
mIsPlay( false ),
- mIsPause( false )
+ mIsUnderlay( true )
{
mVideoPlayer = Dali::VideoPlayer::New();
-
- TriggerEventFactory triggerEventFactory;
- mNotification = triggerEventFactory.CreateTriggerEvent( MakeCallback(this, &VideoView::UpdateDisplayArea ),
- TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER);
}
VideoView::~VideoView()
{
- if( mNotification != NULL )
- {
- delete mNotification;
- }
}
Toolkit::VideoView VideoView::New()
void VideoView::OnInitialize()
{
- Any source;
- Dali::NativeImageSourcePtr nativeImageSourcePtr = Dali::NativeImageSource::New( source );
- mNativeImage = Dali::NativeImage::New( *nativeImageSourcePtr );
-
- mVideoPlayer.SetRenderingTarget( nativeImageSourcePtr );
mVideoPlayer.FinishedSignal().Connect( this, &VideoView::EmitSignalFinish );
-
- mUpdateTriggerPropertyIndex = Self().RegisterProperty( "updateTrigger", true );
+ SetWindowSurfaceTarget();
}
void VideoView::SetUrl( const std::string& url )
{
- if( mUrl != url || !mPropertyMap.Empty() )
- {
mUrl = url;
mPropertyMap.Clear();
- }
-
- if( mIsNativeImageTarget )
- {
- Actor self( Self() );
- Internal::InitializeVisual( self, mVisual, mNativeImage );
- }
mVideoPlayer.SetUrl( mUrl );
}
{
mPropertyMap = map;
- Actor self( Self() );
- Internal::InitializeVisual( self, mVisual, mPropertyMap );
+ Property::Value* target = map.Find( RENDERING_TARGET );
+ std::string targetType;
- Property::Value* widthValue = mPropertyMap.Find( "width" );
- if( widthValue )
+ if( target && target->Get( targetType ) && targetType == WINDOW_SURFACE_TARGET )
{
- int width;
- if( widthValue->Get( width ) )
- {
- mVideoSize = ImageDimensions( width, mVideoSize.GetHeight() );
- }
+ mIsUnderlay = true;
+ SetWindowSurfaceTarget();
+ }
+ else if( target && target->Get( targetType ) && targetType == NATIVE_IMAGE_TARGET )
+ {
+ mIsUnderlay = false;
+ SetNativeImageTarget();
}
- Property::Value* heightValue = mPropertyMap.Find( "height" );
- if( heightValue )
+ // Custom shader
+ Property::Value* shaderValue;
+ if( !map.Empty() )
{
- int height;
- if( heightValue->Get( height ) )
+ shaderValue = map.Find( CUSTOM_SHADER );
+
+ if( shaderValue )
{
- mVideoSize = ImageDimensions( mVideoSize.GetWidth(), height );
+ Property::Map* shaderMap = shaderValue->GetMap();
+ if( shaderMap )
+ {
+ mEffectPropertyMap = *shaderMap;
+ }
}
}
- Property::Value* target = map.Find( RENDERING_TARGET );
- std::string targetType;
-
- if( target && target->Get( targetType ) && targetType == WINDOW_SURFACE_TARGET )
+ if( mTextureRenderer && !mEffectPropertyMap.Empty() )
{
- this->SetWindowSurfaceTarget();
- }
- else if( target && target->Get( targetType ) && targetType == NATIVE_IMAGE_TARGET )
- {
- this->SetNativeImageTarget();
+ Dali::Shader shader = CreateShader();
+ mTextureRenderer.SetShader( shader );
}
RelayoutRequest();
return mUrl;
}
-void VideoView::SetLooping(bool looping)
+void VideoView::SetLooping( bool looping )
{
mVideoPlayer.SetLooping( looping );
}
void VideoView::Play()
{
+ if( mIsUnderlay )
+ {
+ Self().AddRenderer( mOverlayRenderer );
+ }
+
mVideoPlayer.Play();
mIsPlay = true;
- mIsPause = false;
}
void VideoView::Pause()
{
mVideoPlayer.Pause();
mIsPlay = false;
- mIsPause = true;
}
void VideoView::Stop()
{
mVideoPlayer.Stop();
mIsPlay = false;
- mIsPause = false;
}
void VideoView::Forward( int millisecond )
void VideoView::EmitSignalFinish()
{
+ if( mIsUnderlay )
+ {
+ Self().RemoveRenderer( mOverlayRenderer );
+ }
+
if ( !mFinishedSignal.Empty() )
{
Dali::Toolkit::VideoView handle( GetOwner() );
}
else if( value.Get( map ) )
{
- Property::Value* shaderValue = map.Find( Toolkit::Visual::Property::SHADER, CUSTOM_SHADER );
-
- if( map.Count() > 1u || !shaderValue )
- {
impl.SetPropertyMap( map );
}
- else if( impl.mVisual && map.Count() == 1u && shaderValue )
- {
- Property::Map shaderMap;
- if( shaderValue->Get( shaderMap ) )
- {
- Internal::Visual::Base& visual = Toolkit::GetImplementation( impl.mVisual );
- visual.SetCustomShader( shaderMap );
- if( videoView.OnStage() )
- {
- visual.SetOffStage( videoView );
- visual.SetOnStage( videoView );
- }
- }
- }
- }
break;
}
case Toolkit::VideoView::Property::LOOPING:
}
break;
}
+ case Toolkit::VideoView::Property::UNDERLAY:
+ {
+ bool underlay;
+ if( value.Get( underlay ) )
+ {
+ impl.SetUnderlay( underlay );
+ }
+ break;
+ }
+ case Toolkit::VideoView::Property::PLAY_POSITION:
+ {
+ int pos;
+ if( value.Get( pos ) )
+ {
+ impl.SetPlayPosition( pos );
+ }
+ break;
+ }
+ case Toolkit::VideoView::Property::DISPLAY_MODE:
+ {
+ int mode;
+ if( value.Get( mode ) )
+ {
+ impl.SetDisplayMode( mode );
+ }
+ break;
+ }
}
}
}
value = map;
break;
}
+ case Toolkit::VideoView::Property::UNDERLAY:
+ {
+ value = impl.IsUnderlay();
+ break;
+ }
+ case Toolkit::VideoView::Property::PLAY_POSITION:
+ {
+ value = impl.GetPlayPosition();
+ break;
+ }
+ case Toolkit::VideoView::Property::DISPLAY_MODE:
+ {
+ value = impl.GetDisplayMode();
+ break;
+ }
}
}
void VideoView::SetDepthIndex( int depthIndex )
{
- if( mVisual )
+ if( mTextureRenderer )
{
- mVisual.SetDepthIndex( depthIndex );
+ mTextureRenderer.SetProperty( Renderer::Property::DEPTH_INDEX, depthIndex );
}
}
void VideoView::OnStageConnection( int depth )
{
- if( mVisual )
- {
- CustomActor self = Self();
- Toolkit::GetImplementation(mVisual).SetOnStage( self );
- }
-
Control::OnStageConnection( depth );
}
void VideoView::OnStageDisconnection()
{
- if( mVisual )
- {
- CustomActor self = Self();
- Toolkit::GetImplementation(mVisual).SetOffStage( self );
- }
-
Control::OnStageDisconnection();
}
Actor self = Self();
int curPos = mVideoPlayer.GetPlayPosition();
- if( mVisual )
+ if( mIsPlay )
{
- Toolkit::GetImplementation(mVisual).SetOffStage(self);
- mVisual.Reset();
+ mVideoPlayer.Pause();
}
- Constraint constraint = Constraint::New<bool>( self, mUpdateTriggerPropertyIndex, TriggerFunctor( mNotification ) );
- constraint.AddSource( Source( self, Actor::Property::POSITION ) );
- constraint.AddSource( Source( self, Actor::Property::SIZE ) );
- constraint.Apply();
+ mPositionUpdateNotification = self.AddPropertyNotification( Actor::Property::WORLD_POSITION, StepCondition( 1.0f, 1.0f ) );
+ mSizeUpdateNotification = self.AddPropertyNotification( Actor::Property::SIZE, StepCondition( 1.0f, 1.0f ) );
+ mScaleUpdateNotification = self.AddPropertyNotification( Actor::Property::WORLD_SCALE, StepCondition( 0.1f, 1.0f ) );
+ mPositionUpdateNotification.NotifySignal().Connect( this, &VideoView::UpdateDisplayArea );
+ mSizeUpdateNotification.NotifySignal().Connect( this, &VideoView::UpdateDisplayArea );
+ mScaleUpdateNotification.NotifySignal().Connect( this, &VideoView::UpdateDisplayArea );
+
+ if( mTextureRenderer )
+ {
+ self.RemoveRenderer( mTextureRenderer );
+ }
mVideoPlayer.SetRenderingTarget( Dali::Adaptor::Get().GetNativeWindowHandle() );
mVideoPlayer.SetUrl( mUrl );
- mIsNativeImageTarget = false;
-
- if( mIsPlay )
+ if( !mOverlayRenderer )
{
- mVideoPlayer.Play();
+ // For underlay rendering mode, video display area have to be transparent.
+ Geometry geometry = VisualFactoryCache::CreateQuadGeometry();
+ Shader shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
+ mOverlayRenderer = Renderer::New( geometry, shader );
+ mOverlayRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::OFF );
}
- if( mIsPause )
+
+ if( mIsPlay )
{
- mVideoPlayer.Play();
- mVideoPlayer.Pause();
+ Play();
}
if( curPos > 0 )
{
mVideoPlayer.SetPlayPosition( curPos );
}
-
- // For underlay rendering mode, video display area have to be transparent.
- Geometry geometry = VisualFactoryCache::CreateQuadGeometry();
- Shader shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
- Renderer renderer = Renderer::New( geometry, shader );
-
- renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
- renderer.SetProperty( Renderer::Property::BLEND_FACTOR_SRC_RGB, BlendFactor::ONE );
- renderer.SetProperty( Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::ZERO );
- renderer.SetProperty( Renderer::Property::BLEND_FACTOR_SRC_ALPHA, BlendFactor::ONE );
- renderer.SetProperty( Renderer::Property::BLEND_FACTOR_DEST_ALPHA, BlendFactor::ZERO );
- self.AddRenderer( renderer );
}
void VideoView::SetNativeImageTarget()
{
+ if( mVideoPlayer.IsVideoTextureSupported() == false )
+ {
+ DALI_LOG_ERROR( "Platform doesn't support decoded video frame images\n" );
+ mIsUnderlay = true;
+ return;
+ }
+
+ if( mIsPlay )
+ {
+ mVideoPlayer.Pause();
+ }
+
Actor self( Self() );
+
+ if( mOverlayRenderer )
+ {
+ self.RemoveRenderer( mOverlayRenderer );
+ }
+
+ self.RemovePropertyNotification( mPositionUpdateNotification );
+ self.RemovePropertyNotification( mSizeUpdateNotification );
+ self.RemovePropertyNotification( mScaleUpdateNotification );
+
int curPos = mVideoPlayer.GetPlayPosition();
Any source;
Dali::NativeImageSourcePtr nativeImageSourcePtr = Dali::NativeImageSource::New( source );
- mNativeImage = Dali::NativeImage::New( *nativeImageSourcePtr );
+ mNativeTexture = Dali::Texture::New( *nativeImageSourcePtr );
+
+ if( !mTextureRenderer )
+ {
+ Dali::Geometry geometry = VisualFactoryCache::CreateQuadGeometry();
+ Dali::Shader shader = CreateShader();
+ Dali::TextureSet textureSet = Dali::TextureSet::New();
+ textureSet.SetTexture( 0u, mNativeTexture );
+
+ mTextureRenderer = Renderer::New( geometry, shader );
+ mTextureRenderer.SetTextures( textureSet );
+ }
+ else
+ {
+ Dali::TextureSet textureSet = mTextureRenderer.GetTextures();
+ textureSet.SetTexture( 0u, mNativeTexture );
+ }
+ Self().AddRenderer( mTextureRenderer );
mVideoPlayer.SetRenderingTarget( nativeImageSourcePtr );
mVideoPlayer.SetUrl( mUrl );
- Internal::InitializeVisual( self, mVisual, mNativeImage );
- mIsNativeImageTarget = true;
-
if( mIsPlay )
{
- mVideoPlayer.Play();
+ Play();
}
- if( mIsPause )
- {
- mVideoPlayer.Play();
- mVideoPlayer.Pause();
- }
if( curPos > 0 )
{
mVideoPlayer.SetPlayPosition( curPos );
}
}
-void VideoView::UpdateDisplayArea()
+void VideoView::UpdateDisplayArea( Dali::PropertyNotification& source )
{
+ if( !mIsUnderlay )
+ {
+ return;
+ }
+
Actor self( Self() );
bool positionUsesAnchorPoint = self.GetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT ).Get< bool >();
mVideoPlayer.SetDisplayArea( mDisplayArea );
}
+void VideoView::SetUnderlay( bool set )
+{
+ if( set != mIsUnderlay )
+ {
+ mIsUnderlay = set;
+
+ if( mIsUnderlay )
+ {
+ SetWindowSurfaceTarget();
+ }
+ else
+ {
+ SetNativeImageTarget();
+ }
+
+ RelayoutRequest();
+ }
+}
+
+bool VideoView::IsUnderlay()
+{
+ return mIsUnderlay;
+}
+
+void VideoView::SetSWCodec( bool on )
+{
+ // If setting SW or HW type is failed , video-view shows video by default codec type.
+ // The default codec type is selected by platform.
+ if( on )
+ {
+ mVideoPlayer.SetCodecType( Dali::VideoPlayerPlugin::CodecType::SW );
+ }
+ else
+ {
+ mVideoPlayer.SetCodecType( Dali::VideoPlayerPlugin::CodecType::HW );
+ }
+}
+
+int VideoView::GetPlayPosition()
+{
+ return mVideoPlayer.GetPlayPosition();
+}
+
+void VideoView::SetPlayPosition( int pos )
+{
+ mVideoPlayer.SetPlayPosition( pos );
+}
+
+void VideoView::SetDisplayMode( int mode )
+{
+ mVideoPlayer.SetDisplayMode( static_cast< Dali::VideoPlayerPlugin::DisplayMode::Type >( mode ) );
+}
+
+int VideoView::GetDisplayMode() const
+{
+ return static_cast< int >( mVideoPlayer.GetDisplayMode() );
+}
+
+Dali::Shader VideoView::CreateShader()
+{
+ std::string fragmentShader = "#extension GL_OES_EGL_image_external:require\n";
+ std::string vertexShader;
+ std::string customFragmentShader;
+ bool checkShader = false;
+
+ if( !mEffectPropertyMap.Empty() )
+ {
+ Property::Value* vertexShaderValue = mEffectPropertyMap.Find( CUSTOM_VERTEX_SHADER );
+ if( vertexShaderValue )
+ {
+ checkShader = GetStringFromProperty( *vertexShaderValue, vertexShader );
+ }
+
+ if( !vertexShaderValue || !checkShader )
+ {
+ vertexShader = VERTEX_SHADER_TEXTURE;
+ }
+
+ Property::Value* fragmentShaderValue = mEffectPropertyMap.Find( CUSTOM_FRAGMENT_SHADER );
+ if( fragmentShaderValue )
+ {
+ checkShader = GetStringFromProperty( *fragmentShaderValue, customFragmentShader );
+
+ if( checkShader )
+ {
+ fragmentShader = customFragmentShader;
+ }
+ }
+
+ if( !fragmentShaderValue || !checkShader )
+ {
+ fragmentShader += FRAGMENT_SHADER_TEXTURE;
+ }
+ }
+ else
+ {
+ vertexShader = VERTEX_SHADER_TEXTURE;
+ fragmentShader += FRAGMENT_SHADER_TEXTURE;
+ }
+
+ return Dali::Shader::New( vertexShader, fragmentShader );
+}
+
+bool VideoView::GetStringFromProperty( const Dali::Property::Value& value, std::string& output )
+{
+ bool extracted = false;
+ if( value.Get( output ) )
+ {
+ extracted = true;
+ }
+
+ return extracted;
+}
+
} // namespace Internal
} // namespace toolkit