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