dali/internal/imaging/common/pixel-manipulation.cpp

   1 /*
   2  * Copyright (c) 2021 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 // CLASS HEADER
  18 #include <dali/internal/imaging/common/pixel-manipulation.h>
  19
  20 // INTERNAL HEADERS
  21 #include <dali/integration-api/debug.h>
  22 #include <dali/public-api/images/pixel.h>
  23
  24 namespace Dali
  25 {
  26 namespace Internal
  27 {
  28 namespace Adaptor
  29 {
  30 namespace
  31 {
  32 constexpr Channel ALPHA_CHANNEL_ONLY[]       = {ALPHA};
  33 constexpr Channel LUMINANCE_CHANNEL_ONLY[]   = {LUMINANCE};
  34 constexpr Channel LUMINANCE_ALPHA_CHANNELS[] = {LUMINANCE, ALPHA};
  35 constexpr Channel RGB_CHANNELS[]             = {RED, GREEN, BLUE};
  36 constexpr Channel BGR_CHANNELS[]             = {BLUE, GREEN, RED};
  37 constexpr Channel RGBA_CHANNELS[]            = {RED, GREEN, BLUE, ALPHA};
  38 constexpr Channel BGRA_CHANNELS[]            = {BLUE, GREEN, RED, ALPHA};
  39
  40 /**
  41  * @brief Template to Read from a buffer with pixel formats that have one byte per channel.
  42  *
  43  * @tparam NumberOfChannels The number of channels to check
  44  * @param pixelData The pixel data to retrieve the value from
  45  * @param channel The channel we're after
  46  * @param channels The array of channels in the pixel format
  47  * @return The value of the required channel
  48  */
  49 template<size_t NumberOfChannels>
  50 unsigned int ReadChannel(unsigned char* pixelData, Channel channel, const Channel (&channels)[NumberOfChannels])
  51 {
  52   auto num    = 0u;
  53   auto retVal = 0u;
  54   for(auto current : channels)
  55   {
  56     if(channel == current)
  57     {
  58       retVal = static_cast<unsigned int>(*(pixelData + num));
  59       break;
  60     }
  61     ++num;
  62   }
  63   return retVal;
  64 }
  65
  66 /**
  67  * @brief Template to Write to a buffer with pixel formats that have one byte per channel.
  68  *
  69  * @tparam NumberOfChannels The number of channels to check
  70  * @param pixelData The pixel data to write the value to
  71  * @param channel The channel we're after
  72  * @param channelValue The value of the channel to set
  73  * @param channels The array of channels in the pixel format
  74  */
  75 template<size_t NumberOfChannels>
  76 void WriteChannel(unsigned char* pixelData, Channel channel, unsigned int channelValue, const Channel (&channels)[NumberOfChannels])
  77 {
  78   auto num = 0u;
  79   for(auto current : channels)
  80   {
  81     if(channel == current)
  82     {
  83       *(pixelData + num) = static_cast<unsigned char>(channelValue & 0xFF);
  84       break;
  85     }
  86     ++num;
  87   }
  88 }
  89
  90 /**
  91  * @brief Reads from buffers with a pixel format of 565.
  92  *
  93  * @param pixelData The pixel data to read from
  94  * @param channel The channel we're after
  95  * @param one The first channel of the pixel format
  96  * @param two The second channel of the pixel format
  97  * @param three The third channel of the pixel format
  98  * @return The value of the required channel
  99  */
 100 unsigned int ReadChannel565(unsigned char* pixelData, Channel channel, Channel one, Channel two, Channel three)
 101 {
 102   if(channel == one)
 103   {
 104     return (static_cast<unsigned int>(*pixelData) & 0xF8) >> 3;
 105   }
 106   else if(channel == two)
 107   {
 108     return ((static_cast<unsigned int>(*pixelData) & 0x07) << 3) |
 109            ((static_cast<unsigned int>(*(pixelData + 1)) & 0xE0) >> 5);
 110   }
 111   else if(channel == three)
 112   {
 113     return static_cast<unsigned int>(*(pixelData + 1)) & 0x1F;
 114   }
 115   return 0u;
 116 }
 117
 118 /**
 119  * @brief Writes to the buffer with a pixel format of 565.
 120  *
 121  * @param pixelData The pixel data to write to
 122  * @param channel The channel we're after
 123  * @param channelValue The value to write
 124  * @param one The first channel of the pixel format
 125  * @param two The second channel of the pixel format
 126  * @param three The third channel of the pixel format
 127  */
 128 void WriteChannel565(unsigned char* pixelData, Channel channel, unsigned int channelValue, Channel one, Channel two, Channel three)
 129 {
 130   if(channel == one)
 131   {
 132     *pixelData &= static_cast<unsigned char>(~0xF8);
 133     *pixelData |= static_cast<unsigned char>((channelValue << 3) & 0xF8);
 134   }
 135   else if(channel == two)
 136   {
 137     *pixelData &= static_cast<unsigned char>(~0x07);
 138     *pixelData |= static_cast<unsigned char>((channelValue >> 3) & 0x07);
 139
 140     *(pixelData + 1) &= static_cast<unsigned char>(~0xE0);
 141     *(pixelData + 1) |= static_cast<unsigned char>((channelValue << 5) & 0xE0);
 142   }
 143   else if(channel == three)
 144   {
 145     *(pixelData + 1) &= static_cast<unsigned char>(~0x1F);
 146     *(pixelData + 1) |= static_cast<unsigned char>(channelValue & 0x1F);
 147   }
 148 }
 149
 150 /**
 151  * @brief Reads from buffers with a pixel format of 4444.
 152  *
 153  * @param pixelData The pixel data to read from
 154  * @param channel The channel we're after
 155  * @param one The first channel of the pixel format
 156  * @param two The second channel of the pixel format
 157  * @param three The third channel of the pixel format
 158  * @param four The fourth channel of the pixel format
 159  * @return
 160  */
 161 unsigned int ReadChannel4444(unsigned char* pixelData, Channel channel, Channel one, Channel two, Channel three, Channel four)
 162 {
 163   if(channel == one)
 164   {
 165     return (static_cast<unsigned int>(*pixelData) & 0xF0) >> 4;
 166   }
 167   else if(channel == two)
 168   {
 169     return (static_cast<unsigned int>(*pixelData) & 0x0F);
 170   }
 171   else if(channel == three)
 172   {
 173     return (static_cast<unsigned int>(*(pixelData + 1)) & 0xF0) >> 4;
 174   }
 175   else if(channel == four)
 176   {
 177     return (static_cast<unsigned int>(*(pixelData + 1)) & 0x0F);
 178   }
 179   return 0u;
 180 }
 181
 182 /**
 183  * @brief Writes to the buffer with a pixel format of 565.
 184  *
 185  * @param pixelData The pixel data to write to
 186  * @param channel The channel we're after
 187  * @param channelValue The value to write
 188  * @param one The first channel of the pixel format
 189  * @param two The second channel of the pixel format
 190  * @param three The third channel of the pixel format
 191  * @param four The fourth channel of the pixel format
 192  */
 193 void WriteChannel4444(unsigned char* pixelData, Channel channel, unsigned int channelValue, Channel one, Channel two, Channel three, Channel four)
 194 {
 195   if(channel == one)
 196   {
 197     *pixelData &= static_cast<unsigned char>(~0xF0);
 198     *pixelData |= static_cast<unsigned char>((channelValue << 4) & 0xF0);
 199   }
 200   else if(channel == two)
 201   {
 202     *pixelData &= static_cast<unsigned char>(~0x0F);
 203     *pixelData |= static_cast<unsigned char>(channelValue & 0x0F);
 204   }
 205   else if(channel == three)
 206   {
 207     *(pixelData + 1) &= static_cast<unsigned char>(~0xF0);
 208     *(pixelData + 1) |= static_cast<unsigned char>((channelValue << 4) & 0xF0);
 209   }
 210   else if(channel == four)
 211   {
 212     *(pixelData + 1) &= static_cast<unsigned char>(~0x0F);
 213     *(pixelData + 1) |= static_cast<unsigned char>(channelValue & 0x0F);
 214   }
 215 }
 216
 217 /**
 218  * @brief Reads from buffers with a pixel format of 5551.
 219  *
 220  * @param pixelData The pixel data to read from
 221  * @param channel The channel we're after
 222  * @param one The first channel of the pixel format
 223  * @param two The second channel of the pixel format
 224  * @param three The third channel of the pixel format
 225  * @param four The fourth channel of the pixel format
 226  * @return
 227  */
 228 unsigned int ReadChannel5551(unsigned char* pixelData, Channel channel, Channel one, Channel two, Channel three, Channel four)
 229 {
 230   if(channel == one)
 231   {
 232     return (static_cast<unsigned int>(*pixelData) & 0xF8) >> 3;
 233   }
 234   else if(channel == two)
 235   {
 236     return ((static_cast<unsigned int>(*pixelData) & 0x07) << 2) |
 237            ((static_cast<unsigned int>(*(pixelData + 1)) & 0xC0) >> 6);
 238   }
 239   else if(channel == three)
 240   {
 241     return (static_cast<unsigned int>(*(pixelData + 1)) & 0x3E) >> 1;
 242   }
 243   else if(channel == four)
 244   {
 245     return static_cast<unsigned int>(*(pixelData + 1)) & 0x01;
 246   }
 247   return 0u;
 248 }
 249
 250 /**
 251  * @brief Writes to the buffer with a pixel format of 5551.
 252  *
 253  * @param pixelData The pixel data to write to
 254  * @param channel The channel we're after
 255  * @param channelValue The value to write
 256  * @param one The first channel of the pixel format
 257  * @param two The second channel of the pixel format
 258  * @param three The third channel of the pixel format
 259  * @param four The fourth channel of the pixel format
 260  */
 261 void WriteChannel5551(unsigned char* pixelData, Channel channel, unsigned int channelValue, Channel one, Channel two, Channel three, Channel four)
 262 {
 263   // 11111222 22333334
 264   //    F8  7 C0  3E 1
 265   if(channel == one)
 266   {
 267     *pixelData &= static_cast<unsigned char>(~0xF8);
 268     *pixelData |= static_cast<unsigned char>((channelValue << 3) & 0xF8);
 269   }
 270   else if(channel == two)
 271   {
 272     *pixelData &= static_cast<unsigned char>(~0x07);
 273     *pixelData |= static_cast<unsigned char>((channelValue >> 2) & 0x07);
 274
 275     *(pixelData + 1) &= static_cast<unsigned char>(~0xC0);
 276     *(pixelData + 1) |= static_cast<unsigned char>((channelValue << 6) & 0xC0);
 277   }
 278   else if(channel == three)
 279   {
 280     *(pixelData + 1) &= static_cast<unsigned char>(~0x3E);
 281     *(pixelData + 1) |= static_cast<unsigned char>((channelValue << 1) & 0x3E);
 282   }
 283   else if(channel == four)
 284   {
 285     *(pixelData + 1) &= static_cast<unsigned char>(~0x01);
 286     *(pixelData + 1) |= static_cast<unsigned char>(channelValue & 0x01);
 287   }
 288 }
 289
 290 } // unnamed namespace
 291
 292 struct Location
 293 {
 294   unsigned int bitShift;
 295   unsigned int bitMask;
 296   bool         available;
 297 };
 298
 299 struct Locations
 300 {
 301   Location luminance;
 302   Location alpha;
 303   Location red;
 304   Location green;
 305   Location blue;
 306 };
 307
 308 bool HasChannel(Dali::Pixel::Format pixelFormat, Channel channel)
 309 {
 310   switch(pixelFormat)
 311   {
 312     case Dali::Pixel::A8:
 313     {
 314       return (channel == ALPHA);
 315     }
 316     case Dali::Pixel::L8:
 317     {
 318       return (channel == LUMINANCE);
 319     }
 320     case Dali::Pixel::LA88:
 321     {
 322       return (channel == LUMINANCE || channel == ALPHA);
 323     }
 324     case Dali::Pixel::RGB565:
 325     case Dali::Pixel::BGR565:
 326     case Dali::Pixel::RGB888:
 327     case Dali::Pixel::RGB8888:
 328     case Dali::Pixel::BGR8888:
 329     case Dali::Pixel::RGB16F:
 330     case Dali::Pixel::RGB32F:
 331     {
 332       return (channel == RED || channel == GREEN || channel == BLUE);
 333     }
 334
 335     case Dali::Pixel::RGBA8888:
 336     case Dali::Pixel::BGRA8888:
 337     case Dali::Pixel::RGBA4444:
 338     case Dali::Pixel::BGRA4444:
 339     case Dali::Pixel::RGBA5551:
 340     case Dali::Pixel::BGRA5551:
 341     {
 342       return (channel == RED || channel == GREEN || channel == BLUE || channel == ALPHA);
 343     }
 344
 345     case Dali::Pixel::DEPTH_UNSIGNED_INT:
 346     case Dali::Pixel::DEPTH_FLOAT:
 347     {
 348       return (channel == DEPTH);
 349     }
 350
 351     case Dali::Pixel::DEPTH_STENCIL:
 352     {
 353       return (channel == DEPTH || channel == STENCIL);
 354     }
 355
 356     case Dali::Pixel::INVALID:
 357     case Dali::Pixel::COMPRESSED_R11_EAC:
 358     case Dali::Pixel::COMPRESSED_SIGNED_R11_EAC:
 359     case Dali::Pixel::COMPRESSED_RG11_EAC:
 360     case Dali::Pixel::COMPRESSED_SIGNED_RG11_EAC:
 361     case Dali::Pixel::COMPRESSED_RGB8_ETC2:
 362     case Dali::Pixel::COMPRESSED_SRGB8_ETC2:
 363     case Dali::Pixel::COMPRESSED_RGB8_ETC1:
 364     case Dali::Pixel::COMPRESSED_RGB_PVRTC_4BPPV1:
 365     case Dali::Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 366     case Dali::Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 367     case Dali::Pixel::COMPRESSED_RGBA8_ETC2_EAC:
 368     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
 369     case Dali::Pixel::COMPRESSED_RGBA_ASTC_4x4_KHR:
 370     case Dali::Pixel::COMPRESSED_RGBA_ASTC_5x4_KHR:
 371     case Dali::Pixel::COMPRESSED_RGBA_ASTC_5x5_KHR:
 372     case Dali::Pixel::COMPRESSED_RGBA_ASTC_6x5_KHR:
 373     case Dali::Pixel::COMPRESSED_RGBA_ASTC_6x6_KHR:
 374     case Dali::Pixel::COMPRESSED_RGBA_ASTC_8x5_KHR:
 375     case Dali::Pixel::COMPRESSED_RGBA_ASTC_8x6_KHR:
 376     case Dali::Pixel::COMPRESSED_RGBA_ASTC_8x8_KHR:
 377     case Dali::Pixel::COMPRESSED_RGBA_ASTC_10x5_KHR:
 378     case Dali::Pixel::COMPRESSED_RGBA_ASTC_10x6_KHR:
 379     case Dali::Pixel::COMPRESSED_RGBA_ASTC_10x8_KHR:
 380     case Dali::Pixel::COMPRESSED_RGBA_ASTC_10x10_KHR:
 381     case Dali::Pixel::COMPRESSED_RGBA_ASTC_12x10_KHR:
 382     case Dali::Pixel::COMPRESSED_RGBA_ASTC_12x12_KHR:
 383     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
 384     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
 385     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
 386     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
 387     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
 388     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
 389     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
 390     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
 391     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
 392     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
 393     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
 394     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
 395     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
 396     case Dali::Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
 397     {
 398       DALI_LOG_ERROR("Pixel formats for compressed images are not compatible with simple channels.\n");
 399       break;
 400     }
 401   }
 402
 403   return false;
 404 }
 405
 406 unsigned int ReadChannel(unsigned char*      pixelData,
 407                          Dali::Pixel::Format pixelFormat,
 408                          Channel             channel)
 409 {
 410   switch(pixelFormat)
 411   {
 412     case Dali::Pixel::A8:
 413     {
 414       return ReadChannel(pixelData, channel, ALPHA_CHANNEL_ONLY);
 415     }
 416     case Dali::Pixel::L8:
 417     {
 418       return ReadChannel(pixelData, channel, LUMINANCE_CHANNEL_ONLY);
 419     }
 420     case Dali::Pixel::LA88:
 421     {
 422       return ReadChannel(pixelData, channel, LUMINANCE_ALPHA_CHANNELS);
 423     }
 424     case Dali::Pixel::RGB565:
 425     {
 426       return ReadChannel565(pixelData, channel, RED, GREEN, BLUE);
 427     }
 428
 429     case Dali::Pixel::BGR565:
 430     {
 431       return ReadChannel565(pixelData, channel, BLUE, GREEN, RED);
 432     }
 433
 434     case Dali::Pixel::RGB888:
 435     case Dali::Pixel::RGB8888:
 436     {
 437       return ReadChannel(pixelData, channel, RGB_CHANNELS);
 438     }
 439
 440     case Dali::Pixel::BGR8888:
 441     {
 442       return ReadChannel(pixelData, channel, BGR_CHANNELS);
 443     }
 444
 445     case Dali::Pixel::RGBA8888:
 446     {
 447       return ReadChannel(pixelData, channel, RGBA_CHANNELS);
 448     }
 449
 450     case Dali::Pixel::BGRA8888:
 451     {
 452       return ReadChannel(pixelData, channel, BGRA_CHANNELS);
 453     }
 454
 455     case Dali::Pixel::RGBA4444:
 456     {
 457       return ReadChannel4444(pixelData, channel, RED, GREEN, BLUE, ALPHA);
 458     }
 459
 460     case Dali::Pixel::BGRA4444:
 461     {
 462       return ReadChannel4444(pixelData, channel, BLUE, GREEN, RED, ALPHA);
 463     }
 464
 465     case Dali::Pixel::RGBA5551:
 466     {
 467       return ReadChannel5551(pixelData, channel, RED, GREEN, BLUE, ALPHA);
 468     }
 469
 470     case Dali::Pixel::BGRA5551:
 471     {
 472       return ReadChannel5551(pixelData, channel, BLUE, GREEN, RED, ALPHA);
 473     }
 474
 475     case Dali::Pixel::DEPTH_UNSIGNED_INT:
 476     case Dali::Pixel::DEPTH_FLOAT:
 477     case Dali::Pixel::DEPTH_STENCIL:
 478     {
 479       return 0u;
 480     }
 481
 482     default:
 483     {
 484       return 0u;
 485     }
 486   }
 487 }
 488
 489 void WriteChannel(unsigned char*      pixelData,
 490                   Dali::Pixel::Format pixelFormat,
 491                   Channel             channel,
 492                   unsigned int        channelValue)
 493 {
 494   switch(pixelFormat)
 495   {
 496     case Dali::Pixel::A8:
 497     {
 498       WriteChannel(pixelData, channel, channelValue, ALPHA_CHANNEL_ONLY);
 499       break;
 500     }
 501     case Dali::Pixel::L8:
 502     {
 503       WriteChannel(pixelData, channel, channelValue, LUMINANCE_CHANNEL_ONLY);
 504       break;
 505     }
 506     case Dali::Pixel::LA88:
 507     {
 508       WriteChannel(pixelData, channel, channelValue, LUMINANCE_ALPHA_CHANNELS);
 509       break;
 510     }
 511     case Dali::Pixel::RGB565:
 512     {
 513       WriteChannel565(pixelData, channel, channelValue, RED, GREEN, BLUE);
 514       break;
 515     }
 516
 517     case Dali::Pixel::BGR565:
 518     {
 519       WriteChannel565(pixelData, channel, channelValue, BLUE, GREEN, RED);
 520       break;
 521     }
 522
 523     case Dali::Pixel::RGB888:
 524     case Dali::Pixel::RGB8888:
 525     {
 526       WriteChannel(pixelData, channel, channelValue, RGB_CHANNELS);
 527       break;
 528     }
 529
 530     case Dali::Pixel::BGR8888:
 531     {
 532       WriteChannel(pixelData, channel, channelValue, BGR_CHANNELS);
 533       break;
 534     }
 535
 536     case Dali::Pixel::RGBA8888:
 537     {
 538       WriteChannel(pixelData, channel, channelValue, RGBA_CHANNELS);
 539       break;
 540     }
 541
 542     case Dali::Pixel::BGRA8888:
 543     {
 544       WriteChannel(pixelData, channel, channelValue, BGRA_CHANNELS);
 545       break;
 546     }
 547
 548     case Dali::Pixel::RGBA4444:
 549     {
 550       WriteChannel4444(pixelData, channel, channelValue, RED, GREEN, BLUE, ALPHA);
 551       break;
 552     }
 553
 554     case Dali::Pixel::BGRA4444:
 555     {
 556       WriteChannel4444(pixelData, channel, channelValue, BLUE, GREEN, RED, ALPHA);
 557       break;
 558     }
 559
 560     case Dali::Pixel::RGBA5551:
 561     {
 562       WriteChannel5551(pixelData, channel, channelValue, RED, GREEN, BLUE, ALPHA);
 563       break;
 564     }
 565
 566     case Dali::Pixel::BGRA5551:
 567     {
 568       WriteChannel5551(pixelData, channel, channelValue, BLUE, GREEN, RED, ALPHA);
 569       break;
 570     }
 571
 572     case Dali::Pixel::DEPTH_UNSIGNED_INT:
 573     case Dali::Pixel::DEPTH_FLOAT:
 574     case Dali::Pixel::DEPTH_STENCIL:
 575     {
 576       break;
 577     }
 578
 579     default:
 580       break;
 581   }
 582 }
 583
 584 void ConvertColorChannelsToRGBA8888(
 585   unsigned char* srcPixel, int srcOffset, Dali::Pixel::Format srcFormat, unsigned char* destPixel, int destOffset)
 586 {
 587   int red   = ReadChannel(srcPixel + srcOffset, srcFormat, RED);
 588   int green = ReadChannel(srcPixel + srcOffset, srcFormat, GREEN);
 589   int blue  = ReadChannel(srcPixel + srcOffset, srcFormat, BLUE);
 590   switch(srcFormat)
 591   {
 592     case Dali::Pixel::RGB565:
 593     case Dali::Pixel::BGR565:
 594     {
 595       red   = (red << 3) | (red & 0x07);
 596       green = (green << 2) | (green & 0x03);
 597       blue  = (blue << 3) | (blue & 0x07);
 598       break;
 599     }
 600     case Dali::Pixel::RGBA4444:
 601     case Dali::Pixel::BGRA4444:
 602     {
 603       red   = (red << 4) | (red & 0x0F);
 604       green = (green << 4) | (green & 0x0F);
 605       blue  = (blue << 4) | (blue & 0x0F);
 606       break;
 607     }
 608     case Dali::Pixel::RGBA5551:
 609     case Dali::Pixel::BGRA5551:
 610     {
 611       red   = (red << 3) | (red & 0x07);
 612       green = (green << 3) | (green & 0x07);
 613       blue  = (blue << 3) | (blue & 0x07);
 614       break;
 615     }
 616     default:
 617       break;
 618   }
 619   WriteChannel(destPixel + destOffset, Dali::Pixel::RGBA8888, RED, red);
 620   WriteChannel(destPixel + destOffset, Dali::Pixel::RGBA8888, GREEN, green);
 621   WriteChannel(destPixel + destOffset, Dali::Pixel::RGBA8888, BLUE, blue);
 622 }
 623
 624 int ConvertAlphaChannelToA8(unsigned char* srcPixel, int srcOffset, Dali::Pixel::Format srcFormat)
 625 {
 626   int alpha     = ReadChannel(srcPixel + srcOffset, srcFormat, ALPHA);
 627   int destAlpha = alpha;
 628   switch(srcFormat)
 629   {
 630     case Pixel::RGBA5551:
 631     case Pixel::BGRA5551:
 632     {
 633       destAlpha = (alpha == 0) ? 0 : 255;
 634       break;
 635     }
 636     case Pixel::RGBA4444:
 637     case Pixel::BGRA4444:
 638     {
 639       destAlpha = (alpha << 4) | (alpha & 0x0F);
 640       break;
 641     }
 642     default:
 643       break;
 644   }
 645   return destAlpha;
 646 }
 647
 648 } // namespace Adaptor
 649 } // namespace Internal
 650 } // namespace Dali