Merge "Change the fitting mode to FILL" into devel/master
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / controls / video-view / video-view-impl.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 "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/public-api/common/stage.h>
26 #include <dali/devel-api/scripting/scripting.h>
27 #include <dali/public-api/adaptor-framework/native-image-source.h>
28 #include <dali/integration-api/adaptors/adaptor.h>
29 #include <dali/integration-api/debug.h>
30 #include <dali/public-api/animation/constraint.h>
31 #include <dali/devel-api/actors/actor-devel.h>
32
33 // INTERNAL INCLUDES
34 #include <dali-toolkit/public-api/controls/video-view/video-view.h>
35 #include <dali-toolkit/public-api/visuals/visual-properties.h>
36 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
37 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
38 #include <dali-toolkit/internal/visuals/visual-base-impl.h>
39 #include <dali-toolkit/internal/visuals/visual-factory-impl.h>
40 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
41
42 namespace Dali
43 {
44
45 namespace Toolkit
46 {
47
48 namespace Internal
49 {
50
51 namespace
52 {
53
54 BaseHandle Create()
55 {
56   return Toolkit::VideoView::New();
57 }
58
59 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::VideoView, Toolkit::Control, Create );
60
61 DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "video", MAP, VIDEO )
62 DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "looping", BOOLEAN, LOOPING )
63 DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "muted", BOOLEAN, MUTED )
64 DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "volume", MAP, VOLUME )
65 DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "underlay", BOOLEAN, UNDERLAY )
66 DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "playPosition", INTEGER, PLAY_POSITION )
67 DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "displayMode", INTEGER, DISPLAY_MODE )
68
69 DALI_SIGNAL_REGISTRATION( Toolkit, VideoView, "finished", FINISHED_SIGNAL )
70
71 DALI_ACTION_REGISTRATION( Toolkit, VideoView, "play", ACTION_VIDEOVIEW_PLAY )
72 DALI_ACTION_REGISTRATION( Toolkit, VideoView, "pause", ACTION_VIDEOVIEW_PAUSE )
73 DALI_ACTION_REGISTRATION( Toolkit, VideoView, "stop", ACTION_VIDEOVIEW_STOP )
74 DALI_ACTION_REGISTRATION( Toolkit, VideoView, "forward", ACTION_VIDEOVIEW_FORWARD )
75 DALI_ACTION_REGISTRATION( Toolkit, VideoView, "backward", ACTION_VIDEOVIEW_BACKWARD )
76
77 DALI_TYPE_REGISTRATION_END()
78
79 const char* const VOLUME_LEFT( "volumeLeft" );
80 const char* const VOLUME_RIGHT( "volumeRight" );
81
82 // 3.0 TC uses RENDERING_TARGET. It should be removed in next release
83 const char* const RENDERING_TARGET( "renderingTarget" );
84 const char* const WINDOW_SURFACE_TARGET( "windowSurfaceTarget" );
85 const char* const NATIVE_IMAGE_TARGET( "nativeImageTarget" );
86
87 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
88   attribute mediump vec2 aPosition;\n
89   uniform mediump mat4 uMvpMatrix;\n
90   uniform mediump vec3 uSize;\n
91   \n
92   void main()\n
93   {\n
94     mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
95     vertexPosition.xyz *= uSize;\n
96     gl_Position = uMvpMatrix * vertexPosition;\n
97   }\n
98 );
99
100 const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
101   uniform lowp vec4 uColor;\n
102   uniform lowp vec3 mixColor;\n
103   \n
104   void main()\n
105   {\n
106     gl_FragColor = vec4(mixColor, 1.0)*uColor;\n
107   }\n
108 );
109
110 } // anonymous namepsace
111
112 VideoView::VideoView()
113 : Control( ControlBehaviour( ACTOR_BEHAVIOUR_DEFAULT | DISABLE_STYLE_CHANGE_SIGNALS ) ),
114   mCurrentVideoPlayPosition( 0 ),
115   mIsPlay( false ),
116   mIsUnderlay( true )
117 {
118   mVideoPlayer = Dali::VideoPlayer::New();
119 }
120
121 VideoView::~VideoView()
122 {
123 }
124
125 Toolkit::VideoView VideoView::New()
126 {
127   VideoView* impl = new VideoView();
128   Toolkit::VideoView handle = Toolkit::VideoView( *impl );
129
130   impl->Initialize();
131
132   return handle;
133 }
134
135 void VideoView::OnInitialize()
136 {
137   mVideoPlayer.FinishedSignal().Connect( this, &VideoView::EmitSignalFinish );
138   SetWindowSurfaceTarget();
139 }
140
141 void VideoView::SetUrl( const std::string& url )
142 {
143   if( mUrl != url || !mPropertyMap.Empty() )
144   {
145     mUrl = url;
146     mPropertyMap.Clear();
147   }
148
149   if( !mIsUnderlay )
150   {
151     Actor self( Self() );
152     Internal::InitializeVisual( self, mVisual, mNativeImage );
153   }
154
155   mVideoPlayer.SetUrl( mUrl );
156 }
157
158 void VideoView::SetPropertyMap( Property::Map map )
159 {
160   mPropertyMap = map;
161
162   Actor self( Self() );
163   Internal::InitializeVisual( self, mVisual, mPropertyMap );
164
165   Property::Value* widthValue = mPropertyMap.Find( "width" );
166   if( widthValue )
167   {
168     int width;
169     if( widthValue->Get( width ) )
170     {
171       mVideoSize = ImageDimensions( width, mVideoSize.GetHeight() );
172     }
173   }
174
175   Property::Value* heightValue = mPropertyMap.Find( "height" );
176   if( heightValue )
177   {
178     int height;
179     if( heightValue->Get( height ) )
180     {
181       mVideoSize = ImageDimensions( mVideoSize.GetWidth(), height );
182     }
183   }
184
185   Property::Value* target = map.Find( RENDERING_TARGET );
186   std::string targetType;
187
188   if( target && target->Get( targetType ) && targetType == WINDOW_SURFACE_TARGET )
189   {
190     mIsUnderlay = true;
191     SetWindowSurfaceTarget();
192   }
193   else if( target && target->Get( targetType ) && targetType == NATIVE_IMAGE_TARGET )
194   {
195     mIsUnderlay = false;
196     SetNativeImageTarget();
197   }
198
199   RelayoutRequest();
200 }
201
202 std::string VideoView::GetUrl()
203 {
204   return mUrl;
205 }
206
207 void VideoView::SetLooping(bool looping)
208 {
209   mVideoPlayer.SetLooping( looping );
210 }
211
212 bool VideoView::IsLooping()
213 {
214   return mVideoPlayer.IsLooping();
215 }
216
217 void VideoView::Play()
218 {
219   if( mIsUnderlay )
220   {
221     Self().AddRenderer( mRenderer );
222   }
223
224   mVideoPlayer.Play();
225   mIsPlay = true;
226 }
227
228 void VideoView::Pause()
229 {
230   mVideoPlayer.Pause();
231   mIsPlay = false;
232 }
233
234 void VideoView::Stop()
235 {
236   mVideoPlayer.Stop();
237   mIsPlay = false;
238 }
239
240 void VideoView::Forward( int millisecond )
241 {
242   int curPos = mVideoPlayer.GetPlayPosition();
243
244   int nextPos = curPos + millisecond;
245
246   mVideoPlayer.SetPlayPosition( nextPos );
247 }
248
249 void VideoView::Backward( int millisecond )
250 {
251   int curPos = mVideoPlayer.GetPlayPosition();
252
253   int nextPos = curPos - millisecond;
254   nextPos = ( nextPos < 0 )? 0: nextPos;
255
256   mVideoPlayer.SetPlayPosition( nextPos );
257 }
258
259 void VideoView::SetMute( bool mute )
260 {
261   mVideoPlayer.SetMute( mute );
262 }
263
264 bool VideoView::IsMuted()
265 {
266   return mVideoPlayer.IsMuted();
267 }
268
269 void VideoView::SetVolume( float left, float right )
270 {
271   mVideoPlayer.SetVolume( left, right );
272 }
273
274 void VideoView::GetVolume( float& left, float& right )
275 {
276   mVideoPlayer.GetVolume( left, right );
277 }
278
279 Dali::Toolkit::VideoView::VideoViewSignalType& VideoView::FinishedSignal()
280 {
281   return mFinishedSignal;
282 }
283
284 void VideoView::EmitSignalFinish()
285 {
286   if( mIsUnderlay )
287   {
288     Self().RemoveRenderer( mRenderer );
289   }
290
291   if ( !mFinishedSignal.Empty() )
292   {
293     Dali::Toolkit::VideoView handle( GetOwner() );
294     mFinishedSignal.Emit( handle );
295   }
296 }
297
298 bool VideoView::DoAction( BaseObject* object, const std::string& actionName, const Property::Map& attributes )
299 {
300   bool ret = false;
301
302   Dali::BaseHandle handle( object );
303   Toolkit::VideoView videoView = Toolkit::VideoView::DownCast( handle );
304
305   if( !videoView )
306   {
307     return ret;
308   }
309
310   VideoView& impl = GetImpl( videoView );
311
312   if( strcmp( actionName.c_str(), ACTION_VIDEOVIEW_PLAY ) == 0 )
313   {
314     impl.Play();
315     ret = true;
316   }
317   else if( strcmp( actionName.c_str(), ACTION_VIDEOVIEW_PAUSE ) == 0 )
318   {
319     impl.Pause();
320     ret = true;
321   }
322   else if( strcmp( actionName.c_str(), ACTION_VIDEOVIEW_STOP ) == 0 )
323   {
324     impl.Stop();
325     ret = true;
326   }
327   else if( strcmp( actionName.c_str(), ACTION_VIDEOVIEW_FORWARD ) == 0 )
328   {
329     int millisecond = 0;
330     if( attributes["videoForward"].Get( millisecond ) )
331     {
332       impl.Forward( millisecond );
333       ret = true;
334     }
335   }
336   else if( strcmp( actionName.c_str(), ACTION_VIDEOVIEW_BACKWARD ) == 0 )
337   {
338     int millisecond = 0;
339     if( attributes["videoBackward"].Get( millisecond ) )
340     {
341       impl.Backward( millisecond );
342       ret = true;
343     }
344   }
345
346   return ret;
347 }
348
349 bool VideoView::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
350 {
351   Dali::BaseHandle handle( object );
352
353   bool connected( true );
354   Toolkit::VideoView videoView = Toolkit::VideoView::DownCast( handle );
355
356   if( 0 == strcmp( signalName.c_str(), FINISHED_SIGNAL ) )
357   {
358     videoView.FinishedSignal().Connect( tracker, functor );
359   }
360   else
361   {
362     // signalName does not match any signal
363     connected = false;
364   }
365
366   return connected;
367 }
368
369 void VideoView::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
370 {
371   Toolkit::VideoView videoView = Toolkit::VideoView::DownCast( Dali::BaseHandle( object ) );
372
373   if( videoView )
374   {
375     VideoView& impl = GetImpl( videoView );
376
377     switch( index )
378     {
379       case Toolkit::VideoView::Property::VIDEO:
380       {
381         std::string videoUrl;
382         Property::Map map;
383
384         if( value.Get( videoUrl ) )
385         {
386           impl.SetUrl( videoUrl );
387         }
388         else if( value.Get( map ) )
389         {
390           Property::Value* shaderValue = map.Find( Toolkit::Visual::Property::SHADER, CUSTOM_SHADER );
391
392           if( map.Count() > 1u || !shaderValue )
393           {
394             impl.SetPropertyMap( map );
395           }
396           else if( impl.mVisual && map.Count() == 1u && shaderValue )
397           {
398             Property::Map shaderMap;
399             if( shaderValue->Get( shaderMap ) )
400             {
401               Internal::Visual::Base& visual = Toolkit::GetImplementation( impl.mVisual );
402               visual.SetCustomShader( shaderMap );
403               if( videoView.OnStage() )
404               {
405                 visual.SetOffStage( videoView );
406                 visual.SetOnStage( videoView );
407               }
408             }
409           }
410         }
411         break;
412       }
413       case Toolkit::VideoView::Property::LOOPING:
414       {
415         bool looping;
416         if( value.Get( looping ) )
417         {
418           impl.SetLooping( looping );
419         }
420         break;
421       }
422       case Toolkit::VideoView::Property::MUTED:
423       {
424         bool mute;
425         if( value.Get( mute ) )
426         {
427           impl.SetMute( mute );
428         }
429         break;
430       }
431       case Toolkit::VideoView::Property::VOLUME:
432       {
433         Property::Map map;
434         float left, right;
435         if( value.Get( map ) )
436         {
437           Property::Value* volumeLeft = map.Find( VOLUME_LEFT );
438           Property::Value* volumeRight = map.Find( VOLUME_RIGHT );
439           if( volumeLeft && volumeLeft->Get( left ) && volumeRight && volumeRight->Get( right ) )
440           {
441             impl.SetVolume( left, right );
442           }
443         }
444         break;
445       }
446       case Toolkit::VideoView::Property::UNDERLAY:
447       {
448         bool underlay;
449         if( value.Get( underlay ) )
450         {
451           impl.SetUnderlay( underlay );
452         }
453         break;
454       }
455       case Toolkit::VideoView::Property::PLAY_POSITION:
456       {
457         int pos;
458         if( value.Get( pos ) )
459         {
460           impl.SetPlayPosition( pos );
461         }
462         break;
463       }
464       case Toolkit::VideoView::Property::DISPLAY_MODE:
465       {
466         int mode;
467         if( value.Get( mode ) )
468         {
469           impl.SetDisplayMode( mode );
470         }
471         break;
472       }
473     }
474   }
475 }
476
477 Property::Value VideoView::GetProperty( BaseObject* object, Property::Index propertyIndex )
478 {
479   Property::Value value;
480   Toolkit::VideoView videoView = Toolkit::VideoView::DownCast( Dali::BaseHandle( object ) );
481
482   if( videoView )
483   {
484     VideoView& impl = GetImpl( videoView );
485
486     switch( propertyIndex )
487     {
488       case Toolkit::VideoView::Property::VIDEO:
489       {
490         if( !impl.mUrl.empty() )
491         {
492           value = impl.mUrl;
493         }
494         else if( !impl.mPropertyMap.Empty() )
495         {
496           value = impl.mPropertyMap;
497         }
498         break;
499       }
500       case Toolkit::VideoView::Property::LOOPING:
501       {
502         value = impl.IsLooping();
503         break;
504       }
505       case Toolkit::VideoView::Property::MUTED:
506       {
507         value = impl.IsMuted();
508         break;
509       }
510       case Toolkit::VideoView::Property::VOLUME:
511       {
512         Property::Map map;
513         float left, right;
514
515         impl.GetVolume( left, right );
516         map.Insert( VOLUME_LEFT, left );
517         map.Insert( VOLUME_RIGHT, right );
518         value = map;
519         break;
520       }
521       case Toolkit::VideoView::Property::UNDERLAY:
522       {
523         value = impl.IsUnderlay();
524         break;
525       }
526       case Toolkit::VideoView::Property::PLAY_POSITION:
527       {
528         value = impl.GetPlayPosition();
529         break;
530       }
531       case Toolkit::VideoView::Property::DISPLAY_MODE:
532       {
533         value = impl.GetDisplayMode();
534         break;
535       }
536     }
537   }
538
539   return value;
540 }
541
542 void VideoView::SetDepthIndex( int depthIndex )
543 {
544   if( mVisual )
545   {
546     mVisual.SetDepthIndex( depthIndex );
547   }
548 }
549
550 void VideoView::OnStageConnection( int depth )
551 {
552   if( mVisual )
553   {
554     CustomActor self = Self();
555     Toolkit::GetImplementation(mVisual).SetOnStage( self );
556   }
557
558   Control::OnStageConnection( depth );
559 }
560
561 void VideoView::OnStageDisconnection()
562 {
563   if( mVisual )
564   {
565     CustomActor self = Self();
566     Toolkit::GetImplementation(mVisual).SetOffStage( self );
567   }
568
569   Control::OnStageDisconnection();
570 }
571
572 Vector3 VideoView::GetNaturalSize()
573 {
574   Vector3 size;
575   size.x = mVideoSize.GetWidth();
576   size.y = mVideoSize.GetHeight();
577
578   if( size.x > 0 && size.y > 0 )
579   {
580     size.z = std::min( size.x, size.y );
581     return size;
582   }
583   else
584   {
585     return Control::GetNaturalSize();
586   }
587 }
588
589 float VideoView::GetHeightForWidth( float width )
590 {
591   if( mVideoSize.GetWidth() > 0 && mVideoSize.GetHeight() > 0 )
592   {
593     return GetHeightForWidthBase( width );
594   }
595   else
596   {
597     return Control::GetHeightForWidthBase( width );
598   }
599 }
600
601 float VideoView::GetWidthForHeight( float height )
602 {
603   if( mVideoSize.GetWidth() > 0 && mVideoSize.GetHeight() > 0 )
604   {
605     return GetWidthForHeightBase( height );
606   }
607   else
608   {
609     return Control::GetWidthForHeightBase( height );
610   }
611 }
612
613 void VideoView::SetWindowSurfaceTarget()
614 {
615   Actor self = Self();
616   int curPos = mVideoPlayer.GetPlayPosition();
617
618   if( mVisual )
619   {
620     Toolkit::GetImplementation(mVisual).SetOffStage(self);
621     mVisual.Reset();
622   }
623
624   if( mIsPlay )
625   {
626     mVideoPlayer.Pause();
627   }
628
629   mPositionUpdateNotification = self.AddPropertyNotification( Actor::Property::WORLD_POSITION, StepCondition( 1.0f, 1.0f ) );
630   mSizeUpdateNotification = self.AddPropertyNotification( Actor::Property::SIZE, StepCondition( 1.0f, 1.0f ) );
631   mScaleUpdateNotification = self.AddPropertyNotification( Actor::Property::WORLD_SCALE, StepCondition( 0.1f, 1.0f ) );
632   mPositionUpdateNotification.NotifySignal().Connect( this, &VideoView::UpdateDisplayArea );
633   mSizeUpdateNotification.NotifySignal().Connect( this, &VideoView::UpdateDisplayArea );
634   mScaleUpdateNotification.NotifySignal().Connect( this, &VideoView::UpdateDisplayArea );
635
636   mVideoPlayer.SetRenderingTarget( Dali::Adaptor::Get().GetNativeWindowHandle() );
637   mVideoPlayer.SetUrl( mUrl );
638
639   if( !mRenderer )
640   {
641     // For underlay rendering mode, video display area have to be transparent.
642     Geometry geometry = VisualFactoryCache::CreateQuadGeometry();
643     Shader shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
644     mRenderer = Renderer::New( geometry, shader );
645
646     mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
647     mRenderer.SetProperty( Renderer::Property::BLEND_FACTOR_SRC_RGB, BlendFactor::ONE );
648     mRenderer.SetProperty( Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::ZERO );
649     mRenderer.SetProperty( Renderer::Property::BLEND_FACTOR_SRC_ALPHA, BlendFactor::ONE );
650     mRenderer.SetProperty( Renderer::Property::BLEND_FACTOR_DEST_ALPHA, BlendFactor::ZERO );
651   }
652
653   if( mIsPlay )
654   {
655     Play();
656   }
657
658   if( curPos > 0 )
659   {
660     mVideoPlayer.SetPlayPosition( curPos );
661   }
662 }
663
664 void VideoView::SetNativeImageTarget()
665 {
666   if( mVideoPlayer.IsVideoTextureSupported() == false )
667   {
668     DALI_LOG_ERROR( "Platform doesn't support decoded video frame images\n" );
669     mIsUnderlay = true;
670     return;
671   }
672
673   if( mIsPlay )
674   {
675     mVideoPlayer.Pause();
676   }
677
678   Actor self( Self() );
679   self.RemoveRenderer( mRenderer );
680   Dali::Stage::GetCurrent().KeepRendering( 0.0f );
681
682   self.RemovePropertyNotification( mPositionUpdateNotification );
683   self.RemovePropertyNotification( mSizeUpdateNotification );
684   self.RemovePropertyNotification( mScaleUpdateNotification );
685
686   int curPos = mVideoPlayer.GetPlayPosition();
687
688   Any source;
689   Dali::NativeImageSourcePtr nativeImageSourcePtr = Dali::NativeImageSource::New( source );
690   mNativeImage = Dali::NativeImage::New( *nativeImageSourcePtr );
691
692   mVideoPlayer.SetRenderingTarget( nativeImageSourcePtr );
693   mVideoPlayer.SetUrl( mUrl );
694
695   Internal::InitializeVisual( self, mVisual, mNativeImage );
696   Self().RemoveRenderer( mRenderer );
697
698   if( mIsPlay )
699   {
700     Play();
701   }
702
703   if( curPos > 0 )
704   {
705     mVideoPlayer.SetPlayPosition( curPos );
706   }
707 }
708
709 void VideoView::UpdateDisplayArea( Dali::PropertyNotification& source )
710 {
711   if( !mIsUnderlay )
712   {
713     return;
714   }
715
716   Actor self( Self() );
717
718   bool positionUsesAnchorPoint = self.GetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT ).Get< bool >();
719   Vector3 actorSize = self.GetCurrentSize() * self.GetCurrentScale();
720   Vector3 anchorPointOffSet = actorSize * ( positionUsesAnchorPoint ? self.GetCurrentAnchorPoint() : AnchorPoint::TOP_LEFT );
721
722   Vector2 screenPosition = self.GetProperty( DevelActor::Property::SCREEN_POSITION ).Get< Vector2 >();
723
724   mDisplayArea.x = screenPosition.x - anchorPointOffSet.x;
725   mDisplayArea.y = screenPosition.y - anchorPointOffSet.y;
726   mDisplayArea.width = actorSize.x;
727   mDisplayArea.height = actorSize.y;
728
729   mVideoPlayer.SetDisplayArea( mDisplayArea );
730 }
731
732 void VideoView::SetUnderlay( bool set )
733 {
734   if( set != mIsUnderlay )
735   {
736     mIsUnderlay = set;
737
738     if( mIsUnderlay )
739     {
740       SetWindowSurfaceTarget();
741     }
742     else
743     {
744       SetNativeImageTarget();
745     }
746
747     RelayoutRequest();
748   }
749 }
750
751 bool VideoView::IsUnderlay()
752 {
753   return mIsUnderlay;
754 }
755
756 void VideoView::SetSWCodec( bool on )
757 {
758   // If setting SW or HW type is failed , video-view shows video by default codec type.
759   // The default codec type is selected by platform.
760   if( on )
761   {
762     mVideoPlayer.SetCodecType( Dali::VideoPlayerPlugin::CodecType::SW );
763   }
764   else
765   {
766     mVideoPlayer.SetCodecType( Dali::VideoPlayerPlugin::CodecType::HW );
767   }
768 }
769
770 int VideoView::GetPlayPosition()
771 {
772   return mVideoPlayer.GetPlayPosition();
773 }
774
775 void VideoView::SetPlayPosition( int pos )
776 {
777   mVideoPlayer.SetPlayPosition( pos );
778 }
779
780 void VideoView::SetDisplayMode( int mode )
781 {
782   mVideoPlayer.SetDisplayMode( static_cast< Dali::VideoPlayerPlugin::DisplayMode::Type >( mode ) );
783 }
784
785 int VideoView::GetDisplayMode() const
786 {
787   return static_cast< int >( mVideoPlayer.GetDisplayMode() );
788 }
789
790 } // namespace Internal
791
792 } // namespace toolkit
793
794 } // namespace Dali