dali/internal/imaging/common/loader-ico.cpp

   1 /*
   2  * Copyright (c) 2017 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  * Derived from Enlightenment file evas_image_load_ico.c[1]  which is licensed
  19  * under the BSD 2-clause license[2] reproduced below.
  20  *
  21  * [1][http://web.archive.org/web/20141201151111/http://git.enlightenment.org/core/efl.git/tree/src/modules/evas/loaders/ico/evas_image_load_ico.c]
  22  * [2][http://web.archive.org/web/20140717012400/https://git.enlightenment.org/core/efl.git/about/]
  23  *
  24  * Copyright (C) 2002-2012 Carsten Haitzler, Dan Sinclair, Mike Blumenkrantz,
  25  * Samsung Electronics and various contributors (see AUTHORS)
  26  *
  27  * All rights reserved.
  28  *
  29  * Redistribution and use in source and binary forms, with or without
  30  * modification, are permitted provided that the following conditions are met:
  31  *
  32  *    1. Redistributions of source code must retain the above copyright
  33  *       notice, this list of conditions and the following disclaimer.
  34  *    2. Redistributions in binary form must reproduce the above copyright
  35  *       notice, this list of conditions and the following disclaimer in the
  36  *       documentation and/or other materials provided with the distribution.
  37  *
  38  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  39  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  40  * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  41  * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  42  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  43  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  44  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  45  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  46  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  47  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  48  */
  49
  50 // HEADER
  51 #include <dali/internal/imaging/common/loader-ico.h>
  52
  53 // EXTERNAL INCLUDES
  54 #include <cstring>
  55 #include <dali/public-api/common/dali-vector.h>
  56
  57 // INTERNAL INCLUDES
  58 #include <dali/integration-api/debug.h>
  59 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
  60
  61 namespace Dali
  62 {
  63
  64 namespace TizenPlatform
  65 {
  66
  67 namespace
  68 {
  69 // Reserved 2 bytes + type 2 bytes + count 2 bytes + count * 16 bytes
  70 const unsigned char ICO_FILE_HEADER = 22;
  71 // Info header 40 bytes = size 4 bytes + width 4 bytes + height 4 bytes + planes 2 bytes + bitcount 2 bytes
  72 // + compression 4 bytes + imagesize 4 bytes + xpixelsPerM 4 bytes + ypixelsPerM 4 bytes + colorsUsed 4 bytes + colorImportant 4 bytes
  73 // besides, there are rgba color data = numberOfColors * 4 bytes
  74 const unsigned char ICO_IMAGE_INFO_HEADER = 40;
  75
  76 typedef unsigned char  DATA8;
  77 #define A_VAL(p) (reinterpret_cast< DATA8 * >( p )[3])
  78
  79 #define RGB_JOIN(r,g,b) \
  80                 (((r) << 16) + ((g) << 8) + (b))
  81
  82 #define ARGB_JOIN(a,r,g,b) \
  83                 (((a) << 24) + ((r) << 16) + ((g) << 8) + (b))
  84
  85 bool read_ushort(unsigned char *map, size_t length, size_t *position, unsigned short *ret)
  86 {
  87   unsigned char b[2];
  88
  89   if (*position + 2 > length)
  90   {
  91     return false;
  92   }
  93   b[0] = map[(*position)++];
  94   b[1] = map[(*position)++];
  95   *ret = (b[1] << 8) | b[0];
  96   return true;
  97 }
  98
  99 bool read_uint(unsigned char *map, size_t length, size_t *position, unsigned int *ret)
 100 {
 101   unsigned char b[4];
 102   unsigned int i;
 103
 104   if (*position + 4 > length)
 105   {
 106     return false;
 107   }
 108   for (i = 0; i < 4; i++)
 109   {
 110     b[i] = map[(*position)++];
 111   }
 112   *ret = ARGB_JOIN(b[3], b[2], b[1], b[0]);
 113   return true;
 114 }
 115
 116 bool read_uchar(unsigned char *map, size_t length, size_t *position, unsigned char *ret)
 117 {
 118   if (*position + 1 > length)
 119   {
 120     return false;
 121   }
 122   *ret = map[(*position)++];
 123   return true;
 124 }
 125
 126 bool read_mem(unsigned char *map, size_t length, size_t *position, void *buffer, int size)
 127 {
 128   if (*position + size > length)
 129   {
 130     return false;
 131   }
 132   memcpy(buffer, map + *position, size);
 133   *position += size;
 134   return true;
 135 }
 136
 137 enum
 138 {
 139   SMALLEST,
 140   BIGGEST,
 141   SMALLER,
 142   BIGGER
 143 };
 144
 145 enum
 146 {
 147   ICON = 1,
 148   CURSOR = 2
 149 };
 150
 151 struct IcoData
 152 {
 153   int pdelta;
 154   int w, h;
 155   int cols;
 156   int bpp, planes;
 157   int hot_x, hot_y;
 158   unsigned int bmoffset, bmsize;
 159 };
 160
 161 bool LoadIcoHeaderHelper( FILE* fp,
 162                           IcoData& chosen,
 163                           Dali::Vector<unsigned char>& map,
 164                           unsigned int& fsize )
 165 {
 166   memset( &chosen, 0, sizeof(chosen) );
 167
 168   if(fp == NULL)
 169   {
 170     DALI_LOG_ERROR("Error loading bitmap\n");
 171     return false;
 172   }
 173   size_t position = 0;
 174   unsigned short word;
 175   unsigned char byte;
 176
 177   if( fseek(fp,0,SEEK_END) )
 178   {
 179     DALI_LOG_ERROR("Error seeking ICO data\n");
 180     return false;
 181   }
 182
 183   long positionIndicator = ftell(fp);
 184   fsize = 0u;
 185
 186   if( positionIndicator > -1L )
 187   {
 188     fsize = static_cast<unsigned int>(positionIndicator);
 189   }
 190
 191   if( 0u == fsize )
 192   {
 193     return false;
 194   }
 195
 196   if( fseek(fp, 0, SEEK_SET) )
 197   {
 198     DALI_LOG_ERROR("Error seeking ICO data\n");
 199     return false;
 200   }
 201
 202   if (fsize < (ICO_FILE_HEADER + ICO_IMAGE_INFO_HEADER)) //6 + 16 + 40
 203   {
 204     return false;
 205   }
 206   map.Resize(fsize);
 207
 208   if(fread(&map[0], 1, fsize, fp) != fsize)
 209   {
 210     DALI_LOG_WARNING("image file read opeation error!\n");
 211     return false;
 212   }
 213
 214   int search = BIGGEST;
 215   unsigned short reserved, type, count;
 216   if (!read_ushort(&map[0], fsize, &position, &reserved))
 217   {
 218     return false;
 219   }
 220   if (!read_ushort(&map[0], fsize, &position, &type))
 221   {
 222     return false;
 223   }
 224   if (!read_ushort(&map[0], fsize, &position, &count))
 225   {
 226     return false;
 227   }
 228   if (!((reserved == 0) &&
 229        ((type == ICON) || (type == CURSOR)) && (count != 0)))
 230   {
 231     return false;
 232   }
 233   search = BIGGEST;
 234   chosen.pdelta = 0;
 235   bool have_choice = false;
 236
 237   for (unsigned short i = 0; i < count; i++)
 238   {
 239     unsigned char tw = 0, th = 0, tcols = 0;
 240     if (!read_uchar(&map[0], fsize, &position, &tw))
 241     {
 242       return false;
 243     }
 244     int w = tw;
 245     if (w <= 0)
 246     {
 247       w = 256;
 248     }
 249     if (!read_uchar(&map[0], fsize, &position, &th))
 250     {
 251       return false;
 252
 253     }
 254     int h = th;
 255     if (h <= 0)
 256     {
 257       h = 256;
 258     }
 259     if (!read_uchar(&map[0], fsize, &position, &tcols))
 260     {
 261       return false;
 262     }
 263     int cols = tcols;
 264     if (!read_uchar(&map[0], fsize, &position, &byte))
 265     {
 266       return false;
 267     }
 268     if (!read_ushort(&map[0], fsize, &position, &word))
 269     {
 270       return false;
 271     }
 272     int planes=0;
 273     if (type == 1)
 274     {
 275       planes = word;
 276     }
 277     //else hot_x = word;
 278     if (!read_ushort(&map[0], fsize, &position, &word))
 279     {
 280       return false;
 281     }
 282     int bpp=0;
 283     if (type == 1)
 284     {
 285       bpp = word;
 286     }
 287
 288     // 0 colors means 256 for paletized modes.
 289     // Note: We must not do this conversion for bpp greater than 8, as there is no palette.
 290     if( bpp <= 8 && cols == 0 )
 291     {
 292       cols = 256;
 293     }
 294
 295     //else hot_y = word;
 296     unsigned int bmoffset, bmsize;
 297     if (!read_uint(&map[0], fsize, &position, &bmsize))
 298     {
 299       return false;
 300     }
 301     if (!read_uint(&map[0], fsize, &position, &bmoffset))
 302     {
 303       return false;
 304     }
 305     if ((bmsize <= 0) || (bmoffset <= 0) || (bmoffset >= fsize))
 306     {
 307       return false;
 308     }
 309     if (search == BIGGEST)
 310     {
 311       int pdelta = w * h;
 312       if ((!have_choice) ||
 313        ((pdelta >= chosen.pdelta) &&
 314            (((bpp >= 3) && (bpp >= chosen.bpp)) ||
 315                ((bpp < 3) && (cols >= chosen.cols)))))
 316       {
 317         have_choice = true;
 318         chosen.pdelta = pdelta;
 319         chosen.w = w;
 320         chosen.h = h;
 321         chosen.cols = cols;
 322         chosen.bpp = bpp;
 323         chosen.planes = planes;
 324         chosen.bmsize = bmsize;
 325         chosen.bmoffset = bmoffset;
 326       }
 327     }
 328   }
 329
 330   if (chosen.bmoffset == 0)
 331   {
 332     return false;
 333   }
 334
 335   return true;
 336 }
 337
 338 }//unnamed namespace
 339
 340 bool LoadIcoHeader( const Dali::ImageLoader::Input& input, unsigned int& width, unsigned int& height )
 341 {
 342   IcoData chosen;
 343   Dali::Vector<unsigned char> map;
 344   unsigned int fsize;
 345   FILE* const fp = input.file;
 346
 347   if ( false == LoadIcoHeaderHelper(fp, chosen, map, fsize) )
 348   {
 349     return false;
 350   }
 351
 352   width = chosen.w;
 353   height = chosen.h;
 354
 355   return true;
 356 }
 357
 358 bool LoadBitmapFromIco( const Dali::ImageLoader::Input& input, Dali::Devel::PixelBuffer& bitmap )
 359 {
 360   IcoData chosen;
 361   Dali::Vector<unsigned char> map;
 362   unsigned int fsize;
 363   FILE* const fp = input.file;
 364
 365   if ( false == LoadIcoHeaderHelper(fp, chosen, map, fsize) )
 366   {
 367     return false;
 368   }
 369
 370   Dali::Vector<unsigned int> pal;
 371   Dali::Vector<unsigned int> surface;
 372   Dali::Vector<unsigned char> maskbuf;
 373   Dali::Vector<unsigned char> pixbuf;
 374   pal.Resize(256 * 4);
 375
 376   unsigned int dword;
 377   unsigned short word;
 378
 379   int diff_size = 0;
 380   unsigned int* pix;
 381
 382   size_t position = chosen.bmoffset;//22 == position
 383
 384   unsigned int w = chosen.w;
 385   unsigned int h = chosen.h;
 386   unsigned int cols = chosen.cols;
 387
 388   // read bmp header time... let's do some checking
 389   if (!read_uint(&map[0], fsize, &position, &dword))
 390   {
 391     return false; // headersize - dont care
 392   }
 393   if (!read_uint(&map[0], fsize, &position, &dword))
 394   {
 395     return false; // width
 396   }
 397   if (dword > 0)
 398   {
 399     if (dword != w)
 400     {
 401       w = dword;
 402       diff_size = 1;
 403     }
 404   }
 405   if (!read_uint(&map[0], fsize, &position, &dword))
 406   {
 407     return false; // height
 408   }
 409   if (dword > 0)
 410   {
 411     if (dword != (h * 2))
 412     {
 413       h = dword / 2;
 414       diff_size = 1;
 415     }
 416   }
 417   if (diff_size)
 418   {
 419     DALI_LOG_WARNING("Broken ICO file!\n");
 420   }
 421
 422   // Set up the surface as soon as we have the width and height, so we have a black image if there are any further errors.
 423   surface.Resize( w * h * 4 );
 424   memset( &surface[0], 0, w * h * 4 );
 425
 426   if (!read_ushort(&map[0], fsize, &position, &word))
 427   {
 428     return false; // planes
 429   }
 430   //planes2 = word;
 431   if (!read_ushort(&map[0], fsize, &position, &word))
 432   {
 433     return false; // bitcount
 434   }
 435   unsigned int bitcount = word;
 436   if (!read_uint(&map[0], fsize, &position, &dword))
 437   {
 438     return false; // compression
 439   }
 440   //compression = dword;
 441   if (!read_uint(&map[0], fsize, &position, &dword))
 442   {
 443     return false; // imagesize
 444   }
 445   //imagesize = dword;
 446   if (!read_uint(&map[0], fsize, &position, &dword))
 447   {
 448     return false; // z pixels per m
 449   }
 450   if (!read_uint(&map[0], fsize, &position, &dword))
 451   {
 452     return false; // y pizels per m
 453   }
 454   if (!read_uint(&map[0], fsize, &position, &dword))
 455   {
 456     return false; // colors used
 457   }
 458   //colorsused = dword;
 459   if (!read_uint(&map[0], fsize, &position, &dword))
 460   {
 461     return false; // colors important
 462   }
 463
 464   for( unsigned int i = 0; i < cols ; i ++ )
 465   {
 466     unsigned char a, r, g, b;
 467
 468     if (!read_uchar(&map[0], fsize, &position, &b))
 469     {
 470       return false;
 471     }
 472     if (!read_uchar(&map[0], fsize, &position, &g))
 473     {
 474       return false;
 475     }
 476     if (!read_uchar(&map[0], fsize, &position, &r))
 477     {
 478       return false;
 479     }
 480     if (!read_uchar(&map[0], fsize, &position, &a))
 481     {
 482       return false;
 483     }
 484     pal[i] = ARGB_JOIN( 0xff, b, g, r );
 485   }
 486
 487   // This is the reference way of calculating the total number of bytes necessary to store one row of pixels.
 488   unsigned int stride = ( ( ( bitcount * w ) + 31 ) / 32 ) * 4;
 489   unsigned int bitStride = ( ( w + 31 ) / 32 ) * 4;
 490
 491   // Pixbuf only ever contains one scanline worth of data.
 492   pixbuf.Resize( stride );
 493   maskbuf.Resize( bitStride * h );
 494
 495   // Handle different bits-per-pixel.
 496   // Note: Switch is in order of most common format first.
 497   switch( bitcount )
 498   {
 499     case 32:
 500     {
 501       unsigned char* p = &map[position];
 502       pix = &surface[0] + ( ( h - 1 ) * w );
 503
 504       for( unsigned int i = 0; i < h; i++ )
 505       {
 506         for( unsigned int j = 0; j < w; j++ )
 507         {
 508           *pix++ = ARGB_JOIN( p[3], p[0], p[1], p[2] );
 509           p += 4;
 510         }
 511         // Move the output up 1 line (we subtract 2 lines because we moved forward one line while copying).
 512         pix -= ( w * 2 );
 513       }
 514       break;
 515     }
 516
 517     case 24:
 518     {
 519       for( unsigned int i = 0; i < h; i++ )
 520       {
 521         pix = &surface[0] + ( ( h - 1 - i ) * w );
 522         if( !read_mem( &map[0], fsize, &position, &pixbuf[0], stride ) )
 523         {
 524           return false;
 525         }
 526         unsigned char* p = &pixbuf[0];
 527         for( unsigned int j = 0; j < w; j++ )
 528         {
 529           *pix++ = ARGB_JOIN( 0xff, p[0], p[1], p[2] );
 530           p += 3;
 531         }
 532       }
 533       break;
 534     }
 535
 536     case 8:
 537     {
 538       for( unsigned int i = 0; i < h; i++ )
 539       {
 540         pix = &surface[0] + ( ( h - 1 - i ) * w );
 541         if( !read_mem( &map[0], fsize, &position, &pixbuf[0], stride ) )
 542         {
 543           return false;
 544         }
 545         unsigned char* p = &pixbuf[0];
 546         for( unsigned int j = 0; j < w; j++ )
 547         {
 548           *pix++ = pal[*p++];
 549         }
 550       }
 551       break;
 552     }
 553
 554     case 4:
 555     {
 556       for( unsigned int i = 0; i < h; i++ )
 557       {
 558         pix = &surface[0] + ( ( h - 1 - i ) * w );
 559         if( !read_mem( &map[0], fsize, &position, &pixbuf[0], stride ) )
 560         {
 561           return false;
 562         }
 563         unsigned char* p = &pixbuf[0];
 564         for( unsigned int j = 0; j < w; j++ )
 565         {
 566           if( j & 0x1 )
 567           {
 568             *pix = pal[*p & 0x0f];
 569             p++;
 570           }
 571           else
 572           {
 573             *pix = pal[*p >> 4];
 574           }
 575           pix++;
 576         }
 577       }
 578       break;
 579     }
 580
 581     case 1:
 582     {
 583       for( unsigned int i = 0; i < h; i++ )
 584       {
 585         pix = &surface[0] + ( ( h - 1 - i ) * w );
 586         if( !read_mem( &map[0], fsize, &position, &pixbuf[0], stride ) )
 587         {
 588           return false;
 589         }
 590         unsigned char* p = &pixbuf[0];
 591
 592         for( unsigned int j = 0; j < w; j += 8 )
 593         {
 594           *pix++ = pal[ *p >> 7 ];
 595           *pix++ = pal[ *p >> 6 & 0x01 ];
 596           *pix++ = pal[ *p >> 5 & 0x01 ];
 597           *pix++ = pal[ *p >> 4 & 0x01 ];
 598           *pix++ = pal[ *p >> 3 & 0x01 ];
 599           *pix++ = pal[ *p >> 2 & 0x01 ];
 600           *pix++ = pal[ *p >> 1 & 0x01 ];
 601           *pix++ = pal[ *p >> 0 & 0x01 ];
 602
 603           p++;
 604         }
 605       }
 606       break;
 607     }
 608
 609     default:
 610     {
 611       DALI_LOG_WARNING( "Image file contains unsupported bits-per-pixel %d\n", bitcount );
 612       return false;
 613     }
 614   }
 615
 616   // From the spec: If bpp is less than 32, there will be a 1bpp mask bitmap also.
 617   if( bitcount < 32 )
 618   {
 619     if( !read_mem( &map[0], fsize, &position, &maskbuf[0], bitStride * h ) )
 620     {
 621       return false;
 622     }
 623
 624     // Apply mask.
 625     // Precalc to save time in the loops.
 626     unsigned int bytesPerWidth = w / 8;
 627     unsigned int bytesRemainingPerWidth = w - ( bytesPerWidth << 3 );
 628
 629     // Loop for each line of the image.
 630     for( unsigned int i = 0; i < h; ++i )
 631     {
 632       unsigned char *m = &maskbuf[0] + ( bitStride * i );
 633       pix = &surface[0] + ( ( h - 1 - i ) * w );
 634
 635       // Do chunks of 8 pixels first so mask operations can be unrolled.
 636       for( unsigned int j = 0; j < bytesPerWidth; ++j )
 637       {
 638         // Unrolled 8 bits of the mask to avoid many conditions and branches.
 639         A_VAL( pix++ ) = ( *m & ( 1 << 7 ) ) ? 0x00 : 0xff;
 640         A_VAL( pix++ ) = ( *m & ( 1 << 6 ) ) ? 0x00 : 0xff;
 641         A_VAL( pix++ ) = ( *m & ( 1 << 5 ) ) ? 0x00 : 0xff;
 642         A_VAL( pix++ ) = ( *m & ( 1 << 4 ) ) ? 0x00 : 0xff;
 643         A_VAL( pix++ ) = ( *m & ( 1 << 3 ) ) ? 0x00 : 0xff;
 644         A_VAL( pix++ ) = ( *m & ( 1 << 2 ) ) ? 0x00 : 0xff;
 645         A_VAL( pix++ ) = ( *m & ( 1 << 1 ) ) ? 0x00 : 0xff;
 646         A_VAL( pix++ ) = ( *m & ( 1 << 0 ) ) ? 0x00 : 0xff;
 647         m++;
 648       }
 649
 650       // Handle any remaining width ( < 8 ) or images that are < 8 wide.
 651       if( bytesRemainingPerWidth > 0 )
 652       {
 653         for( unsigned int j = 0; j < bytesRemainingPerWidth; ++j )
 654         {
 655           // Note: Although we are doing less that a bytes worth of mask, we still always start on the first bit.
 656           // If the image is smaller than 8 pixels wide, each mask will still start on a new byte.
 657           A_VAL( pix++ ) = ( *m & ( 1 << ( 7 - j ) ) ) ? 0x00 : 0xff;
 658         }
 659         m++;
 660       }
 661     }
 662   }
 663
 664   bitmap = Dali::Devel::PixelBuffer::New(w, h, Pixel::Format::RGBA8888);
 665   auto pixels = bitmap.GetBuffer();
 666   memcpy( pixels, &surface[0], w * h * 4 );
 667
 668   return true;
 669 }
 670
 671 }
 672
 673 }