Removed synchronous image size getter
[platform/core/uifw/dali-core.git] / dali / internal / event / images / nine-patch-image-impl.cpp
1 /*
2  * Copyright (c) 2014 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 <dali/internal/event/images/nine-patch-image-impl.h>
20
21 // INTERNAL INCLUDES
22 #include <dali/public-api/object/type-registry.h>
23 #include <dali/integration-api/bitmap.h>
24 #include <dali/internal/event/images/bitmap-external.h>
25 #include <dali/internal/event/common/thread-local-storage.h>
26 #include <dali/internal/event/resources/resource-client.h>
27 #include <dali/internal/update/manager/update-manager.h>
28 #include <dali/internal/event/images/image-factory.h>
29 #include <dali/integration-api/platform-abstraction.h>
30 #include <dali/integration-api/resource-types.h>
31 #include <dali/integration-api/resource-cache.h>
32
33
34 namespace
35 {
36 void GetRedOffsetAndMask(Dali::Pixel::Format pixelFormat, int& byteOffset, int& bitMask)
37 {
38   switch (pixelFormat)
39   {
40     case Dali::Pixel::A8:
41     case Dali::Pixel::L8:
42     case Dali::Pixel::LA88:
43     {
44       byteOffset=0;
45       bitMask=0;
46       break;
47     }
48
49     case Dali::Pixel::RGB888:
50     case Dali::Pixel::RGB8888:
51     case Dali::Pixel::RGBA8888:
52     {
53       byteOffset=0;
54       bitMask=0xFF;
55       break;
56     }
57     case Dali::Pixel::BGR8888:
58     case Dali::Pixel::BGRA8888:
59     {
60       byteOffset=2;
61       bitMask=0xff;
62       break;
63     }
64     case Dali::Pixel::RGB565:
65     {
66       byteOffset=0;
67       bitMask=0xf8;
68       break;
69     }
70     case Dali::Pixel::BGR565:
71     {
72       byteOffset=1;
73       bitMask=0x1f;
74       break;
75     }
76
77     case Dali::Pixel::RGBA4444:
78     {
79       byteOffset=0;
80       bitMask=0xf0;
81       break;
82     }
83     case Dali::Pixel::BGRA4444:
84     {
85       byteOffset=1;
86       bitMask=0xf0;
87       break;
88     }
89
90     case Dali::Pixel::RGBA5551:
91     {
92       byteOffset=0;
93       bitMask=0xf8;
94       break;
95     }
96
97     case Dali::Pixel::BGRA5551:
98     {
99       byteOffset=1;
100       bitMask=0x1e;
101       break;
102     }
103
104     case Dali::Pixel::COMPRESSED_R11_EAC:
105     case Dali::Pixel::COMPRESSED_SIGNED_R11_EAC:
106     case Dali::Pixel::COMPRESSED_RG11_EAC:
107     case Dali::Pixel::COMPRESSED_SIGNED_RG11_EAC:
108     case Dali::Pixel::COMPRESSED_RGB8_ETC2:
109     case Dali::Pixel::COMPRESSED_SRGB8_ETC2:
110     case Dali::Pixel::COMPRESSED_RGB8_ETC1:
111     case Dali::Pixel::COMPRESSED_RGB_PVRTC_4BPPV1:
112     case Dali::Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
113     case Dali::Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
114     case Dali::Pixel::COMPRESSED_RGBA8_ETC2_EAC:
115     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
116     {
117       DALI_LOG_ERROR("Pixel formats for compressed images are not compatible with simple masking-out of per-pixel alpha.\n");
118       byteOffset=0;
119       bitMask=0;
120       break;
121     }
122   }
123 }
124
125 } // anonymous namespace
126
127
128 namespace Dali
129 {
130 namespace Internal
131 {
132
133 namespace
134 {
135 TypeRegistration mType( typeid( Dali::NinePatchImage ), typeid( Dali::Image ), NULL );
136 } // unnamed namespace
137
138 NinePatchImagePtr NinePatchImage::New( const std::string& filename, const Dali::ImageAttributes& attributes, LoadPolicy loadPol, ReleasePolicy releasePol )
139 {
140   Internal::NinePatchImagePtr internal( new NinePatchImage( filename, attributes, loadPol, releasePol ) );
141   internal->Initialize();
142   return internal;
143 }
144
145 NinePatchImage::NinePatchImage( const std::string& filename, const Dali::ImageAttributes& attributes, LoadPolicy loadPol, ReleasePolicy releasePol)
146 : Image(Dali::Image::Immediate, Dali::Image::Never),
147   mParsedBorder(false)
148 {
149   ThreadLocalStorage& tls = ThreadLocalStorage::Get();
150   mResourceClient = &tls.GetResourceClient();
151
152   Integration::PlatformAbstraction& platformAbstraction = Internal::ThreadLocalStorage::Get().GetPlatformAbstraction();
153
154   Vector2 closestSize;
155   platformAbstraction.GetClosestImageSize( filename, attributes, closestSize );
156   ImageAttributes loadedAttrs;
157   loadedAttrs.SetSize( closestSize );
158   mWidth = closestSize.width;
159   mHeight = closestSize.height;
160   mNaturalSizeSet = true;
161
162   Integration::BitmapResourceType resourceType( loadedAttrs );
163
164   // Note, bitmap is only destroyed when the image is destroyed.
165   Integration::ResourcePointer resource = platformAbstraction.LoadResourceSynchronously(resourceType, filename);
166   if( resource )
167   {
168     mBitmap = static_cast<Integration::Bitmap*>( resource.Get());
169   }
170   else
171   {
172     mBitmap.Reset();
173   }
174 }
175
176 NinePatchImage* NinePatchImage::GetNinePatchImage( Image* image)
177 {
178   return dynamic_cast<NinePatchImage*>(image);
179 }
180
181 NinePatchImage::~NinePatchImage()
182 {
183 }
184
185 Vector4 NinePatchImage::GetStretchBorders()
186 {
187   if( ! mParsedBorder )
188   {
189     ParseBorders();
190   }
191   return mStretchBorders;
192 }
193
194 Rect<int> NinePatchImage::GetChildRectangle()
195 {
196   if( ! mParsedBorder )
197   {
198     ParseBorders();
199   }
200   return mChildRectangle;
201 }
202
203 Internal::BitmapImagePtr NinePatchImage::CreateCroppedBitmapImage()
204 {
205   BitmapImagePtr cropped;
206
207   if( ! mBitmap )
208   {
209     DALI_LOG_ERROR( "NinePatchImage: Bitmap not loaded, cannot perform operation\n");
210   }
211   else
212   {
213     Pixel::Format pixelFormat = mBitmap->GetPixelFormat();
214
215     cropped = BitmapImage::New( mWidth-2, mHeight-2, pixelFormat, Dali::Image::Immediate, Dali::Image::Never );
216
217     Integration::Bitmap::PackedPixelsProfile* srcProfile = mBitmap->GetPackedPixelsProfile();
218     DALI_ASSERT_DEBUG( srcProfile && "Wrong profile for source bitmap");
219
220     if( srcProfile )
221     {
222       PixelBuffer* destPixels = cropped->GetBuffer();
223       unsigned int destStride = cropped->GetBufferStride();
224       unsigned int pixelWidth = GetBytesPerPixel(pixelFormat);
225
226       PixelBuffer* srcPixels = mBitmap->GetBuffer();
227       unsigned int srcStride = srcProfile->GetBufferStride();
228
229       for( unsigned int row=1; row < mHeight-1; ++row )
230       {
231         PixelBuffer* src  = srcPixels + row*srcStride + pixelWidth;
232         PixelBuffer* dest = destPixels + (row-1)*destStride;
233         memcpy(dest, src, destStride );
234       }
235     }
236
237     RectArea area;
238     cropped->Update(area); // default area has no width or height
239   }
240   return cropped;
241 }
242
243 void NinePatchImage::Connect()
244 {
245   if( !mTicket )
246   {
247     if( mBitmap )
248     {
249       const ImageTicketPtr& t = mResourceClient->AddBitmapImage(mBitmap.Get());
250       mTicket = t.Get();
251       mTicket->AddObserver(*this);
252     }
253   }
254
255   ++mConnectionCount;
256 }
257
258 void NinePatchImage::Disconnect()
259 {
260   if( mConnectionCount > 0 )
261   {
262     --mConnectionCount;
263   }
264 }
265
266
267 void NinePatchImage::ParseBorders()
268 {
269   if( ! mBitmap )
270   {
271     DALI_LOG_ERROR( "NinePatchImage: Bitmap not loaded, cannot perform operation\n");
272     return;
273   }
274
275   Pixel::Format pixelFormat = mBitmap->GetPixelFormat();
276
277   Integration::Bitmap::PackedPixelsProfile* srcProfile = mBitmap->GetPackedPixelsProfile();
278   DALI_ASSERT_DEBUG( srcProfile && "Wrong profile for source bitmap");
279
280   if( srcProfile )
281   {
282     unsigned int pixelWidth = GetBytesPerPixel(pixelFormat);
283     PixelBuffer* srcPixels = mBitmap->GetBuffer();
284     unsigned int srcStride = srcProfile->GetBufferStride();
285
286     int alphaByte=0;
287     int alphaBits=0;
288     Pixel::GetAlphaOffsetAndMask(pixelFormat, alphaByte, alphaBits);
289     int redByte=0;
290     int redBits=0;
291     GetRedOffsetAndMask(pixelFormat, redByte, redBits);
292
293     int testByte = alphaByte;
294     int testBits = alphaBits;
295     int testValue = alphaBits; // Opaque == stretch
296     if( ! alphaBits )
297     {
298       testByte = redByte;
299       testBits = redBits;
300       testValue = 0;           // Black == stretch
301     }
302
303     int startX1=-1;
304     int endX1=-1;
305     int startY1=-1;
306     int endY1=-1;
307     int startX2=-1;
308     int endX2=-1;
309     int startY2=-1;
310     int endY2=-1;
311
312     PixelBuffer* top = srcPixels + pixelWidth;
313     PixelBuffer* bottom = srcPixels + (mHeight-1)*srcStride + pixelWidth;
314
315     // Read the top and bottom rows:
316     // (Also read the last column to ensure end value gets set)
317     for( unsigned int col=1; col < mWidth; ++col )
318     {
319       if( (top[testByte] & testBits) == testValue )
320       {
321         if(startX1 < 0)
322         {
323           startX1 = col;
324         }
325       }
326       else if(startX1 >= 0 && endX1 < 0)
327       {
328         endX1 = col-1;
329         break;
330       }
331
332       if( (bottom[testByte] & testBits) == testValue )
333       {
334         if(startX2 < 0)
335         {
336           startX2 = col;
337         }
338       }
339       else if(startX2 >= 0 && endX2 < 0)
340       {
341         endX2 = col-1;
342         break;
343       }
344       top+=pixelWidth;
345       bottom+=pixelWidth;
346     }
347
348     // Read the left and right columns:
349     PixelBuffer* left  = srcPixels + srcStride;
350     PixelBuffer* right = left + (srcStride - pixelWidth);
351
352     // (Also read the last row to ensure end value gets set)
353     for( unsigned int row=1; row < mHeight; ++row )
354     {
355       if((left[testByte] & testBits) == testValue)
356       {
357         if(startY1 < 0)
358         {
359           startY1 = row;
360         }
361       }
362       else if(startY1 >= 0 && endY1 < 0)
363       {
364         endY1 = row-1;
365         break;
366       }
367
368       if((right[testByte] & testBits) == testValue)
369       {
370         if(startY2 < 0)
371         {
372           startY2 = row;
373         }
374       }
375       else if(startY2 >= 0 && endY2 < 0)
376       {
377         endY2 = row-1;
378         break;
379       }
380       left += srcStride;
381       right += srcStride;
382     }
383
384     mStretchBorders.x = startX1-1;
385     mStretchBorders.y = startY1-1;
386     mStretchBorders.z = mWidth-endX1-1;
387     mStretchBorders.w = mHeight-endY1-1;
388
389     mChildRectangle.x = startX2-1;
390     mChildRectangle.y = startY2-1;
391     mChildRectangle.width = endX2-startX2;
392     mChildRectangle.height = endY2-startY2;
393
394     mParsedBorder = true;
395   }
396 }
397
398 } // namespace Internal
399
400 } // namespace Dali