Fix compile error. Non initialized variable.
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / controls / video-view / video-view-impl.cpp
1 /*
2  * Copyright (c) 2020 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 "video-view-impl.h"
20
21 // EXTERNAL INCLUDES
22 #include <cstring>
23 #include <dali/public-api/object/type-registry.h>
24 #include <dali/public-api/object/type-registry-helper.h>
25 #include <dali/devel-api/scripting/scripting.h>
26 #include <dali/devel-api/adaptor-framework/window-devel.h>
27 #include <dali/public-api/adaptor-framework/native-image-source.h>
28 #include <dali/integration-api/debug.h>
29 #include <dali/public-api/animation/constraint.h>
30 #include <dali/devel-api/actors/actor-devel.h>
31
32 // INTERNAL INCLUDES
33 #include <dali-toolkit/public-api/controls/video-view/video-view.h>
34 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
35 #include <dali/integration-api/adaptor-framework/adaptor.h>
36
37 namespace Dali
38 {
39
40 namespace Toolkit
41 {
42
43 namespace Internal
44 {
45
46 namespace
47 {
48
49 BaseHandle Create()
50 {
51   return Toolkit::VideoView::New();
52 }
53
54 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::VideoView, Toolkit::Control, Create );
55
56 DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "video", MAP, VIDEO )
57 DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "looping", BOOLEAN, LOOPING )
58 DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "muted", BOOLEAN, MUTED )
59 DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "volume", MAP, VOLUME )
60 DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "underlay", BOOLEAN, UNDERLAY )
61 DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "playPosition", INTEGER, PLAY_POSITION )
62 DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "displayMode", INTEGER, DISPLAY_MODE )
63
64 DALI_SIGNAL_REGISTRATION( Toolkit, VideoView, "finished", FINISHED_SIGNAL )
65
66 DALI_ACTION_REGISTRATION( Toolkit, VideoView, "play", ACTION_VIDEOVIEW_PLAY )
67 DALI_ACTION_REGISTRATION( Toolkit, VideoView, "pause", ACTION_VIDEOVIEW_PAUSE )
68 DALI_ACTION_REGISTRATION( Toolkit, VideoView, "stop", ACTION_VIDEOVIEW_STOP )
69 DALI_ACTION_REGISTRATION( Toolkit, VideoView, "forward", ACTION_VIDEOVIEW_FORWARD )
70 DALI_ACTION_REGISTRATION( Toolkit, VideoView, "backward", ACTION_VIDEOVIEW_BACKWARD )
71
72 DALI_TYPE_REGISTRATION_END()
73
74 const char* const VOLUME_LEFT( "volumeLeft" );
75 const char* const VOLUME_RIGHT( "volumeRight" );
76
77 // 3.0 TC uses RENDERING_TARGET. It should be removed in next release
78 const char* const RENDERING_TARGET( "renderingTarget" );
79 const char* const WINDOW_SURFACE_TARGET( "windowSurfaceTarget" );
80 const char* const NATIVE_IMAGE_TARGET( "nativeImageTarget" );
81
82 const char* const CUSTOM_SHADER( "shader" );
83 const char* const CUSTOM_VERTEX_SHADER( "vertexShader" );
84 const char* const CUSTOM_FRAGMENT_SHADER( "fragmentShader" );
85 const char* const DEFAULT_SAMPLER_TYPE_NAME( "sampler2D" );
86 const char* const CUSTOM_SAMPLER_TYPE_NAME( "samplerExternalOES" );
87
88 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
89   attribute mediump vec2 aPosition;\n
90   uniform highp   mat4 uMvpMatrix;\n
91   uniform mediump vec3 uSize;\n
92   \n
93   void main()\n
94   {\n
95     mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
96     vertexPosition.xyz *= uSize;\n
97     gl_Position = uMvpMatrix * vertexPosition;\n
98   }\n
99 );
100
101 const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
102   \n
103   void main()\n
104   {\n
105     gl_FragColor = vec4(0.0);\n
106   }\n
107 );
108
109 const char* VERTEX_SHADER_TEXTURE = DALI_COMPOSE_SHADER(
110   attribute mediump vec2 aPosition;\n
111   varying mediump vec2 vTexCoord;\n
112   uniform highp   mat4 uMvpMatrix;\n
113   uniform mediump vec3 uSize;\n
114   varying mediump vec2 sTexCoordRect;\n
115   void main()\n
116   {\n
117     gl_Position = uMvpMatrix * vec4(aPosition * uSize.xy, 0.0, 1.0);\n
118     vTexCoord = aPosition + vec2(0.5);\n
119   }\n
120 );
121
122 const char* FRAGMENT_SHADER_TEXTURE = DALI_COMPOSE_SHADER(
123   uniform lowp vec4 uColor;\n
124   varying mediump vec2 vTexCoord;\n
125   uniform samplerExternalOES sTexture;\n
126   void main()\n
127   {\n
128     gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
129   }\n
130 );
131
132 } // anonymous namepsace
133
134 VideoView::VideoView( Dali::VideoSyncMode syncMode )
135 : Control( ControlBehaviour( ACTOR_BEHAVIOUR_DEFAULT | DISABLE_STYLE_CHANGE_SIGNALS ) ),
136   mCurrentVideoPlayPosition( 0 ),
137   mFrameID( 0 ),
138   mIsPlay( false ),
139   mIsUnderlay( true ),
140   mSyncMode( syncMode )
141 {
142 }
143
144 VideoView::~VideoView()
145 {
146 }
147
148 Toolkit::VideoView VideoView::New( VideoSyncMode syncMode )
149 {
150   VideoView* impl = new VideoView( syncMode );
151   Toolkit::VideoView handle = Toolkit::VideoView( *impl );
152
153   impl->mVideoPlayer = Dali::VideoPlayer::New( impl->Self(), syncMode );
154   impl->Initialize();
155   return handle;
156 }
157
158 void VideoView::OnInitialize()
159 {
160   mVideoPlayer.FinishedSignal().Connect( this, &VideoView::EmitSignalFinish );
161 }
162
163 void VideoView::SetUrl( const std::string& url )
164 {
165     mUrl = url;
166     mPropertyMap.Clear();
167
168   mVideoPlayer.SetUrl( mUrl );
169 }
170
171 void VideoView::SetPropertyMap( Property::Map map )
172 {
173   mPropertyMap = map;
174
175   Property::Value* target = map.Find( RENDERING_TARGET );
176   std::string targetType;
177
178   if( target && target->Get( targetType ) && targetType == WINDOW_SURFACE_TARGET )
179   {
180     mIsUnderlay = true;
181     SetWindowSurfaceTarget();
182   }
183   else if( target && target->Get( targetType ) && targetType == NATIVE_IMAGE_TARGET )
184   {
185     mIsUnderlay = false;
186     SetNativeImageTarget();
187   }
188
189   // Custom shader
190   Property::Value* shaderValue;
191   if( !map.Empty() )
192   {
193     shaderValue = map.Find( CUSTOM_SHADER );
194
195     if( shaderValue )
196     {
197       Property::Map* shaderMap = shaderValue->GetMap();
198       if( shaderMap )
199       {
200         mEffectPropertyMap = *shaderMap;
201       }
202     }
203   }
204
205   if( mTextureRenderer && !mEffectPropertyMap.Empty() )
206   {
207     Dali::Shader shader = CreateShader();
208     mTextureRenderer.SetShader( shader );
209   }
210
211   RelayoutRequest();
212 }
213
214 std::string VideoView::GetUrl()
215 {
216   return mUrl;
217 }
218
219 void VideoView::SetLooping( bool looping )
220 {
221   mVideoPlayer.SetLooping( looping );
222 }
223
224 bool VideoView::IsLooping()
225 {
226   return mVideoPlayer.IsLooping();
227 }
228
229 void VideoView::Play()
230 {
231   if( mOverlayRenderer )
232   {
233     Self().AddRenderer( mOverlayRenderer );
234   }
235
236   mVideoPlayer.Play();
237   mIsPlay = true;
238 }
239
240 void VideoView::Pause()
241 {
242   mVideoPlayer.Pause();
243   mIsPlay = false;
244 }
245
246 void VideoView::Stop()
247 {
248   mVideoPlayer.Stop();
249   mIsPlay = false;
250 }
251
252 void VideoView::Forward( int millisecond )
253 {
254   int curPos = mVideoPlayer.GetPlayPosition();
255
256   int nextPos = curPos + millisecond;
257
258   mVideoPlayer.SetPlayPosition( nextPos );
259 }
260
261 void VideoView::Backward( int millisecond )
262 {
263   int curPos = mVideoPlayer.GetPlayPosition();
264
265   int nextPos = curPos - millisecond;
266   nextPos = ( nextPos < 0 )? 0: nextPos;
267
268   mVideoPlayer.SetPlayPosition( nextPos );
269 }
270
271 void VideoView::SetMute( bool mute )
272 {
273   mVideoPlayer.SetMute( mute );
274 }
275
276 bool VideoView::IsMuted()
277 {
278   return mVideoPlayer.IsMuted();
279 }
280
281 void VideoView::SetVolume( float left, float right )
282 {
283   mVideoPlayer.SetVolume( left, right );
284 }
285
286 void VideoView::GetVolume( float& left, float& right )
287 {
288   mVideoPlayer.GetVolume( left, right );
289 }
290
291 Dali::Toolkit::VideoView::VideoViewSignalType& VideoView::FinishedSignal()
292 {
293   return mFinishedSignal;
294 }
295
296 void VideoView::EmitSignalFinish()
297 {
298   if( mOverlayRenderer )
299   {
300     Self().RemoveRenderer( mOverlayRenderer );
301   }
302
303   if ( !mFinishedSignal.Empty() )
304   {
305     Dali::Toolkit::VideoView handle( GetOwner() );
306     mFinishedSignal.Emit( handle );
307   }
308 }
309
310 bool VideoView::DoAction( BaseObject* object, const std::string& actionName, const Property::Map& attributes )
311 {
312   bool ret = false;
313
314   Dali::BaseHandle handle( object );
315   Toolkit::VideoView videoView = Toolkit::VideoView::DownCast( handle );
316
317   if( !videoView )
318   {
319     return ret;
320   }
321
322   VideoView& impl = GetImpl( videoView );
323
324   if( strcmp( actionName.c_str(), ACTION_VIDEOVIEW_PLAY ) == 0 )
325   {
326     impl.Play();
327     ret = true;
328   }
329   else if( strcmp( actionName.c_str(), ACTION_VIDEOVIEW_PAUSE ) == 0 )
330   {
331     impl.Pause();
332     ret = true;
333   }
334   else if( strcmp( actionName.c_str(), ACTION_VIDEOVIEW_STOP ) == 0 )
335   {
336     impl.Stop();
337     ret = true;
338   }
339   else if( strcmp( actionName.c_str(), ACTION_VIDEOVIEW_FORWARD ) == 0 )
340   {
341     int millisecond = 0;
342     if( attributes["videoForward"].Get( millisecond ) )
343     {
344       impl.Forward( millisecond );
345       ret = true;
346     }
347   }
348   else if( strcmp( actionName.c_str(), ACTION_VIDEOVIEW_BACKWARD ) == 0 )
349   {
350     int millisecond = 0;
351     if( attributes["videoBackward"].Get( millisecond ) )
352     {
353       impl.Backward( millisecond );
354       ret = true;
355     }
356   }
357
358   return ret;
359 }
360
361 bool VideoView::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
362 {
363   Dali::BaseHandle handle( object );
364
365   bool connected( true );
366   Toolkit::VideoView videoView = Toolkit::VideoView::DownCast( handle );
367
368   if( 0 == strcmp( signalName.c_str(), FINISHED_SIGNAL ) )
369   {
370     videoView.FinishedSignal().Connect( tracker, functor );
371   }
372   else
373   {
374     // signalName does not match any signal
375     connected = false;
376   }
377
378   return connected;
379 }
380
381 void VideoView::SetPropertyInternal( Property::Index index, const Property::Value& value )
382 {
383   switch( index )
384   {
385     case Toolkit::VideoView::Property::VIDEO:
386     {
387       std::string videoUrl;
388       Property::Map map;
389
390       if( value.Get( videoUrl ) )
391       {
392         SetUrl( videoUrl );
393       }
394       else if( value.Get( map ) )
395       {
396         SetPropertyMap( map );
397       }
398       break;
399     }
400     case Toolkit::VideoView::Property::LOOPING:
401     {
402       bool looping;
403       if( value.Get( looping ) )
404       {
405         SetLooping( looping );
406       }
407       break;
408     }
409     case Toolkit::VideoView::Property::MUTED:
410     {
411       bool mute;
412       if( value.Get( mute ) )
413       {
414         SetMute( mute );
415       }
416       break;
417     }
418     case Toolkit::VideoView::Property::VOLUME:
419     {
420       Property::Map map;
421       float left, right;
422       if( value.Get( map ) )
423       {
424         Property::Value* volumeLeft = map.Find( VOLUME_LEFT );
425         Property::Value* volumeRight = map.Find( VOLUME_RIGHT );
426         if( volumeLeft && volumeLeft->Get( left ) && volumeRight && volumeRight->Get( right ) )
427         {
428           SetVolume( left, right );
429         }
430       }
431       break;
432     }
433     case Toolkit::VideoView::Property::UNDERLAY:
434     {
435       bool underlay;
436       if( value.Get( underlay ) )
437       {
438         SetUnderlay( underlay );
439       }
440       break;
441     }
442     case Toolkit::VideoView::Property::PLAY_POSITION:
443     {
444       int pos;
445       if( value.Get( pos ) )
446       {
447         SetPlayPosition( pos );
448       }
449       break;
450     }
451     case Toolkit::VideoView::Property::DISPLAY_MODE:
452     {
453       int mode;
454       if( value.Get( mode ) )
455       {
456         SetDisplayMode( mode );
457       }
458       break;
459     }
460   }
461 }
462
463 void VideoView::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
464 {
465   Toolkit::VideoView videoView = Toolkit::VideoView::DownCast( Dali::BaseHandle( object ) );
466
467   if( videoView )
468   {
469     VideoView& impl = GetImpl( videoView );
470
471     impl.SetPropertyInternal( index, value );
472
473     if( index != Toolkit::VideoView::Property::UNDERLAY )
474     {
475       // Backup values.
476       // These values will be used when underlay mode is changed.
477       impl.mPropertyBackup[index] = value;
478     }
479   }
480 }
481
482 Property::Value VideoView::GetProperty( BaseObject* object, Property::Index propertyIndex )
483 {
484   Property::Value value;
485   Toolkit::VideoView videoView = Toolkit::VideoView::DownCast( Dali::BaseHandle( object ) );
486
487   if( videoView )
488   {
489     VideoView& impl = GetImpl( videoView );
490
491     switch( propertyIndex )
492     {
493       case Toolkit::VideoView::Property::VIDEO:
494       {
495         if( !impl.mUrl.empty() )
496         {
497           value = impl.mUrl;
498         }
499         else if( !impl.mPropertyMap.Empty() )
500         {
501           value = impl.mPropertyMap;
502         }
503         break;
504       }
505       case Toolkit::VideoView::Property::LOOPING:
506       {
507         value = impl.IsLooping();
508         break;
509       }
510       case Toolkit::VideoView::Property::MUTED:
511       {
512         value = impl.IsMuted();
513         break;
514       }
515       case Toolkit::VideoView::Property::VOLUME:
516       {
517         Property::Map map;
518         float left, right;
519
520         impl.GetVolume( left, right );
521         map.Insert( VOLUME_LEFT, left );
522         map.Insert( VOLUME_RIGHT, right );
523         value = map;
524         break;
525       }
526       case Toolkit::VideoView::Property::UNDERLAY:
527       {
528         value = impl.IsUnderlay();
529         break;
530       }
531       case Toolkit::VideoView::Property::PLAY_POSITION:
532       {
533         value = impl.GetPlayPosition();
534         break;
535       }
536       case Toolkit::VideoView::Property::DISPLAY_MODE:
537       {
538         value = impl.GetDisplayMode();
539         break;
540       }
541     }
542   }
543
544   return value;
545 }
546
547 void VideoView::SetDepthIndex( int depthIndex )
548 {
549   if( mTextureRenderer )
550   {
551     mTextureRenderer.SetProperty( Renderer::Property::DEPTH_INDEX, depthIndex );
552   }
553 }
554
555 void VideoView::OnSceneConnection( int depth )
556 {
557   Control::OnSceneConnection( depth );
558
559   if( mIsUnderlay )
560   {
561     SetWindowSurfaceTarget();
562   }
563 }
564
565 void VideoView::OnSceneDisconnection()
566 {
567   Control::OnSceneDisconnection();
568 }
569
570 void VideoView::OnSizeSet( const Vector3& targetSize )
571 {
572   if( mIsUnderlay && mSyncMode == Dali::VideoSyncMode::ENABLED )
573   {
574     SetFrameRenderCallback();
575     mVideoPlayer.StartSynchronization();
576   }
577   Control::OnSizeSet( targetSize );
578 }
579
580 Vector3 VideoView::GetNaturalSize()
581 {
582   Vector3 size;
583   size.x = mVideoSize.GetWidth();
584   size.y = mVideoSize.GetHeight();
585
586   if( size.x > 0 && size.y > 0 )
587   {
588     size.z = std::min( size.x, size.y );
589     return size;
590   }
591   else
592   {
593     return Control::GetNaturalSize();
594   }
595 }
596
597 float VideoView::GetHeightForWidth( float width )
598 {
599   if( mVideoSize.GetWidth() > 0 && mVideoSize.GetHeight() > 0 )
600   {
601     return GetHeightForWidthBase( width );
602   }
603   else
604   {
605     return Control::GetHeightForWidthBase( width );
606   }
607 }
608
609 float VideoView::GetWidthForHeight( float height )
610 {
611   if( mVideoSize.GetWidth() > 0 && mVideoSize.GetHeight() > 0 )
612   {
613     return GetWidthForHeightBase( height );
614   }
615   else
616   {
617     return Control::GetWidthForHeightBase( height );
618   }
619 }
620
621 void VideoView::SetWindowSurfaceTarget()
622 {
623   Actor self = Self();
624
625   if( !self.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) )
626   {
627     // When the control is off the stage, it does not have Window.
628     return;
629   }
630
631   int curPos = mVideoPlayer.GetPlayPosition();
632
633   if( mIsPlay )
634   {
635     mVideoPlayer.Pause();
636   }
637
638   mPositionUpdateNotification = self.AddPropertyNotification( Actor::Property::WORLD_POSITION, StepCondition( 1.0f, 1.0f ) );
639   mSizeUpdateNotification = self.AddPropertyNotification( Actor::Property::SIZE, StepCondition( 1.0f, 1.0f ) );
640   mScaleUpdateNotification = self.AddPropertyNotification( Actor::Property::WORLD_SCALE, StepCondition( 0.1f, 1.0f ) );
641   mPositionUpdateNotification.NotifySignal().Connect( this, &VideoView::UpdateDisplayArea );
642   mSizeUpdateNotification.NotifySignal().Connect( this, &VideoView::UpdateDisplayArea );
643   mScaleUpdateNotification.NotifySignal().Connect( this, &VideoView::UpdateDisplayArea );
644
645   if( mTextureRenderer )
646   {
647     self.RemoveRenderer( mTextureRenderer );
648   }
649
650   // Note VideoPlayer::SetRenderingTarget resets all the options. (e.g. url, mute, looping)
651   mVideoPlayer.SetRenderingTarget( Dali::Adaptor::Get().GetNativeWindowHandle( self ) );
652
653   ApplyBackupProperties();
654
655   if( !mOverlayRenderer )
656   {
657     // For underlay rendering mode, video display area have to be transparent.
658     Geometry geometry = VisualFactoryCache::CreateQuadGeometry();
659     Shader shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
660     mOverlayRenderer = Renderer::New( geometry, shader );
661     mOverlayRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::OFF );
662   }
663
664   if( mIsPlay )
665   {
666     Play();
667   }
668
669   if( curPos > 0 )
670   {
671     mVideoPlayer.SetPlayPosition( curPos );
672   }
673 }
674
675 void VideoView::SetNativeImageTarget()
676 {
677   if( mVideoPlayer.IsVideoTextureSupported() == false )
678   {
679     DALI_LOG_ERROR( "Platform doesn't support decoded video frame images\n" );
680     mIsUnderlay = true;
681     return;
682   }
683
684   if( mIsPlay )
685   {
686     mVideoPlayer.Pause();
687   }
688
689   Actor self( Self() );
690
691   if( mOverlayRenderer )
692   {
693     self.RemoveRenderer( mOverlayRenderer );
694
695     mOverlayRenderer.Reset();
696   }
697
698   self.RemovePropertyNotification( mPositionUpdateNotification );
699   self.RemovePropertyNotification( mSizeUpdateNotification );
700   self.RemovePropertyNotification( mScaleUpdateNotification );
701
702   int curPos = mVideoPlayer.GetPlayPosition();
703
704   Any source;
705   Dali::NativeImageSourcePtr nativeImageSourcePtr = Dali::NativeImageSource::New( source );
706   mNativeTexture = Dali::Texture::New( *nativeImageSourcePtr );
707
708   if( !mTextureRenderer )
709   {
710     Dali::Geometry geometry = VisualFactoryCache::CreateQuadGeometry();
711     Dali::Shader shader = CreateShader();
712     Dali::TextureSet textureSet = Dali::TextureSet::New();
713     textureSet.SetTexture( 0u, mNativeTexture );
714
715     mTextureRenderer = Renderer::New( geometry, shader );
716     mTextureRenderer.SetTextures( textureSet );
717   }
718   else
719   {
720     Dali::TextureSet textureSet = mTextureRenderer.GetTextures();
721     textureSet.SetTexture( 0u, mNativeTexture );
722   }
723   Self().AddRenderer( mTextureRenderer );
724
725   // Note VideoPlayer::SetRenderingTarget resets all the options. (e.g. url, mute, looping)
726   mVideoPlayer.SetRenderingTarget( nativeImageSourcePtr );
727
728   ApplyBackupProperties();
729
730   if( mIsPlay )
731   {
732     Play();
733   }
734
735   if( curPos > 0 )
736   {
737     mVideoPlayer.SetPlayPosition( curPos );
738   }
739 }
740
741 void VideoView::UpdateDisplayArea( Dali::PropertyNotification& source )
742 {
743   // If mSyncMode is enabled, Video player's size and poistion is updated in Video player's constraint.
744   // Because video view and player should be work syncronization.
745   if( !mIsUnderlay || mSyncMode == Dali::VideoSyncMode::ENABLED )
746   {
747     return;
748   }
749
750   Actor self( Self() );
751
752   bool positionUsesAnchorPoint = self.GetProperty( Actor::Property::POSITION_USES_ANCHOR_POINT ).Get< bool >();
753   Vector3 actorSize = self.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ) * self.GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
754   Vector3 anchorPointOffSet = actorSize * ( positionUsesAnchorPoint ? self.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ) : AnchorPoint::TOP_LEFT );
755
756   Vector2 screenPosition = self.GetProperty( Actor::Property::SCREEN_POSITION ).Get< Vector2 >();
757
758   mDisplayArea.x = screenPosition.x - anchorPointOffSet.x;
759   mDisplayArea.y = screenPosition.y - anchorPointOffSet.y;
760   mDisplayArea.width = actorSize.x;
761   mDisplayArea.height = actorSize.y;
762
763   mVideoPlayer.SetDisplayArea( mDisplayArea );
764 }
765
766 void VideoView::SetUnderlay( bool set )
767 {
768   if( set != mIsUnderlay )
769   {
770     mIsUnderlay = set;
771
772     if( mIsUnderlay )
773     {
774       SetWindowSurfaceTarget();
775     }
776     else
777     {
778       SetNativeImageTarget();
779     }
780
781     RelayoutRequest();
782   }
783 }
784
785 bool VideoView::IsUnderlay()
786 {
787   return mIsUnderlay;
788 }
789
790 void VideoView::SetSWCodec( bool on )
791 {
792   // If setting SW or HW type is failed , video-view shows video by default codec type.
793   // The default codec type is selected by platform.
794   if( on )
795   {
796     mVideoPlayer.SetCodecType( Dali::VideoPlayerPlugin::CodecType::SW );
797   }
798   else
799   {
800     mVideoPlayer.SetCodecType( Dali::VideoPlayerPlugin::CodecType::HW );
801   }
802 }
803
804 int VideoView::GetPlayPosition()
805 {
806   return mVideoPlayer.GetPlayPosition();
807 }
808
809 void VideoView::SetPlayPosition( int pos )
810 {
811   mVideoPlayer.SetPlayPosition( pos );
812 }
813
814 void VideoView::SetDisplayMode( int mode )
815 {
816   mVideoPlayer.SetDisplayMode( static_cast< Dali::VideoPlayerPlugin::DisplayMode::Type >( mode ) );
817 }
818
819 int VideoView::GetDisplayMode() const
820 {
821   return static_cast< int >( mVideoPlayer.GetDisplayMode() );
822 }
823
824 Any VideoView::GetMediaPlayer()
825 {
826   return mVideoPlayer.GetMediaPlayer();
827 }
828
829 void VideoView::OnAnimationFinished( Animation& animation )
830 {
831   // send desync
832   SetFrameRenderCallback();
833 }
834
835 void VideoView::PlayAnimation( Dali::Animation animation )
836 {
837   if( mIsUnderlay && mSyncMode == Dali::VideoSyncMode::ENABLED )
838   {
839     mVideoPlayer.StartSynchronization();
840     animation.FinishedSignal().Connect( this, &VideoView::OnAnimationFinished );
841   }
842   animation.Play();
843 }
844
845 Dali::Shader VideoView::CreateShader()
846 {
847   std::string fragmentShader = "#extension GL_OES_EGL_image_external:require\n";
848   std::string vertexShader;
849   std::string customFragmentShader;
850   bool checkShader = false;
851
852   if( !mEffectPropertyMap.Empty() )
853   {
854     Property::Value* vertexShaderValue = mEffectPropertyMap.Find( CUSTOM_VERTEX_SHADER );
855     if( vertexShaderValue )
856     {
857       checkShader = GetStringFromProperty( *vertexShaderValue, vertexShader );
858     }
859
860     if( !vertexShaderValue || !checkShader )
861     {
862       vertexShader = VERTEX_SHADER_TEXTURE;
863     }
864
865     Property::Value* fragmentShaderValue = mEffectPropertyMap.Find( CUSTOM_FRAGMENT_SHADER );
866     if( fragmentShaderValue )
867     {
868       checkShader = GetStringFromProperty( *fragmentShaderValue, customFragmentShader );
869
870       if( checkShader )
871       {
872         fragmentShader = customFragmentShader;
873       }
874     }
875
876     if( !fragmentShaderValue || !checkShader )
877     {
878       fragmentShader += FRAGMENT_SHADER_TEXTURE;
879     }
880   }
881   else
882   {
883     vertexShader = VERTEX_SHADER_TEXTURE;
884     fragmentShader += FRAGMENT_SHADER_TEXTURE;
885   }
886
887   return Dali::Shader::New( vertexShader, fragmentShader );
888 }
889
890 bool VideoView::GetStringFromProperty( const Dali::Property::Value& value, std::string& output )
891 {
892   bool extracted = false;
893   if( value.Get( output ) )
894   {
895     extracted = true;
896   }
897
898   return extracted;
899 }
900
901 void VideoView::ApplyBackupProperties()
902 {
903   Property::Map::SizeType pos = 0;
904   Property::Map::SizeType count = mPropertyBackup.Count();
905
906   for( ; pos < count; pos++ )
907   {
908     KeyValuePair property = mPropertyBackup.GetKeyValue( pos );
909
910     SetPropertyInternal( property.first.indexKey, property.second );
911   }
912 }
913
914 void VideoView::FrameRenderCallback( int frameID )
915 {
916   // send desync
917   if( frameID == mFrameID )
918   {
919     mVideoPlayer.FinishSynchronization();
920     mFrameID = 0;
921   }
922 }
923
924 void VideoView::SetFrameRenderCallback()
925 {
926   mFrameID++;
927   DevelWindow::AddFrameRenderedCallback( DevelWindow::Get( Self() ),
928                                          std::unique_ptr< CallbackBase >( MakeCallback( this, &VideoView::FrameRenderCallback ) ), mFrameID );
929 }
930
931 } // namespace Internal
932
933 } // namespace toolkit
934
935 } // namespace Dali