dali/internal/event/images/nine-patch-image-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 <dali/internal/event/images/nine-patch-image-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <cstring> // for memcmp
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/public-api/object/type-registry.h>
  26 #include <dali/integration-api/bitmap.h>
  27 #include <dali/internal/event/common/thread-local-storage.h>
  28 #include <dali/internal/update/manager/update-manager.h>
  29 #include <dali/integration-api/platform-abstraction.h>
  30 #include <dali/integration-api/resource-types.h>
  31
  32
  33 namespace
  34 {
  35 void GetRedOffsetAndMask(Dali::Pixel::Format pixelFormat, int& byteOffset, int& bitMask)
  36 {
  37   switch (pixelFormat)
  38   {
  39     case Dali::Pixel::A8:
  40     case Dali::Pixel::L8:
  41     case Dali::Pixel::LA88:
  42     {
  43       byteOffset=0;
  44       bitMask=0;
  45       break;
  46     }
  47
  48     case Dali::Pixel::RGB888:
  49     case Dali::Pixel::RGB8888:
  50     case Dali::Pixel::RGBA8888:
  51     {
  52       byteOffset=0;
  53       bitMask=0xFF;
  54       break;
  55     }
  56     case Dali::Pixel::BGR8888:
  57     case Dali::Pixel::BGRA8888:
  58     {
  59       byteOffset=2;
  60       bitMask=0xff;
  61       break;
  62     }
  63     case Dali::Pixel::RGB565:
  64     {
  65       byteOffset=0;
  66       bitMask=0xf8;
  67       break;
  68     }
  69     case Dali::Pixel::BGR565:
  70     {
  71       byteOffset=1;
  72       bitMask=0x1f;
  73       break;
  74     }
  75
  76     case Dali::Pixel::RGBA4444:
  77     {
  78       byteOffset=0;
  79       bitMask=0xf0;
  80       break;
  81     }
  82     case Dali::Pixel::BGRA4444:
  83     {
  84       byteOffset=1;
  85       bitMask=0xf0;
  86       break;
  87     }
  88
  89     case Dali::Pixel::RGBA5551:
  90     {
  91       byteOffset=0;
  92       bitMask=0xf8;
  93       break;
  94     }
  95
  96     case Dali::Pixel::BGRA5551:
  97     {
  98       byteOffset=1;
  99       bitMask=0x1e;
 100       break;
 101     }
 102
 103     case Dali::Pixel::INVALID:
 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     case Dali::Pixel::COMPRESSED_RGBA_ASTC_4x4_KHR:
 117     case Dali::Pixel::COMPRESSED_RGBA_ASTC_5x4_KHR:
 118     case Dali::Pixel::COMPRESSED_RGBA_ASTC_5x5_KHR:
 119     case Dali::Pixel::COMPRESSED_RGBA_ASTC_6x5_KHR:
 120     case Dali::Pixel::COMPRESSED_RGBA_ASTC_6x6_KHR:
 121     case Dali::Pixel::COMPRESSED_RGBA_ASTC_8x5_KHR:
 122     case Dali::Pixel::COMPRESSED_RGBA_ASTC_8x6_KHR:
 123     case Dali::Pixel::COMPRESSED_RGBA_ASTC_8x8_KHR:
 124     case Dali::Pixel::COMPRESSED_RGBA_ASTC_10x5_KHR:
 125     case Dali::Pixel::COMPRESSED_RGBA_ASTC_10x6_KHR:
 126     case Dali::Pixel::COMPRESSED_RGBA_ASTC_10x8_KHR:
 127     case Dali::Pixel::COMPRESSED_RGBA_ASTC_10x10_KHR:
 128     case Dali::Pixel::COMPRESSED_RGBA_ASTC_12x10_KHR:
 129     case Dali::Pixel::COMPRESSED_RGBA_ASTC_12x12_KHR:
 130     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
 131     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
 132     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
 133     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
 134     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
 135     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
 136     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
 137     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
 138     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
 139     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
 140     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
 141     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
 142     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
 143     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
 144     {
 145       DALI_LOG_ERROR("Pixel formats for compressed images are not compatible with simple masking-out of per-pixel alpha.\n");
 146       byteOffset=0;
 147       bitMask=0;
 148       break;
 149     }
 150
 151     case Dali::Pixel::RGB16F:
 152     case Dali::Pixel::RGB32F:
 153     {
 154       DALI_LOG_ERROR("Pixel format not compatible.\n");
 155       byteOffset=0;
 156       bitMask=0;
 157       break;
 158     }
 159   }
 160 }
 161
 162 } // anonymous namespace
 163
 164
 165 namespace Dali
 166 {
 167 namespace Internal
 168 {
 169
 170 namespace
 171 {
 172 TypeRegistration mType( typeid( Dali::NinePatchImage ), typeid( Dali::Image ), NULL );
 173 } // unnamed namespace
 174
 175 NinePatchImagePtr NinePatchImage::New( const std::string& filename )
 176 {
 177   Internal::NinePatchImagePtr internal( new NinePatchImage( filename ) );
 178   internal->Initialize();
 179   return internal;
 180 }
 181
 182 NinePatchImage::NinePatchImage( const std::string& filename )
 183 : ResourceImage(),
 184   mParsedBorder(false)
 185 {
 186   mUrl = filename;
 187   ThreadLocalStorage& tls = ThreadLocalStorage::Get();
 188
 189   Integration::PlatformAbstraction& platformAbstraction = tls.GetPlatformAbstraction();
 190   Integration::BitmapResourceType resourceType;
 191
 192   // Note, bitmap is only destroyed when the image is destroyed.
 193   Integration::ResourcePointer resource = platformAbstraction.LoadImageSynchronously( resourceType, filename );
 194   if( resource )
 195   {
 196     mBitmap = static_cast<Integration::Bitmap*>( resource.Get());
 197
 198     mWidth = mBitmap->GetImageWidth();
 199     mHeight = mBitmap->GetImageHeight();
 200     mTexture = Texture::New( Dali::TextureType::TEXTURE_2D, mBitmap->GetPixelFormat(), mWidth, mHeight );
 201
 202     uint32_t bufferSize = mBitmap->GetBufferSize();
 203     uint8_t* buffer = new uint8_t[bufferSize];
 204     memcpy( buffer, mBitmap->GetBuffer(), bufferSize );
 205     PixelDataPtr pixelData = PixelData::New( buffer, bufferSize, mWidth, mHeight, mBitmap->GetPixelFormat(), Dali::PixelData::DELETE_ARRAY );
 206     mTexture->Upload( pixelData );
 207   }
 208   else
 209   {
 210     mBitmap.Reset();
 211     mWidth = 0;
 212     mHeight = 0;
 213   }
 214 }
 215
 216 NinePatchImage* NinePatchImage::DownCast( Image* image)
 217 {
 218   return dynamic_cast<NinePatchImage*>(image);
 219 }
 220
 221 NinePatchImage::~NinePatchImage()
 222 {
 223 }
 224
 225 const NinePatchImage::StretchRanges& NinePatchImage::GetStretchPixelsX()
 226 {
 227   if( ! mParsedBorder )
 228   {
 229     ParseBorders();
 230   }
 231   return mStretchPixelsX;
 232 }
 233
 234 const NinePatchImage::StretchRanges& NinePatchImage::GetStretchPixelsY()
 235 {
 236   if( ! mParsedBorder )
 237   {
 238     ParseBorders();
 239   }
 240   return mStretchPixelsY;
 241 }
 242
 243 Rect<int> NinePatchImage::GetChildRectangle()
 244 {
 245   if( ! mParsedBorder )
 246   {
 247     ParseBorders();
 248   }
 249   return mChildRectangle;
 250 }
 251
 252 Internal::BufferImagePtr NinePatchImage::CreateCroppedBufferImage()
 253 {
 254   BufferImagePtr cropped;
 255
 256   if( ! mBitmap )
 257   {
 258     DALI_LOG_ERROR( "NinePatchImage: Bitmap not loaded, cannot perform operation\n");
 259   }
 260   else
 261   {
 262     Pixel::Format pixelFormat = mBitmap->GetPixelFormat();
 263
 264     cropped = BufferImage::New( mWidth-2, mHeight-2, pixelFormat );
 265
 266     Integration::Bitmap::PackedPixelsProfile* srcProfile = mBitmap->GetPackedPixelsProfile();
 267     DALI_ASSERT_DEBUG( srcProfile && "Wrong profile for source bitmap");
 268
 269     if( srcProfile )
 270     {
 271       PixelBuffer* destPixels = cropped->GetBuffer();
 272       uint32_t destStride = cropped->GetBufferStride();
 273       uint32_t pixelWidth = GetBytesPerPixel(pixelFormat);
 274
 275       PixelBuffer* srcPixels = mBitmap->GetBuffer();
 276       uint32_t srcStride = srcProfile->GetBufferStride();
 277
 278       for( uint32_t row=1; row < mHeight-1; ++row )
 279       {
 280         PixelBuffer* src  = srcPixels + row*srcStride + pixelWidth;
 281         PixelBuffer* dest = destPixels + (row-1)*destStride;
 282         memcpy(dest, src, destStride );
 283       }
 284     }
 285
 286     RectArea area;
 287     cropped->Update(area); // default area has no width or height
 288   }
 289   return cropped;
 290 }
 291
 292 const std::string& NinePatchImage::GetUrl() const
 293 {
 294   return mUrl;
 295 }
 296
 297 void NinePatchImage::ParseBorders()
 298 {
 299   if( !mBitmap )
 300   {
 301     DALI_LOG_ERROR( "NinePatchImage: Bitmap not loaded, cannot perform operation\n");
 302     return;
 303   }
 304
 305   mStretchPixelsX.Clear();
 306   mStretchPixelsY.Clear();
 307
 308   Pixel::Format pixelFormat = mBitmap->GetPixelFormat();
 309
 310   const Integration::Bitmap::PackedPixelsProfile* srcProfile = mBitmap->GetPackedPixelsProfile();
 311   DALI_ASSERT_DEBUG( srcProfile && "Wrong profile for source bitmap" );
 312
 313   if( srcProfile )
 314   {
 315     int alphaByte = 0;
 316     int alphaBits = 0;
 317     Pixel::GetAlphaOffsetAndMask( pixelFormat, alphaByte, alphaBits );
 318
 319     int testByte = alphaByte;
 320     int testBits = alphaBits;
 321     int testValue = alphaBits; // Opaque == stretch
 322     if( ! alphaBits )
 323     {
 324       GetRedOffsetAndMask( pixelFormat, testByte, testBits );
 325       testValue = 0;           // Black == stretch
 326     }
 327
 328     uint32_t pixelWidth = GetBytesPerPixel( pixelFormat );
 329     const PixelBuffer* srcPixels = mBitmap->GetBuffer();
 330     uint32_t srcStride = srcProfile->GetBufferStride();
 331
 332     //TOP
 333     const PixelBuffer* top = srcPixels + pixelWidth;
 334     uint32_t index = 0;
 335     uint32_t width = mBitmap->GetImageWidth();
 336     uint32_t height = mBitmap->GetImageHeight();
 337
 338     for(; index < width - 2; )
 339     {
 340       Uint16Pair range = ParseRange( index, width - 2, top, pixelWidth, testByte, testBits, testValue );
 341       if( range.GetX() != 0xFFFF )
 342       {
 343         mStretchPixelsX.PushBack( range );
 344       }
 345     }
 346
 347     //LEFT
 348     const PixelBuffer* left  = srcPixels + srcStride;
 349     index = 0;
 350     for(; index < height - 2; )
 351     {
 352       Uint16Pair range = ParseRange( index, height - 2, left, srcStride, testByte, testBits, testValue );
 353       if( range.GetX() != 0xFFFF )
 354       {
 355         mStretchPixelsY.PushBack( range );
 356       }
 357     }
 358
 359     //If there are no stretch pixels then make the entire image stretchable
 360     if( mStretchPixelsX.Size() == 0 )
 361     {
 362       mStretchPixelsX.PushBack( Uint16Pair( 0, width - 2 ) );
 363     }
 364     if( mStretchPixelsY.Size() == 0 )
 365     {
 366       mStretchPixelsY.PushBack( Uint16Pair( 0, height - 2 ) );
 367     }
 368
 369     //Child Rectangle
 370     //BOTTOM
 371     const PixelBuffer* bottom = srcPixels + ( height - 1 ) * srcStride + pixelWidth;
 372     index = 0;
 373     Uint16Pair contentRangeX = ParseRange( index, width - 2, bottom, pixelWidth, testByte, testBits, testValue );
 374     if( contentRangeX.GetX() == 0xFFFF )
 375     {
 376       contentRangeX = Uint16Pair();
 377     }
 378
 379     //RIGHT
 380     const PixelBuffer* right = srcPixels + srcStride + ( width - 1 ) * pixelWidth;
 381     index = 0;
 382     Uint16Pair contentRangeY = ParseRange( index, height - 2, right, srcStride, testByte, testBits, testValue );
 383     if( contentRangeY.GetX() == 0xFFFF )
 384     {
 385       contentRangeY = Uint16Pair();
 386     }
 387
 388     mChildRectangle.x = contentRangeX.GetX() + 1;
 389     mChildRectangle.y = contentRangeY.GetX() + 1;
 390     mChildRectangle.width = contentRangeX.GetY() - contentRangeX.GetX();
 391     mChildRectangle.height = contentRangeY.GetY() - contentRangeY.GetX();
 392
 393     mParsedBorder = true;
 394   }
 395 }
 396
 397 Uint16Pair NinePatchImage::ParseRange( uint32_t& index, uint32_t width, const PixelBuffer* & pixel, uint32_t pixelStride, int testByte, int testBits, int testValue )
 398 {
 399   uint32_t start = 0xFFFF;
 400   for( ; index < width; ++index, pixel += pixelStride )
 401   {
 402     if( ( pixel[ testByte ] & testBits ) == testValue )
 403     {
 404         start = index;
 405         ++index;
 406         pixel += pixelStride;
 407         break;
 408     }
 409   }
 410
 411   uint32_t end = width;
 412   for( ; index < width; ++index, pixel += pixelStride )
 413   {
 414     if( ( pixel[ testByte ] & testBits ) != testValue )
 415     {
 416         end = index;
 417         ++index;
 418         pixel += pixelStride;
 419         break;
 420     }
 421   }
 422
 423   return Uint16Pair( start, end );
 424 }
 425
 426 bool NinePatchImage::IsNinePatchUrl( const std::string& url )
 427 {
 428   bool match = false;
 429
 430   std::string::const_reverse_iterator iter = url.rbegin();
 431   enum { SUFFIX, HASH, HASH_DOT, DONE } state = SUFFIX;
 432   while(iter < url.rend())
 433   {
 434     switch(state)
 435     {
 436       case SUFFIX:
 437       {
 438         if(*iter == '.')
 439         {
 440           state = HASH;
 441         }
 442         else if(!isalnum(*iter))
 443         {
 444           state = DONE;
 445         }
 446       }
 447       break;
 448       case HASH:
 449       {
 450         if( *iter == '#' || *iter == '9' )
 451         {
 452           state = HASH_DOT;
 453         }
 454         else
 455         {
 456           state = DONE;
 457         }
 458       }
 459       break;
 460       case HASH_DOT:
 461       {
 462         if(*iter == '.')
 463         {
 464           match = true;
 465         }
 466         state = DONE; // Stop testing characters
 467       }
 468       break;
 469       case DONE:
 470       {
 471       }
 472       break;
 473     }
 474
 475     // Satisfy prevent
 476     if( state == DONE )
 477     {
 478       break;
 479     }
 480
 481     ++iter;
 482   }
 483   return match;
 484 }
 485
 486 } // namespace Internal
 487
 488 } // namespace Dali