icon_util.cc revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7
1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "ui/gfx/icon_util.h" 6 7#include "base/file_util.h" 8#include "base/files/important_file_writer.h" 9#include "base/logging.h" 10#include "base/memory/scoped_ptr.h" 11#include "base/win/resource_util.h" 12#include "base/win/scoped_gdi_object.h" 13#include "base/win/scoped_handle.h" 14#include "base/win/scoped_hdc.h" 15#include "skia/ext/image_operations.h" 16#include "third_party/skia/include/core/SkBitmap.h" 17#include "ui/gfx/gdi_util.h" 18#include "ui/gfx/image/image.h" 19#include "ui/gfx/image/image_family.h" 20#include "ui/gfx/size.h" 21 22namespace { 23 24struct ScopedICONINFO : ICONINFO { 25 ScopedICONINFO() { 26 hbmColor = NULL; 27 hbmMask = NULL; 28 } 29 30 ~ScopedICONINFO() { 31 if (hbmColor) 32 ::DeleteObject(hbmColor); 33 if (hbmMask) 34 ::DeleteObject(hbmMask); 35 } 36}; 37 38// Creates a new ImageFamily, |resized_image_family|, based on the images in 39// |image_family|, but containing images of specific dimensions desirable for 40// Windows icons. For each desired image dimension, it chooses the most 41// appropriate image for that size, and resizes it to the desired size. 42// Returns true on success, false on failure. Failure can occur if 43// |image_family| is empty, all images in the family have size 0x0, or an image 44// has no allocated pixel data. 45// |resized_image_family| must be empty. 46bool BuildResizedImageFamily(const gfx::ImageFamily& image_family, 47 gfx::ImageFamily* resized_image_family) { 48 DCHECK(resized_image_family); 49 DCHECK(resized_image_family->empty()); 50 51 for (size_t i = 0; i < IconUtil::kNumIconDimensions; ++i) { 52 int dimension = IconUtil::kIconDimensions[i]; 53 gfx::Size size(dimension, dimension); 54 const gfx::Image* best = image_family.GetBest(size); 55 if (!best || best->IsEmpty()) { 56 // Either |image_family| is empty, or all images have size 0x0. 57 return false; 58 } 59 60 // Optimize for the "Large icons" view in Windows Vista+. This view displays 61 // icons at full size if only if there is a 256x256 (kLargeIconSize) image 62 // in the .ico file. Otherwise, it shrinks icons to 48x48 (kMediumIconSize). 63 if (dimension > IconUtil::kMediumIconSize && 64 best->Width() <= IconUtil::kMediumIconSize && 65 best->Height() <= IconUtil::kMediumIconSize) { 66 // There is no source icon larger than 48x48, so do not create any 67 // images larger than 48x48. kIconDimensions is sorted in ascending 68 // order, so it is safe to break here. 69 break; 70 } 71 72 if (best->Size() == size) { 73 resized_image_family->Add(*best); 74 } else { 75 // There is no |dimension|x|dimension| source image. 76 // Resize this one to the desired size, and insert it. 77 SkBitmap best_bitmap = best->AsBitmap(); 78 // Only kARGB_8888 images are supported. 79 // This will also filter out images with no pixels. 80 if (best_bitmap.config() != SkBitmap::kARGB_8888_Config) 81 return false; 82 SkBitmap resized_bitmap = skia::ImageOperations::Resize( 83 best_bitmap, skia::ImageOperations::RESIZE_LANCZOS3, 84 dimension, dimension); 85 resized_image_family->Add(gfx::Image::CreateFrom1xBitmap(resized_bitmap)); 86 } 87 } 88 return true; 89} 90 91// Creates a set of bitmaps from an image family. 92// All images smaller than 256x256 are converted to SkBitmaps, and inserted into 93// |bitmaps| in order of aspect ratio (thinnest to widest), and then ascending 94// size order. If an image of exactly 256x256 is specified, it is converted into 95// PNG format and stored in |png_bytes|. Images with width or height larger than 96// 256 are ignored. 97// |bitmaps| must be an empty vector, and not NULL. 98// Returns true on success, false on failure. This fails if any image in 99// |image_family| is not a 32-bit ARGB image, or is otherwise invalid. 100bool ConvertImageFamilyToBitmaps( 101 const gfx::ImageFamily& image_family, 102 std::vector<SkBitmap>* bitmaps, 103 scoped_refptr<base::RefCountedMemory>* png_bytes) { 104 DCHECK(bitmaps != NULL); 105 DCHECK(bitmaps->empty()); 106 107 for (gfx::ImageFamily::const_iterator it = image_family.begin(); 108 it != image_family.end(); ++it) { 109 const gfx::Image& image = *it; 110 111 // All images should have one of the kIconDimensions sizes. 112 DCHECK_GT(image.Width(), 0); 113 DCHECK_LE(image.Width(), IconUtil::kLargeIconSize); 114 DCHECK_GT(image.Height(), 0); 115 DCHECK_LE(image.Height(), IconUtil::kLargeIconSize); 116 117 SkBitmap bitmap = image.AsBitmap(); 118 119 // Only 32 bit ARGB bitmaps are supported. We also make sure the bitmap has 120 // been properly initialized. 121 SkAutoLockPixels bitmap_lock(bitmap); 122 if ((bitmap.config() != SkBitmap::kARGB_8888_Config) || 123 (bitmap.getPixels() == NULL)) { 124 return false; 125 } 126 127 // Special case: Icons exactly 256x256 are stored in PNG format. 128 if (image.Width() == IconUtil::kLargeIconSize && 129 image.Height() == IconUtil::kLargeIconSize) { 130 *png_bytes = image.As1xPNGBytes(); 131 } else { 132 bitmaps->push_back(bitmap); 133 } 134 } 135 136 return true; 137} 138 139} // namespace 140 141// The icon images appear in the icon file in same order in which their 142// corresponding dimensions appear in this array, so it is important to keep 143// this array sorted. Also note that the maximum icon image size we can handle 144// is 256 by 256. See: 145// http://msdn.microsoft.com/en-us/library/windows/desktop/aa511280.aspx#size 146const int IconUtil::kIconDimensions[] = { 147 8, // Recommended by the MSDN as a nice to have icon size. 148 10, // Used by the Shell (e.g. for shortcuts). 149 14, // Recommended by the MSDN as a nice to have icon size. 150 16, // Toolbar, Application and Shell icon sizes. 151 22, // Recommended by the MSDN as a nice to have icon size. 152 24, // Used by the Shell (e.g. for shortcuts). 153 32, // Toolbar, Dialog and Wizard icon size. 154 40, // Quick Launch. 155 48, // Alt+Tab icon size. 156 64, // Recommended by the MSDN as a nice to have icon size. 157 96, // Recommended by the MSDN as a nice to have icon size. 158 128, // Used by the Shell (e.g. for shortcuts). 159 256 // Used by Vista onwards for large icons. 160}; 161 162const size_t IconUtil::kNumIconDimensions = arraysize(kIconDimensions); 163const size_t IconUtil::kNumIconDimensionsUpToMediumSize = 9; 164 165HICON IconUtil::CreateHICONFromSkBitmap(const SkBitmap& bitmap) { 166 // Only 32 bit ARGB bitmaps are supported. We also try to perform as many 167 // validations as we can on the bitmap. 168 SkAutoLockPixels bitmap_lock(bitmap); 169 if ((bitmap.config() != SkBitmap::kARGB_8888_Config) || 170 (bitmap.width() <= 0) || (bitmap.height() <= 0) || 171 (bitmap.getPixels() == NULL)) 172 return NULL; 173 174 // We start by creating a DIB which we'll use later on in order to create 175 // the HICON. We use BITMAPV5HEADER since the bitmap we are about to convert 176 // may contain an alpha channel and the V5 header allows us to specify the 177 // alpha mask for the DIB. 178 BITMAPV5HEADER bitmap_header; 179 InitializeBitmapHeader(&bitmap_header, bitmap.width(), bitmap.height()); 180 void* bits; 181 HDC hdc = ::GetDC(NULL); 182 HBITMAP dib; 183 dib = ::CreateDIBSection(hdc, reinterpret_cast<BITMAPINFO*>(&bitmap_header), 184 DIB_RGB_COLORS, &bits, NULL, 0); 185 DCHECK(dib); 186 ::ReleaseDC(NULL, hdc); 187 memcpy(bits, bitmap.getPixels(), bitmap.width() * bitmap.height() * 4); 188 189 // Icons are generally created using an AND and XOR masks where the AND 190 // specifies boolean transparency (the pixel is either opaque or 191 // transparent) and the XOR mask contains the actual image pixels. If the XOR 192 // mask bitmap has an alpha channel, the AND monochrome bitmap won't 193 // actually be used for computing the pixel transparency. Even though all our 194 // bitmap has an alpha channel, Windows might not agree when all alpha values 195 // are zero. So the monochrome bitmap is created with all pixels transparent 196 // for this case. Otherwise, it is created with all pixels opaque. 197 bool bitmap_has_alpha_channel = PixelsHaveAlpha( 198 static_cast<const uint32*>(bitmap.getPixels()), 199 bitmap.width() * bitmap.height()); 200 201 scoped_ptr<uint8[]> mask_bits; 202 if (!bitmap_has_alpha_channel) { 203 // Bytes per line with paddings to make it word alignment. 204 size_t bytes_per_line = (bitmap.width() + 0xF) / 16 * 2; 205 size_t mask_bits_size = bytes_per_line * bitmap.height(); 206 207 mask_bits.reset(new uint8[mask_bits_size]); 208 DCHECK(mask_bits.get()); 209 210 // Make all pixels transparent. 211 memset(mask_bits.get(), 0xFF, mask_bits_size); 212 } 213 214 HBITMAP mono_bitmap = ::CreateBitmap(bitmap.width(), bitmap.height(), 1, 1, 215 reinterpret_cast<LPVOID>(mask_bits.get())); 216 DCHECK(mono_bitmap); 217 218 ICONINFO icon_info; 219 icon_info.fIcon = TRUE; 220 icon_info.xHotspot = 0; 221 icon_info.yHotspot = 0; 222 icon_info.hbmMask = mono_bitmap; 223 icon_info.hbmColor = dib; 224 HICON icon = ::CreateIconIndirect(&icon_info); 225 ::DeleteObject(dib); 226 ::DeleteObject(mono_bitmap); 227 return icon; 228} 229 230SkBitmap* IconUtil::CreateSkBitmapFromHICON(HICON icon, const gfx::Size& s) { 231 // We start with validating parameters. 232 if (!icon || s.IsEmpty()) 233 return NULL; 234 ScopedICONINFO icon_info; 235 if (!::GetIconInfo(icon, &icon_info)) 236 return NULL; 237 if (!icon_info.fIcon) 238 return NULL; 239 return new SkBitmap(CreateSkBitmapFromHICONHelper(icon, s)); 240} 241 242scoped_ptr<SkBitmap> IconUtil::CreateSkBitmapFromIconResource(HMODULE module, 243 int resource_id, 244 int size) { 245 DCHECK_LE(size, kLargeIconSize); 246 247 // For everything except the Vista+ 256x256 icons, use |LoadImage()|. 248 if (size != kLargeIconSize) { 249 HICON icon_handle = 250 static_cast<HICON>(LoadImage(module, MAKEINTRESOURCE(resource_id), 251 IMAGE_ICON, size, size, 252 LR_DEFAULTCOLOR | LR_DEFAULTSIZE)); 253 scoped_ptr<SkBitmap> bitmap(IconUtil::CreateSkBitmapFromHICON(icon_handle)); 254 DestroyIcon(icon_handle); 255 return bitmap.Pass(); 256 } 257 258 // For Vista+ 256x256 PNG icons, read the resource directly and find 259 // the corresponding icon entry to get its PNG bytes. 260 void* icon_dir_data = NULL; 261 size_t icon_dir_size = 0; 262 if (!base::win::GetResourceFromModule(module, resource_id, RT_GROUP_ICON, 263 &icon_dir_data, &icon_dir_size)) { 264 return scoped_ptr<SkBitmap>(); 265 } 266 DCHECK(icon_dir_data); 267 DCHECK_GE(icon_dir_size, sizeof(GRPICONDIR)); 268 269 const GRPICONDIR* icon_dir = 270 reinterpret_cast<const GRPICONDIR*>(icon_dir_data); 271 const GRPICONDIRENTRY* large_icon_entry = NULL; 272 for (size_t i = 0; i < icon_dir->idCount; ++i) { 273 const GRPICONDIRENTRY* entry = &icon_dir->idEntries[i]; 274 // 256x256 icons are stored with width and height set to 0. 275 // See: http://en.wikipedia.org/wiki/ICO_(file_format) 276 if (entry->bWidth == 0 && entry->bHeight == 0) { 277 large_icon_entry = entry; 278 break; 279 } 280 } 281 if (!large_icon_entry) 282 return scoped_ptr<SkBitmap>(); 283 284 void* png_data = NULL; 285 size_t png_size = 0; 286 if (!base::win::GetResourceFromModule(module, large_icon_entry->nID, RT_ICON, 287 &png_data, &png_size)) { 288 return scoped_ptr<SkBitmap>(); 289 } 290 DCHECK(png_data); 291 DCHECK_EQ(png_size, large_icon_entry->dwBytesInRes); 292 293 gfx::Image image = gfx::Image::CreateFrom1xPNGBytes( 294 new base::RefCountedStaticMemory(png_data, png_size)); 295 return scoped_ptr<SkBitmap>(new SkBitmap(image.AsBitmap())); 296} 297 298SkBitmap* IconUtil::CreateSkBitmapFromHICON(HICON icon) { 299 // We start with validating parameters. 300 if (!icon) 301 return NULL; 302 303 ScopedICONINFO icon_info; 304 BITMAP bitmap_info = { 0 }; 305 306 if (!::GetIconInfo(icon, &icon_info)) 307 return NULL; 308 309 if (!::GetObject(icon_info.hbmMask, sizeof(bitmap_info), &bitmap_info)) 310 return NULL; 311 312 gfx::Size icon_size(bitmap_info.bmWidth, bitmap_info.bmHeight); 313 return new SkBitmap(CreateSkBitmapFromHICONHelper(icon, icon_size)); 314} 315 316HICON IconUtil::CreateCursorFromDIB(const gfx::Size& icon_size, 317 const gfx::Point& hotspot, 318 const void* dib_bits, 319 size_t dib_size) { 320 BITMAPINFO icon_bitmap_info = {0}; 321 gfx::CreateBitmapHeader( 322 icon_size.width(), 323 icon_size.height(), 324 reinterpret_cast<BITMAPINFOHEADER*>(&icon_bitmap_info)); 325 326 base::win::ScopedGetDC dc(NULL); 327 base::win::ScopedCreateDC working_dc(CreateCompatibleDC(dc)); 328 base::win::ScopedGDIObject<HBITMAP> bitmap_handle( 329 CreateDIBSection(dc, 330 &icon_bitmap_info, 331 DIB_RGB_COLORS, 332 0, 333 0, 334 0)); 335 if (dib_size > 0) { 336 SetDIBits(0, 337 bitmap_handle, 338 0, 339 icon_size.height(), 340 dib_bits, 341 &icon_bitmap_info, 342 DIB_RGB_COLORS); 343 } 344 345 HBITMAP old_bitmap = reinterpret_cast<HBITMAP>( 346 SelectObject(working_dc, bitmap_handle)); 347 SetBkMode(working_dc, TRANSPARENT); 348 SelectObject(working_dc, old_bitmap); 349 350 base::win::ScopedGDIObject<HBITMAP> mask( 351 CreateBitmap(icon_size.width(), 352 icon_size.height(), 353 1, 354 1, 355 NULL)); 356 ICONINFO ii = {0}; 357 ii.fIcon = FALSE; 358 ii.xHotspot = hotspot.x(); 359 ii.yHotspot = hotspot.y(); 360 ii.hbmMask = mask; 361 ii.hbmColor = bitmap_handle; 362 363 return CreateIconIndirect(&ii); 364} 365 366SkBitmap IconUtil::CreateSkBitmapFromHICONHelper(HICON icon, 367 const gfx::Size& s) { 368 DCHECK(icon); 369 DCHECK(!s.IsEmpty()); 370 371 // Allocating memory for the SkBitmap object. We are going to create an ARGB 372 // bitmap so we should set the configuration appropriately. 373 SkBitmap bitmap; 374 bitmap.setConfig(SkBitmap::kARGB_8888_Config, s.width(), s.height()); 375 bitmap.allocPixels(); 376 bitmap.eraseARGB(0, 0, 0, 0); 377 SkAutoLockPixels bitmap_lock(bitmap); 378 379 // Now we should create a DIB so that we can use ::DrawIconEx in order to 380 // obtain the icon's image. 381 BITMAPV5HEADER h; 382 InitializeBitmapHeader(&h, s.width(), s.height()); 383 HDC hdc = ::GetDC(NULL); 384 uint32* bits; 385 HBITMAP dib = ::CreateDIBSection(hdc, reinterpret_cast<BITMAPINFO*>(&h), 386 DIB_RGB_COLORS, reinterpret_cast<void**>(&bits), NULL, 0); 387 DCHECK(dib); 388 HDC dib_dc = CreateCompatibleDC(hdc); 389 ::ReleaseDC(NULL, hdc); 390 DCHECK(dib_dc); 391 HGDIOBJ old_obj = ::SelectObject(dib_dc, dib); 392 393 // Windows icons are defined using two different masks. The XOR mask, which 394 // represents the icon image and an AND mask which is a monochrome bitmap 395 // which indicates the transparency of each pixel. 396 // 397 // To make things more complex, the icon image itself can be an ARGB bitmap 398 // and therefore contain an alpha channel which specifies the transparency 399 // for each pixel. Unfortunately, there is no easy way to determine whether 400 // or not a bitmap has an alpha channel and therefore constructing the bitmap 401 // for the icon is nothing but straightforward. 402 // 403 // The idea is to read the AND mask but use it only if we know for sure that 404 // the icon image does not have an alpha channel. The only way to tell if the 405 // bitmap has an alpha channel is by looking through the pixels and checking 406 // whether there are non-zero alpha bytes. 407 // 408 // We start by drawing the AND mask into our DIB. 409 size_t num_pixels = s.GetArea(); 410 memset(bits, 0, num_pixels * 4); 411 ::DrawIconEx(dib_dc, 0, 0, icon, s.width(), s.height(), 0, NULL, DI_MASK); 412 413 // Capture boolean opacity. We may not use it if we find out the bitmap has 414 // an alpha channel. 415 scoped_ptr<bool[]> opaque(new bool[num_pixels]); 416 for (size_t i = 0; i < num_pixels; ++i) 417 opaque[i] = !bits[i]; 418 419 // Then draw the image itself which is really the XOR mask. 420 memset(bits, 0, num_pixels * 4); 421 ::DrawIconEx(dib_dc, 0, 0, icon, s.width(), s.height(), 0, NULL, DI_NORMAL); 422 memcpy(bitmap.getPixels(), static_cast<void*>(bits), num_pixels * 4); 423 424 // Finding out whether the bitmap has an alpha channel. 425 bool bitmap_has_alpha_channel = PixelsHaveAlpha( 426 static_cast<const uint32*>(bitmap.getPixels()), num_pixels); 427 428 // If the bitmap does not have an alpha channel, we need to build it using 429 // the previously captured AND mask. Otherwise, we are done. 430 if (!bitmap_has_alpha_channel) { 431 uint32* p = static_cast<uint32*>(bitmap.getPixels()); 432 for (size_t i = 0; i < num_pixels; ++p, ++i) { 433 DCHECK_EQ((*p & 0xff000000), 0u); 434 if (opaque[i]) 435 *p |= 0xff000000; 436 else 437 *p &= 0x00ffffff; 438 } 439 } 440 441 ::SelectObject(dib_dc, old_obj); 442 ::DeleteObject(dib); 443 ::DeleteDC(dib_dc); 444 445 return bitmap; 446} 447 448// static 449bool IconUtil::CreateIconFileFromImageFamily( 450 const gfx::ImageFamily& image_family, 451 const base::FilePath& icon_path) { 452 // Creating a set of bitmaps corresponding to the icon images we'll end up 453 // storing in the icon file. Each bitmap is created by resizing the most 454 // appropriate image from |image_family| to the desired size. 455 gfx::ImageFamily resized_image_family; 456 if (!BuildResizedImageFamily(image_family, &resized_image_family)) 457 return false; 458 459 std::vector<SkBitmap> bitmaps; 460 scoped_refptr<base::RefCountedMemory> png_bytes; 461 if (!ConvertImageFamilyToBitmaps(resized_image_family, &bitmaps, &png_bytes)) 462 return false; 463 464 // Guaranteed true because BuildResizedImageFamily will provide at least one 465 // image < 256x256. 466 DCHECK(!bitmaps.empty()); 467 size_t bitmap_count = bitmaps.size(); // Not including PNG image. 468 // Including PNG image, if any. 469 size_t image_count = bitmap_count + (png_bytes.get() ? 1 : 0); 470 471 // Computing the total size of the buffer we need in order to store the 472 // images in the desired icon format. 473 size_t buffer_size = ComputeIconFileBufferSize(bitmaps); 474 // Account for the bytes needed for the PNG entry. 475 if (png_bytes.get()) 476 buffer_size += sizeof(ICONDIRENTRY) + png_bytes->size(); 477 478 // Setting the information in the structures residing within the buffer. 479 // First, we set the information which doesn't require iterating through the 480 // bitmap set and then we set the bitmap specific structures. In the latter 481 // step we also copy the actual bits. 482 std::vector<uint8> buffer(buffer_size); 483 ICONDIR* icon_dir = reinterpret_cast<ICONDIR*>(&buffer[0]); 484 icon_dir->idType = kResourceTypeIcon; 485 icon_dir->idCount = static_cast<WORD>(image_count); 486 // - 1 because there is already one ICONDIRENTRY in ICONDIR. 487 size_t icon_dir_count = image_count - 1; 488 489 size_t offset = sizeof(ICONDIR) + (sizeof(ICONDIRENTRY) * icon_dir_count); 490 for (size_t i = 0; i < bitmap_count; i++) { 491 ICONIMAGE* image = reinterpret_cast<ICONIMAGE*>(&buffer[offset]); 492 DCHECK_LT(offset, buffer_size); 493 size_t icon_image_size = 0; 494 SetSingleIconImageInformation(bitmaps[i], i, icon_dir, image, offset, 495 &icon_image_size); 496 DCHECK_GT(icon_image_size, 0U); 497 offset += icon_image_size; 498 } 499 500 // Add the PNG entry, if necessary. 501 if (png_bytes.get()) { 502 ICONDIRENTRY* entry = &icon_dir->idEntries[bitmap_count]; 503 entry->bWidth = 0; 504 entry->bHeight = 0; 505 entry->wPlanes = 1; 506 entry->wBitCount = 32; 507 entry->dwBytesInRes = static_cast<DWORD>(png_bytes->size()); 508 entry->dwImageOffset = static_cast<DWORD>(offset); 509 memcpy(&buffer[offset], png_bytes->front(), png_bytes->size()); 510 offset += png_bytes->size(); 511 } 512 513 DCHECK_EQ(offset, buffer_size); 514 515 std::string data(buffer.begin(), buffer.end()); 516 return base::ImportantFileWriter::WriteFileAtomically(icon_path, data); 517} 518 519bool IconUtil::PixelsHaveAlpha(const uint32* pixels, size_t num_pixels) { 520 for (const uint32* end = pixels + num_pixels; pixels != end; ++pixels) { 521 if ((*pixels & 0xff000000) != 0) 522 return true; 523 } 524 525 return false; 526} 527 528void IconUtil::InitializeBitmapHeader(BITMAPV5HEADER* header, int width, 529 int height) { 530 DCHECK(header); 531 memset(header, 0, sizeof(BITMAPV5HEADER)); 532 header->bV5Size = sizeof(BITMAPV5HEADER); 533 534 // Note that icons are created using top-down DIBs so we must negate the 535 // value used for the icon's height. 536 header->bV5Width = width; 537 header->bV5Height = -height; 538 header->bV5Planes = 1; 539 header->bV5Compression = BI_RGB; 540 541 // Initializing the bitmap format to 32 bit ARGB. 542 header->bV5BitCount = 32; 543 header->bV5RedMask = 0x00FF0000; 544 header->bV5GreenMask = 0x0000FF00; 545 header->bV5BlueMask = 0x000000FF; 546 header->bV5AlphaMask = 0xFF000000; 547 548 // Use the system color space. The default value is LCS_CALIBRATED_RGB, which 549 // causes us to crash if we don't specify the approprite gammas, etc. See 550 // <http://msdn.microsoft.com/en-us/library/ms536531(VS.85).aspx> and 551 // <http://b/1283121>. 552 header->bV5CSType = LCS_WINDOWS_COLOR_SPACE; 553 554 // Use a valid value for bV5Intent as 0 is not a valid one. 555 // <http://msdn.microsoft.com/en-us/library/dd183381(VS.85).aspx> 556 header->bV5Intent = LCS_GM_IMAGES; 557} 558 559void IconUtil::SetSingleIconImageInformation(const SkBitmap& bitmap, 560 size_t index, 561 ICONDIR* icon_dir, 562 ICONIMAGE* icon_image, 563 size_t image_offset, 564 size_t* image_byte_count) { 565 DCHECK(icon_dir != NULL); 566 DCHECK(icon_image != NULL); 567 DCHECK_GT(image_offset, 0U); 568 DCHECK(image_byte_count != NULL); 569 DCHECK_LT(bitmap.width(), kLargeIconSize); 570 DCHECK_LT(bitmap.height(), kLargeIconSize); 571 572 // We start by computing certain image values we'll use later on. 573 size_t xor_mask_size, bytes_in_resource; 574 ComputeBitmapSizeComponents(bitmap, 575 &xor_mask_size, 576 &bytes_in_resource); 577 578 icon_dir->idEntries[index].bWidth = static_cast<BYTE>(bitmap.width()); 579 icon_dir->idEntries[index].bHeight = static_cast<BYTE>(bitmap.height()); 580 icon_dir->idEntries[index].wPlanes = 1; 581 icon_dir->idEntries[index].wBitCount = 32; 582 icon_dir->idEntries[index].dwBytesInRes = bytes_in_resource; 583 icon_dir->idEntries[index].dwImageOffset = image_offset; 584 icon_image->icHeader.biSize = sizeof(BITMAPINFOHEADER); 585 586 // The width field in the BITMAPINFOHEADER structure accounts for the height 587 // of both the AND mask and the XOR mask so we need to multiply the bitmap's 588 // height by 2. The same does NOT apply to the width field. 589 icon_image->icHeader.biHeight = bitmap.height() * 2; 590 icon_image->icHeader.biWidth = bitmap.width(); 591 icon_image->icHeader.biPlanes = 1; 592 icon_image->icHeader.biBitCount = 32; 593 594 // We use a helper function for copying to actual bits from the SkBitmap 595 // object into the appropriate space in the buffer. We use a helper function 596 // (rather than just copying the bits) because there is no way to specify the 597 // orientation (bottom-up vs. top-down) of a bitmap residing in a .ico file. 598 // Thus, if we just copy the bits, we'll end up with a bottom up bitmap in 599 // the .ico file which will result in the icon being displayed upside down. 600 // The helper function copies the image into the buffer one scanline at a 601 // time. 602 // 603 // Note that we don't need to initialize the AND mask since the memory 604 // allocated for the icon data buffer was initialized to zero. The icon we 605 // create will therefore use an AND mask containing only zeros, which is OK 606 // because the underlying image has an alpha channel. An AND mask containing 607 // only zeros essentially means we'll initially treat all the pixels as 608 // opaque. 609 unsigned char* image_addr = reinterpret_cast<unsigned char*>(icon_image); 610 unsigned char* xor_mask_addr = image_addr + sizeof(BITMAPINFOHEADER); 611 CopySkBitmapBitsIntoIconBuffer(bitmap, xor_mask_addr, xor_mask_size); 612 *image_byte_count = bytes_in_resource; 613} 614 615void IconUtil::CopySkBitmapBitsIntoIconBuffer(const SkBitmap& bitmap, 616 unsigned char* buffer, 617 size_t buffer_size) { 618 SkAutoLockPixels bitmap_lock(bitmap); 619 unsigned char* bitmap_ptr = static_cast<unsigned char*>(bitmap.getPixels()); 620 size_t bitmap_size = bitmap.height() * bitmap.width() * 4; 621 DCHECK_EQ(buffer_size, bitmap_size); 622 for (size_t i = 0; i < bitmap_size; i += bitmap.width() * 4) { 623 memcpy(buffer + bitmap_size - bitmap.width() * 4 - i, 624 bitmap_ptr + i, 625 bitmap.width() * 4); 626 } 627} 628 629size_t IconUtil::ComputeIconFileBufferSize(const std::vector<SkBitmap>& set) { 630 DCHECK(!set.empty()); 631 632 // We start by counting the bytes for the structures that don't depend on the 633 // number of icon images. Note that sizeof(ICONDIR) already accounts for a 634 // single ICONDIRENTRY structure, which is why we subtract one from the 635 // number of bitmaps. 636 size_t total_buffer_size = sizeof(ICONDIR); 637 size_t bitmap_count = set.size(); 638 total_buffer_size += sizeof(ICONDIRENTRY) * (bitmap_count - 1); 639 // May not have all icon sizes, but must have at least up to medium icon size. 640 DCHECK_GE(bitmap_count, kNumIconDimensionsUpToMediumSize); 641 642 // Add the bitmap specific structure sizes. 643 for (size_t i = 0; i < bitmap_count; i++) { 644 size_t xor_mask_size, bytes_in_resource; 645 ComputeBitmapSizeComponents(set[i], 646 &xor_mask_size, 647 &bytes_in_resource); 648 total_buffer_size += bytes_in_resource; 649 } 650 return total_buffer_size; 651} 652 653void IconUtil::ComputeBitmapSizeComponents(const SkBitmap& bitmap, 654 size_t* xor_mask_size, 655 size_t* bytes_in_resource) { 656 // The XOR mask size is easy to calculate since we only deal with 32bpp 657 // images. 658 *xor_mask_size = bitmap.width() * bitmap.height() * 4; 659 660 // Computing the AND mask is a little trickier since it is a monochrome 661 // bitmap (regardless of the number of bits per pixels used in the XOR mask). 662 // There are two things we must make sure we do when computing the AND mask 663 // size: 664 // 665 // 1. Make sure the right number of bytes is allocated for each AND mask 666 // scan line in case the number of pixels in the image is not divisible by 667 // 8. For example, in a 15X15 image, 15 / 8 is one byte short of 668 // containing the number of bits we need in order to describe a single 669 // image scan line so we need to add a byte. Thus, we need 2 bytes instead 670 // of 1 for each scan line. 671 // 672 // 2. Make sure each scan line in the AND mask is 4 byte aligned (so that the 673 // total icon image has a 4 byte alignment). In the 15X15 image example 674 // above, we can not use 2 bytes so we increase it to the next multiple of 675 // 4 which is 4. 676 // 677 // Once we compute the size for a singe AND mask scan line, we multiply that 678 // number by the image height in order to get the total number of bytes for 679 // the AND mask. Thus, for a 15X15 image, we need 15 * 4 which is 60 bytes 680 // for the monochrome bitmap representing the AND mask. 681 size_t and_line_length = (bitmap.width() + 7) >> 3; 682 and_line_length = (and_line_length + 3) & ~3; 683 size_t and_mask_size = and_line_length * bitmap.height(); 684 size_t masks_size = *xor_mask_size + and_mask_size; 685 *bytes_in_resource = masks_size + sizeof(BITMAPINFOHEADER); 686} 687