Add a test to check the default Control OnPinch method
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / image-loader / image-load-thread.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 "image-load-thread.h"
20
21 // EXTERNAL INCLUDES
22 #include <dali/devel-api/adaptor-framework/image-loading.h>
23 #include <dali/devel-api/adaptor-framework/thread-settings.h>
24 #include <dali/integration-api/adaptor-framework/adaptor.h>
25 #include <dali/integration-api/debug.h>
26
27 namespace Dali
28 {
29
30 namespace Toolkit
31 {
32
33 namespace Internal
34 {
35
36 LoadingTask::LoadingTask( uint32_t id, Dali::AnimatedImageLoading animatedImageLoading, uint32_t frameIndex )
37 : pixelBuffer(),
38   url(),
39   id( id ),
40   dimensions(),
41   fittingMode(),
42   samplingMode(),
43   orientationCorrection(),
44   preMultiplyOnLoad( DevelAsyncImageLoader::PreMultiplyOnLoad::OFF ),
45   isMaskTask( false ),
46   maskPixelBuffer(),
47   contentScale( 1.0f ),
48   cropToMask( false ),
49   animatedImageLoading( animatedImageLoading ),
50   frameIndex( frameIndex )
51 {
52 }
53
54 LoadingTask::LoadingTask( uint32_t id, const VisualUrl& url, ImageDimensions dimensions,
55                           FittingMode::Type fittingMode, SamplingMode::Type samplingMode, bool orientationCorrection, DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad )
56 : pixelBuffer(),
57   url( url ),
58   id( id ),
59   dimensions( dimensions ),
60   fittingMode( fittingMode ),
61   samplingMode( samplingMode ),
62   orientationCorrection( orientationCorrection ),
63   preMultiplyOnLoad( preMultiplyOnLoad ),
64   isMaskTask( false ),
65   maskPixelBuffer(),
66   contentScale( 1.0f ),
67   cropToMask( false ),
68   animatedImageLoading(),
69   frameIndex( 0u )
70 {
71 }
72
73 LoadingTask::LoadingTask( uint32_t id, Devel::PixelBuffer pixelBuffer, Devel::PixelBuffer maskPixelBuffer, float contentScale, bool cropToMask,
74                           DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad )
75 : pixelBuffer( pixelBuffer ),
76   url( "" ),
77   id( id ),
78   dimensions(),
79   fittingMode(),
80   samplingMode(),
81   orientationCorrection(),
82   preMultiplyOnLoad( preMultiplyOnLoad ),
83   isMaskTask( true ),
84   maskPixelBuffer( maskPixelBuffer ),
85   contentScale( contentScale ),
86   cropToMask( cropToMask ),
87   animatedImageLoading(),
88   frameIndex( 0u )
89 {
90 }
91
92 void LoadingTask::Load()
93 {;
94   if( animatedImageLoading )
95   {
96     pixelBuffer = animatedImageLoading.LoadFrame( frameIndex );
97   }
98   else if( url.IsLocalResource() )
99   {
100     pixelBuffer = Dali::LoadImageFromFile( url.GetUrl(), dimensions, fittingMode, samplingMode, orientationCorrection );
101   }
102   else
103   {
104     pixelBuffer = Dali::DownloadImageSynchronously ( url.GetUrl(), dimensions, fittingMode, samplingMode, orientationCorrection );
105   }
106
107   if( !pixelBuffer )
108   {
109     DALI_LOG_ERROR( "LoadingTask::Load: Loading is failed: %s\n", url.GetUrl().c_str() );
110   }
111 }
112
113 void LoadingTask::ApplyMask()
114 {
115   pixelBuffer.ApplyMask( maskPixelBuffer, contentScale, cropToMask );
116 }
117
118 void LoadingTask::MultiplyAlpha()
119 {
120   if( pixelBuffer && Pixel::HasAlpha( pixelBuffer.GetPixelFormat() ) )
121   {
122     if( preMultiplyOnLoad == DevelAsyncImageLoader::PreMultiplyOnLoad::ON )
123     {
124       pixelBuffer.MultiplyColorByAlpha();
125     }
126   }
127 }
128
129 ImageLoadThread::ImageLoadThread( EventThreadCallback* trigger )
130 : mTrigger( trigger ),
131   mLogFactory( Dali::Adaptor::Get().GetLogFactory() )
132 {
133 }
134
135 ImageLoadThread::~ImageLoadThread()
136 {
137   // add an empty task would stop the thread from conditional wait.
138   AddTask( NULL );
139   // stop the thread
140   Join();
141
142   delete mTrigger;
143 }
144
145 void ImageLoadThread::Run()
146 {
147   SetThreadName( "ImageLoadThread" );
148   mLogFactory.InstallLogFunction();
149
150   while( LoadingTask* task = NextTaskToProcess() )
151   {
152     if( !task->isMaskTask )
153     {
154       task->Load();
155     }
156     else
157     {
158       task->ApplyMask();
159     }
160     task->MultiplyAlpha();
161
162     AddCompletedTask( task );
163   }
164 }
165
166 void ImageLoadThread::AddTask( LoadingTask* task )
167 {
168   bool wasEmpty = false;
169   {
170     // Lock while adding task to the queue
171     ConditionalWait::ScopedLock lock( mConditionalWait );
172     wasEmpty = mLoadQueue.Empty();
173     mLoadQueue.PushBack( task );
174   }
175
176   if( wasEmpty )
177   {
178     // wake up the image loading thread
179     mConditionalWait.Notify();
180   }
181 }
182
183 LoadingTask* ImageLoadThread::NextCompletedTask()
184 {
185   // Lock while popping task out from the queue
186   Mutex::ScopedLock lock( mMutex );
187
188   if( mCompleteQueue.Empty() )
189   {
190     return NULL;
191   }
192
193   Vector< LoadingTask* >::Iterator next = mCompleteQueue.Begin();
194   LoadingTask* nextTask = *next;
195   mCompleteQueue.Erase( next );
196
197   return nextTask;
198 }
199
200 bool ImageLoadThread::CancelTask( uint32_t loadingTaskId )
201 {
202   // Lock while remove task from the queue
203   ConditionalWait::ScopedLock lock( mConditionalWait );
204
205   for( Vector< LoadingTask* >::Iterator iter = mLoadQueue.Begin(); iter != mLoadQueue.End(); ++iter )
206   {
207     if( (*iter)->id == loadingTaskId )
208     {
209       delete (*iter);
210       mLoadQueue.Erase( iter );
211       return true;
212     }
213   }
214
215   return false;
216 }
217
218
219 void ImageLoadThread::CancelAll()
220 {
221   // Lock while remove task from the queue
222   ConditionalWait::ScopedLock lock( mConditionalWait );
223
224   for( Vector< LoadingTask* >::Iterator iter = mLoadQueue.Begin(); iter != mLoadQueue.End(); ++iter )
225   {
226     delete ( *iter );
227   }
228   mLoadQueue.Clear();
229 }
230
231 LoadingTask* ImageLoadThread::NextTaskToProcess()
232 {
233   // Lock while popping task out from the queue
234   ConditionalWait::ScopedLock lock( mConditionalWait );
235
236   while( mLoadQueue.Empty() )
237   {
238     mConditionalWait.Wait( lock );
239   }
240
241   Vector< LoadingTask* >::Iterator next = mLoadQueue.Begin();
242   LoadingTask* nextTask = *next;
243   mLoadQueue.Erase( next );
244
245   return nextTask;
246 }
247
248 void ImageLoadThread::AddCompletedTask( LoadingTask* task )
249 {
250   // Lock while adding task to the queue
251   Mutex::ScopedLock lock( mMutex );
252   mCompleteQueue.PushBack( task );
253
254   // wake up the main thread
255   mTrigger->Trigger();
256 }
257
258 } // namespace Internal
259
260 } // namespace Toolkit
261
262 } // namespace Dali