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/files/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.colorType() != kN32_SkColorType)
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.colorType() != kN32_SkColorType) ||
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.colorType() != kN32_SkColorType) ||
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
181  void* bits = NULL;
182  HBITMAP dib;
183
184  {
185    base::win::ScopedGetDC hdc(NULL);
186    dib = ::CreateDIBSection(hdc, reinterpret_cast<BITMAPINFO*>(&bitmap_header),
187                             DIB_RGB_COLORS, &bits, NULL, 0);
188  }
189  if (!dib || !bits)
190    return NULL;
191
192  memcpy(bits, bitmap.getPixels(), bitmap.width() * bitmap.height() * 4);
193
194  // Icons are generally created using an AND and XOR masks where the AND
195  // specifies boolean transparency (the pixel is either opaque or
196  // transparent) and the XOR mask contains the actual image pixels. If the XOR
197  // mask bitmap has an alpha channel, the AND monochrome bitmap won't
198  // actually be used for computing the pixel transparency. Even though all our
199  // bitmap has an alpha channel, Windows might not agree when all alpha values
200  // are zero. So the monochrome bitmap is created with all pixels transparent
201  // for this case. Otherwise, it is created with all pixels opaque.
202  bool bitmap_has_alpha_channel = PixelsHaveAlpha(
203      static_cast<const uint32*>(bitmap.getPixels()),
204      bitmap.width() * bitmap.height());
205
206  scoped_ptr<uint8[]> mask_bits;
207  if (!bitmap_has_alpha_channel) {
208    // Bytes per line with paddings to make it word alignment.
209    size_t bytes_per_line = (bitmap.width() + 0xF) / 16 * 2;
210    size_t mask_bits_size = bytes_per_line * bitmap.height();
211
212    mask_bits.reset(new uint8[mask_bits_size]);
213    DCHECK(mask_bits.get());
214
215    // Make all pixels transparent.
216    memset(mask_bits.get(), 0xFF, mask_bits_size);
217  }
218
219  HBITMAP mono_bitmap = ::CreateBitmap(bitmap.width(), bitmap.height(), 1, 1,
220      reinterpret_cast<LPVOID>(mask_bits.get()));
221  DCHECK(mono_bitmap);
222
223  ICONINFO icon_info;
224  icon_info.fIcon = TRUE;
225  icon_info.xHotspot = 0;
226  icon_info.yHotspot = 0;
227  icon_info.hbmMask = mono_bitmap;
228  icon_info.hbmColor = dib;
229  HICON icon = ::CreateIconIndirect(&icon_info);
230  ::DeleteObject(dib);
231  ::DeleteObject(mono_bitmap);
232  return icon;
233}
234
235SkBitmap* IconUtil::CreateSkBitmapFromHICON(HICON icon, const gfx::Size& s) {
236  // We start with validating parameters.
237  if (!icon || s.IsEmpty())
238    return NULL;
239  ScopedICONINFO icon_info;
240  if (!::GetIconInfo(icon, &icon_info))
241    return NULL;
242  if (!icon_info.fIcon)
243    return NULL;
244  return new SkBitmap(CreateSkBitmapFromHICONHelper(icon, s));
245}
246
247scoped_ptr<SkBitmap> IconUtil::CreateSkBitmapFromIconResource(HMODULE module,
248                                                              int resource_id,
249                                                              int size) {
250  DCHECK_LE(size, kLargeIconSize);
251
252  // For everything except the Vista+ 256x256 icons, use |LoadImage()|.
253  if (size != kLargeIconSize) {
254    HICON icon_handle =
255        static_cast<HICON>(LoadImage(module, MAKEINTRESOURCE(resource_id),
256                                     IMAGE_ICON, size, size,
257                                     LR_DEFAULTCOLOR | LR_DEFAULTSIZE));
258    scoped_ptr<SkBitmap> bitmap(IconUtil::CreateSkBitmapFromHICON(icon_handle));
259    DestroyIcon(icon_handle);
260    return bitmap.Pass();
261  }
262
263  // For Vista+ 256x256 PNG icons, read the resource directly and find
264  // the corresponding icon entry to get its PNG bytes.
265  void* icon_dir_data = NULL;
266  size_t icon_dir_size = 0;
267  if (!base::win::GetResourceFromModule(module, resource_id, RT_GROUP_ICON,
268                                        &icon_dir_data, &icon_dir_size)) {
269    return scoped_ptr<SkBitmap>();
270  }
271  DCHECK(icon_dir_data);
272  DCHECK_GE(icon_dir_size, sizeof(GRPICONDIR));
273
274  const GRPICONDIR* icon_dir =
275      reinterpret_cast<const GRPICONDIR*>(icon_dir_data);
276  const GRPICONDIRENTRY* large_icon_entry = NULL;
277  for (size_t i = 0; i < icon_dir->idCount; ++i) {
278    const GRPICONDIRENTRY* entry = &icon_dir->idEntries[i];
279    // 256x256 icons are stored with width and height set to 0.
280    // See: http://en.wikipedia.org/wiki/ICO_(file_format)
281    if (entry->bWidth == 0 && entry->bHeight == 0) {
282      large_icon_entry = entry;
283      break;
284    }
285  }
286  if (!large_icon_entry)
287    return scoped_ptr<SkBitmap>();
288
289  void* png_data = NULL;
290  size_t png_size = 0;
291  if (!base::win::GetResourceFromModule(module, large_icon_entry->nID, RT_ICON,
292                                        &png_data, &png_size)) {
293    return scoped_ptr<SkBitmap>();
294  }
295  DCHECK(png_data);
296  DCHECK_EQ(png_size, large_icon_entry->dwBytesInRes);
297
298  gfx::Image image = gfx::Image::CreateFrom1xPNGBytes(
299      new base::RefCountedStaticMemory(png_data, png_size));
300  return scoped_ptr<SkBitmap>(new SkBitmap(image.AsBitmap()));
301}
302
303SkBitmap* IconUtil::CreateSkBitmapFromHICON(HICON icon) {
304  // We start with validating parameters.
305  if (!icon)
306    return NULL;
307
308  ScopedICONINFO icon_info;
309  BITMAP bitmap_info = { 0 };
310
311  if (!::GetIconInfo(icon, &icon_info))
312    return NULL;
313
314  if (!::GetObject(icon_info.hbmMask, sizeof(bitmap_info), &bitmap_info))
315    return NULL;
316
317  gfx::Size icon_size(bitmap_info.bmWidth, bitmap_info.bmHeight);
318  return new SkBitmap(CreateSkBitmapFromHICONHelper(icon, icon_size));
319}
320
321HICON IconUtil::CreateCursorFromDIB(const gfx::Size& icon_size,
322                                    const gfx::Point& hotspot,
323                                    const void* dib_bits,
324                                    size_t dib_size) {
325  BITMAPINFO icon_bitmap_info = {0};
326  gfx::CreateBitmapHeader(
327      icon_size.width(),
328      icon_size.height(),
329      reinterpret_cast<BITMAPINFOHEADER*>(&icon_bitmap_info));
330
331  base::win::ScopedGetDC dc(NULL);
332  base::win::ScopedCreateDC working_dc(CreateCompatibleDC(dc));
333  base::win::ScopedGDIObject<HBITMAP> bitmap_handle(
334      CreateDIBSection(dc,
335                       &icon_bitmap_info,
336                       DIB_RGB_COLORS,
337                       0,
338                       0,
339                       0));
340  if (dib_size > 0) {
341    SetDIBits(0,
342              bitmap_handle,
343              0,
344              icon_size.height(),
345              dib_bits,
346              &icon_bitmap_info,
347              DIB_RGB_COLORS);
348  }
349
350  HBITMAP old_bitmap = reinterpret_cast<HBITMAP>(
351      SelectObject(working_dc.Get(), bitmap_handle));
352  SetBkMode(working_dc.Get(), TRANSPARENT);
353  SelectObject(working_dc.Get(), old_bitmap);
354
355  base::win::ScopedGDIObject<HBITMAP> mask(
356      CreateBitmap(icon_size.width(),
357                   icon_size.height(),
358                   1,
359                   1,
360                   NULL));
361  ICONINFO ii = {0};
362  ii.fIcon = FALSE;
363  ii.xHotspot = hotspot.x();
364  ii.yHotspot = hotspot.y();
365  ii.hbmMask = mask;
366  ii.hbmColor = bitmap_handle;
367
368  return CreateIconIndirect(&ii);
369}
370
371SkBitmap IconUtil::CreateSkBitmapFromHICONHelper(HICON icon,
372                                                 const gfx::Size& s) {
373  DCHECK(icon);
374  DCHECK(!s.IsEmpty());
375
376  // Allocating memory for the SkBitmap object. We are going to create an ARGB
377  // bitmap so we should set the configuration appropriately.
378  SkBitmap bitmap;
379  bitmap.allocN32Pixels(s.width(), s.height());
380  bitmap.eraseARGB(0, 0, 0, 0);
381  SkAutoLockPixels bitmap_lock(bitmap);
382
383  // Now we should create a DIB so that we can use ::DrawIconEx in order to
384  // obtain the icon's image.
385  BITMAPV5HEADER h;
386  InitializeBitmapHeader(&h, s.width(), s.height());
387  HDC hdc = ::GetDC(NULL);
388  uint32* bits;
389  HBITMAP dib = ::CreateDIBSection(hdc, reinterpret_cast<BITMAPINFO*>(&h),
390      DIB_RGB_COLORS, reinterpret_cast<void**>(&bits), NULL, 0);
391  DCHECK(dib);
392  HDC dib_dc = CreateCompatibleDC(hdc);
393  ::ReleaseDC(NULL, hdc);
394  DCHECK(dib_dc);
395  HGDIOBJ old_obj = ::SelectObject(dib_dc, dib);
396
397  // Windows icons are defined using two different masks. The XOR mask, which
398  // represents the icon image and an AND mask which is a monochrome bitmap
399  // which indicates the transparency of each pixel.
400  //
401  // To make things more complex, the icon image itself can be an ARGB bitmap
402  // and therefore contain an alpha channel which specifies the transparency
403  // for each pixel. Unfortunately, there is no easy way to determine whether
404  // or not a bitmap has an alpha channel and therefore constructing the bitmap
405  // for the icon is nothing but straightforward.
406  //
407  // The idea is to read the AND mask but use it only if we know for sure that
408  // the icon image does not have an alpha channel. The only way to tell if the
409  // bitmap has an alpha channel is by looking through the pixels and checking
410  // whether there are non-zero alpha bytes.
411  //
412  // We start by drawing the AND mask into our DIB.
413  size_t num_pixels = s.GetArea();
414  memset(bits, 0, num_pixels * 4);
415  ::DrawIconEx(dib_dc, 0, 0, icon, s.width(), s.height(), 0, NULL, DI_MASK);
416
417  // Capture boolean opacity. We may not use it if we find out the bitmap has
418  // an alpha channel.
419  scoped_ptr<bool[]> opaque(new bool[num_pixels]);
420  for (size_t i = 0; i < num_pixels; ++i)
421    opaque[i] = !bits[i];
422
423  // Then draw the image itself which is really the XOR mask.
424  memset(bits, 0, num_pixels * 4);
425  ::DrawIconEx(dib_dc, 0, 0, icon, s.width(), s.height(), 0, NULL, DI_NORMAL);
426  memcpy(bitmap.getPixels(), static_cast<void*>(bits), num_pixels * 4);
427
428  // Finding out whether the bitmap has an alpha channel.
429  bool bitmap_has_alpha_channel = PixelsHaveAlpha(
430      static_cast<const uint32*>(bitmap.getPixels()), num_pixels);
431
432  // If the bitmap does not have an alpha channel, we need to build it using
433  // the previously captured AND mask. Otherwise, we are done.
434  if (!bitmap_has_alpha_channel) {
435    uint32* p = static_cast<uint32*>(bitmap.getPixels());
436    for (size_t i = 0; i < num_pixels; ++p, ++i) {
437      DCHECK_EQ((*p & 0xff000000), 0u);
438      if (opaque[i])
439        *p |= 0xff000000;
440      else
441        *p &= 0x00ffffff;
442    }
443  }
444
445  ::SelectObject(dib_dc, old_obj);
446  ::DeleteObject(dib);
447  ::DeleteDC(dib_dc);
448
449  return bitmap;
450}
451
452// static
453bool IconUtil::CreateIconFileFromImageFamily(
454    const gfx::ImageFamily& image_family,
455    const base::FilePath& icon_path) {
456  // Creating a set of bitmaps corresponding to the icon images we'll end up
457  // storing in the icon file. Each bitmap is created by resizing the most
458  // appropriate image from |image_family| to the desired size.
459  gfx::ImageFamily resized_image_family;
460  if (!BuildResizedImageFamily(image_family, &resized_image_family))
461    return false;
462
463  std::vector<SkBitmap> bitmaps;
464  scoped_refptr<base::RefCountedMemory> png_bytes;
465  if (!ConvertImageFamilyToBitmaps(resized_image_family, &bitmaps, &png_bytes))
466    return false;
467
468  // Guaranteed true because BuildResizedImageFamily will provide at least one
469  // image < 256x256.
470  DCHECK(!bitmaps.empty());
471  size_t bitmap_count = bitmaps.size();  // Not including PNG image.
472  // Including PNG image, if any.
473  size_t image_count = bitmap_count + (png_bytes.get() ? 1 : 0);
474
475  // Computing the total size of the buffer we need in order to store the
476  // images in the desired icon format.
477  size_t buffer_size = ComputeIconFileBufferSize(bitmaps);
478  // Account for the bytes needed for the PNG entry.
479  if (png_bytes.get())
480    buffer_size += sizeof(ICONDIRENTRY) + png_bytes->size();
481
482  // Setting the information in the structures residing within the buffer.
483  // First, we set the information which doesn't require iterating through the
484  // bitmap set and then we set the bitmap specific structures. In the latter
485  // step we also copy the actual bits.
486  std::vector<uint8> buffer(buffer_size);
487  ICONDIR* icon_dir = reinterpret_cast<ICONDIR*>(&buffer[0]);
488  icon_dir->idType = kResourceTypeIcon;
489  icon_dir->idCount = static_cast<WORD>(image_count);
490  // - 1 because there is already one ICONDIRENTRY in ICONDIR.
491  size_t icon_dir_count = image_count - 1;
492
493  size_t offset = sizeof(ICONDIR) + (sizeof(ICONDIRENTRY) * icon_dir_count);
494  for (size_t i = 0; i < bitmap_count; i++) {
495    ICONIMAGE* image = reinterpret_cast<ICONIMAGE*>(&buffer[offset]);
496    DCHECK_LT(offset, buffer_size);
497    size_t icon_image_size = 0;
498    SetSingleIconImageInformation(bitmaps[i], i, icon_dir, image, offset,
499                                  &icon_image_size);
500    DCHECK_GT(icon_image_size, 0U);
501    offset += icon_image_size;
502  }
503
504  // Add the PNG entry, if necessary.
505  if (png_bytes.get()) {
506    ICONDIRENTRY* entry = &icon_dir->idEntries[bitmap_count];
507    entry->bWidth = 0;
508    entry->bHeight = 0;
509    entry->wPlanes = 1;
510    entry->wBitCount = 32;
511    entry->dwBytesInRes = static_cast<DWORD>(png_bytes->size());
512    entry->dwImageOffset = static_cast<DWORD>(offset);
513    memcpy(&buffer[offset], png_bytes->front(), png_bytes->size());
514    offset += png_bytes->size();
515  }
516
517  DCHECK_EQ(offset, buffer_size);
518
519  std::string data(buffer.begin(), buffer.end());
520  return base::ImportantFileWriter::WriteFileAtomically(icon_path, data);
521}
522
523bool IconUtil::PixelsHaveAlpha(const uint32* pixels, size_t num_pixels) {
524  for (const uint32* end = pixels + num_pixels; pixels != end; ++pixels) {
525    if ((*pixels & 0xff000000) != 0)
526      return true;
527  }
528
529  return false;
530}
531
532void IconUtil::InitializeBitmapHeader(BITMAPV5HEADER* header, int width,
533                                      int height) {
534  DCHECK(header);
535  memset(header, 0, sizeof(BITMAPV5HEADER));
536  header->bV5Size = sizeof(BITMAPV5HEADER);
537
538  // Note that icons are created using top-down DIBs so we must negate the
539  // value used for the icon's height.
540  header->bV5Width = width;
541  header->bV5Height = -height;
542  header->bV5Planes = 1;
543  header->bV5Compression = BI_RGB;
544
545  // Initializing the bitmap format to 32 bit ARGB.
546  header->bV5BitCount = 32;
547  header->bV5RedMask = 0x00FF0000;
548  header->bV5GreenMask = 0x0000FF00;
549  header->bV5BlueMask = 0x000000FF;
550  header->bV5AlphaMask = 0xFF000000;
551
552  // Use the system color space.  The default value is LCS_CALIBRATED_RGB, which
553  // causes us to crash if we don't specify the approprite gammas, etc.  See
554  // <http://msdn.microsoft.com/en-us/library/ms536531(VS.85).aspx> and
555  // <http://b/1283121>.
556  header->bV5CSType = LCS_WINDOWS_COLOR_SPACE;
557
558  // Use a valid value for bV5Intent as 0 is not a valid one.
559  // <http://msdn.microsoft.com/en-us/library/dd183381(VS.85).aspx>
560  header->bV5Intent = LCS_GM_IMAGES;
561}
562
563void IconUtil::SetSingleIconImageInformation(const SkBitmap& bitmap,
564                                             size_t index,
565                                             ICONDIR* icon_dir,
566                                             ICONIMAGE* icon_image,
567                                             size_t image_offset,
568                                             size_t* image_byte_count) {
569  DCHECK(icon_dir != NULL);
570  DCHECK(icon_image != NULL);
571  DCHECK_GT(image_offset, 0U);
572  DCHECK(image_byte_count != NULL);
573  DCHECK_LT(bitmap.width(), kLargeIconSize);
574  DCHECK_LT(bitmap.height(), kLargeIconSize);
575
576  // We start by computing certain image values we'll use later on.
577  size_t xor_mask_size, bytes_in_resource;
578  ComputeBitmapSizeComponents(bitmap,
579                              &xor_mask_size,
580                              &bytes_in_resource);
581
582  icon_dir->idEntries[index].bWidth = static_cast<BYTE>(bitmap.width());
583  icon_dir->idEntries[index].bHeight = static_cast<BYTE>(bitmap.height());
584  icon_dir->idEntries[index].wPlanes = 1;
585  icon_dir->idEntries[index].wBitCount = 32;
586  icon_dir->idEntries[index].dwBytesInRes = bytes_in_resource;
587  icon_dir->idEntries[index].dwImageOffset = image_offset;
588  icon_image->icHeader.biSize = sizeof(BITMAPINFOHEADER);
589
590  // The width field in the BITMAPINFOHEADER structure accounts for the height
591  // of both the AND mask and the XOR mask so we need to multiply the bitmap's
592  // height by 2. The same does NOT apply to the width field.
593  icon_image->icHeader.biHeight = bitmap.height() * 2;
594  icon_image->icHeader.biWidth = bitmap.width();
595  icon_image->icHeader.biPlanes = 1;
596  icon_image->icHeader.biBitCount = 32;
597
598  // We use a helper function for copying to actual bits from the SkBitmap
599  // object into the appropriate space in the buffer. We use a helper function
600  // (rather than just copying the bits) because there is no way to specify the
601  // orientation (bottom-up vs. top-down) of a bitmap residing in a .ico file.
602  // Thus, if we just copy the bits, we'll end up with a bottom up bitmap in
603  // the .ico file which will result in the icon being displayed upside down.
604  // The helper function copies the image into the buffer one scanline at a
605  // time.
606  //
607  // Note that we don't need to initialize the AND mask since the memory
608  // allocated for the icon data buffer was initialized to zero. The icon we
609  // create will therefore use an AND mask containing only zeros, which is OK
610  // because the underlying image has an alpha channel. An AND mask containing
611  // only zeros essentially means we'll initially treat all the pixels as
612  // opaque.
613  unsigned char* image_addr = reinterpret_cast<unsigned char*>(icon_image);
614  unsigned char* xor_mask_addr = image_addr + sizeof(BITMAPINFOHEADER);
615  CopySkBitmapBitsIntoIconBuffer(bitmap, xor_mask_addr, xor_mask_size);
616  *image_byte_count = bytes_in_resource;
617}
618
619void IconUtil::CopySkBitmapBitsIntoIconBuffer(const SkBitmap& bitmap,
620                                              unsigned char* buffer,
621                                              size_t buffer_size) {
622  SkAutoLockPixels bitmap_lock(bitmap);
623  unsigned char* bitmap_ptr = static_cast<unsigned char*>(bitmap.getPixels());
624  size_t bitmap_size = bitmap.height() * bitmap.width() * 4;
625  DCHECK_EQ(buffer_size, bitmap_size);
626  for (size_t i = 0; i < bitmap_size; i += bitmap.width() * 4) {
627    memcpy(buffer + bitmap_size - bitmap.width() * 4 - i,
628           bitmap_ptr + i,
629           bitmap.width() * 4);
630  }
631}
632
633size_t IconUtil::ComputeIconFileBufferSize(const std::vector<SkBitmap>& set) {
634  DCHECK(!set.empty());
635
636  // We start by counting the bytes for the structures that don't depend on the
637  // number of icon images. Note that sizeof(ICONDIR) already accounts for a
638  // single ICONDIRENTRY structure, which is why we subtract one from the
639  // number of bitmaps.
640  size_t total_buffer_size = sizeof(ICONDIR);
641  size_t bitmap_count = set.size();
642  total_buffer_size += sizeof(ICONDIRENTRY) * (bitmap_count - 1);
643  // May not have all icon sizes, but must have at least up to medium icon size.
644  DCHECK_GE(bitmap_count, kNumIconDimensionsUpToMediumSize);
645
646  // Add the bitmap specific structure sizes.
647  for (size_t i = 0; i < bitmap_count; i++) {
648    size_t xor_mask_size, bytes_in_resource;
649    ComputeBitmapSizeComponents(set[i],
650                                &xor_mask_size,
651                                &bytes_in_resource);
652    total_buffer_size += bytes_in_resource;
653  }
654  return total_buffer_size;
655}
656
657void IconUtil::ComputeBitmapSizeComponents(const SkBitmap& bitmap,
658                                           size_t* xor_mask_size,
659                                           size_t* bytes_in_resource) {
660  // The XOR mask size is easy to calculate since we only deal with 32bpp
661  // images.
662  *xor_mask_size = bitmap.width() * bitmap.height() * 4;
663
664  // Computing the AND mask is a little trickier since it is a monochrome
665  // bitmap (regardless of the number of bits per pixels used in the XOR mask).
666  // There are two things we must make sure we do when computing the AND mask
667  // size:
668  //
669  // 1. Make sure the right number of bytes is allocated for each AND mask
670  //    scan line in case the number of pixels in the image is not divisible by
671  //    8. For example, in a 15X15 image, 15 / 8 is one byte short of
672  //    containing the number of bits we need in order to describe a single
673  //    image scan line so we need to add a byte. Thus, we need 2 bytes instead
674  //    of 1 for each scan line.
675  //
676  // 2. Make sure each scan line in the AND mask is 4 byte aligned (so that the
677  //    total icon image has a 4 byte alignment). In the 15X15 image example
678  //    above, we can not use 2 bytes so we increase it to the next multiple of
679  //    4 which is 4.
680  //
681  // Once we compute the size for a singe AND mask scan line, we multiply that
682  // number by the image height in order to get the total number of bytes for
683  // the AND mask. Thus, for a 15X15 image, we need 15 * 4 which is 60 bytes
684  // for the monochrome bitmap representing the AND mask.
685  size_t and_line_length = (bitmap.width() + 7) >> 3;
686  and_line_length = (and_line_length + 3) & ~3;
687  size_t and_mask_size = and_line_length * bitmap.height();
688  size_t masks_size = *xor_mask_size + and_mask_size;
689  *bytes_in_resource = masks_size + sizeof(BITMAPINFOHEADER);
690}
691