optimize-ico-files: Automatically rebuild the AND mask of 32-bit images.

tools/resources/optimize-ico-files.py

 #!/usr/bin/env python
 # Copyright 2015 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Windows ICO file crusher.
 
 Optimizes the PNG images within a Windows ICO icon file. This extracts all of
 the sub-images within the file, runs any PNG-formatted images through
 optimize-png-files.sh, then packs them back into an ICO file.
 
 NOTE: ICO files can contain both raw uncompressed BMP files and PNG files. This
 script does not touch the BMP files, which means if you have a huge uncompressed
 image, it will not get smaller. 256x256 icons should be PNG-formatted first.
 (Smaller icons should be BMPs for compatibility with Windows XP.)
 """
 
 import argparse
 import logging
+import math
 import os
 import StringIO
 import struct
 import subprocess
 import sys
 import tempfile
 
 OPTIMIZE_PNG_FILES = 'tools/resources/optimize-png-files.sh'
 
 logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
@@ skipping 46 matching lines @@
     with open(png_filename, 'wb') as png_file:
       png_file.write(png_data)
     return OptimizePngFile(temp_dir, png_filename,
                            optimization_level=optimization_level)
 
   finally:
     if os.path.exists(png_filename):
       os.unlink(png_filename)
     os.rmdir(temp_dir)
 
+def ComputeANDMaskFromAlpha(image_data, width, height):
+  """Compute an AND mask from 32-bit BGRA image data."""
+  and_bytes = []
+  for y in range(height):
+    bit_count = 0
+    current_byte = 0
+    for x in range(width):
+      alpha = image_data[(y * width + x) * 4 + 3]
+      current_byte <<= 1
+      if ord(alpha) == 0:
+        current_byte |= 1
+      bit_count += 1
+      if bit_count == 8:
+        and_bytes.append(current_byte)
+        bit_count = 0
+        current_byte = 0
+
+    # At the end of a row, pad the current byte.
+    if bit_count > 0:
+      current_byte <<= (8 - bit_count)
+      and_bytes.append(current_byte)
+    # And keep padding until a multiple of 4 bytes.
+    while len(and_bytes) % 4 != 0:
+      and_bytes.append(0)
+
+  and_bytes = ''.join(map(chr, and_bytes))
+  return and_bytes
+
+def RebuildANDMask(iconimage):
+  """Rebuild the AND mask in an icon image.
+
+  GIMP (<=2.8.14) creates a bad AND mask on 32-bit icon images (pixels with <50%
+  opacity are marked as transparent, which end up looking black on Windows). So,
+  if this is a 32-bit image, throw the mask away and recompute it from the alpha
+  data. (See: https://bugzilla.gnome.org/show_bug.cgi?id=755200)
+
+  Args:
+    iconimage: Bytes of an icon image (the BMP data for an entry in an ICO
+      file). Must be in BMP format, not PNG. Does not need to be 32-bit (if it
+      is not 32-bit, this is a no-op).
+
+  Returns:
+    An updated |iconimage|, with the AND mask re-computed using
+    ComputeANDMaskFromAlpha.
+  """
+  # Parse BITMAPINFOHEADER.
+  (_, width, height, _, bpp, _, _, _, _, num_colors, _) = struct.unpack(
+      '<LLLHHLLLLLL', iconimage[:40])
+
+  if bpp != 32:
+    # No alpha channel, so the mask cannot be "wrong" (it is the only source of
+    # transparency information).
+    return iconimage
+
+  height /= 2
+  xor_size = int(math.ceil(width * bpp / 32.0)) * 4 * height
+
+  # num_colors can be 0, implying 2^bpp colors.
+  xor_palette_size = (num_colors or (1 << bpp if bpp < 24 else 0)) * 4
+  xor_data = iconimage[40 + xor_palette_size :
+                       40 + xor_palette_size + xor_size]
+
+  and_data = ComputeANDMaskFromAlpha(xor_data, width, height)
+
+  # Replace the AND mask in the original icon data.
+  return iconimage[:40 + xor_palette_size + xor_size] + and_data
+
 def OptimizeIcoFile(infile, outfile, optimization_level=None):
   """Read an ICO file, optimize its PNGs, and write the output to outfile.
 
   Args:
     infile: The file to read from. Must be a seekable file-like object
       containing a Microsoft ICO file.
     outfile: The file to write to.
   """
   filename = os.path.basename(infile.name)
   icondir = infile.read(6)
@@ skipping 20 matching lines @@
     icon_data = infile.read(size)
     if len(icon_data) != size:
       raise EOFError()
 
     entry_is_png = IsPng(icon_data)
     logging.info('%s entry #%d: %dx%d, %d bytes (%s)', filename, i + 1, width,
                  height, size, 'PNG' if entry_is_png else 'BMP')
 
     if entry_is_png:
       icon_data = OptimizePng(icon_data, optimization_level=optimization_level)
-    elif width >= 256 or height >= 256:
-      # TODO(mgiuca): Automatically convert large BMP images to PNGs.
-      logging.warning('Entry #%d is a large image in uncompressed BMP format. '
-                      'Please manually convert to PNG format before running '
-                      'this utility.', i + 1)
+    else:
+      new_icon_data = RebuildANDMask(icon_data)
+      if new_icon_data != icon_data:
+        logging.info('  * Rebuilt AND mask for this image from alpha channel.')
+        icon_data = new_icon_data
+
+      if width >= 256 or height >= 256:
+        # TODO(mgiuca): Automatically convert large BMP images to PNGs.
+        logging.warning('Entry #%d is a large image in uncompressed BMP '
+                        'format. Please manually convert to PNG format before '
+                        'running this utility.', i + 1)
 
     new_size = len(icon_data)
     current_offset += new_size
     icon_dir_entries[i] = (width % 256, height % 256, num_colors, r1, r2, r3,
                            new_size, offset)
     icon_bitmap_data.append(icon_data)
 
   # Write the data back to outfile.
   outfile.write(icondir)
   for icon_dir_entry in icon_dir_entries:
@@ skipping 19 matching lines @@
     logging.getLogger().setLevel(logging.DEBUG)
 
   for file in args.files:
     buf = StringIO.StringIO()
     file.seek(0, os.SEEK_END)
     old_length = file.tell()
     file.seek(0, os.SEEK_SET)
     OptimizeIcoFile(file, buf, args.optimization_level)
 
     new_length = len(buf.getvalue())
+
+    # Always write (even if file size not reduced), because we make other fixes
+    # such as regenerating the AND mask.
+    file.truncate(new_length)
+    file.seek(0)
+    file.write(buf.getvalue())
+
     if new_length >= old_length:
       logging.info('%s : Could not reduce file size.', file.name)
     else:
-      file.truncate(new_length)
-      file.seek(0)
-      file.write(buf.getvalue())
-
       saving = old_length - new_length
       saving_percent = float(saving) / old_length
       logging.info('%s : %d => %d (%d bytes : %d %%)', file.name, old_length,
                    new_length, saving, int(saving_percent * 100))
 
 if __name__ == '__main__':
   sys.exit(main())