build/sanitize-png-files.sh

   1 #!/bin/bash
   2 # Copyright (c) 2010 The Chromium Authors. All rights reserved.
   3 # Use of this source code is governed by a BSD-style license that can be
   4 # found in the LICENSE file.
   5
   6 # The optimization code is based on pngslim (http://goo.gl/a0XHg)
   7 # and executes a similar pipleline to optimize the png file size.
   8 # The steps that require pngoptimizercl/pngrewrite/deflopt are omitted,
   9 # but this runs all other processes, including:
  10 # 1) various color-dependent optimizations using optipng.
  11 # 2) optimize the number of huffman blocks.
  12 # 3) randomize the huffman table.
  13 # 4) Further optimize using optipng and advdef (zlib stream).
  14 # Due to the step 3), each run may produce slightly different results.
  15 #
  16 # Note(oshima): In my experiment, advdef didn't reduce much. I'm keeping it
  17 # for now as it does not take much time to run.
  18
  19 readonly ALL_DIRS="
  20 ash/resources
  21 ui/resources
  22 chrome/app/theme
  23 chrome/browser/resources
  24 chrome/renderer/resources
  25 webkit/glue/resources
  26 remoting/resources
  27 remoting/webapp
  28 "
  29
  30 # Files larger than this file size (in bytes) will
  31 # use the optimization parameters tailored for large files.
  32 LARGE_FILE_THRESHOLD=3000
  33
  34 # Constants used for optimization
  35 readonly DEFAULT_MIN_BLOCK_SIZE=128
  36 readonly DEFAULT_LIMIT_BLOCKS=256
  37 readonly DEFAULT_RANDOM_TRIALS=100
  38 # Taken from the recommendation in the pngslim's readme.txt.
  39 readonly LARGE_MIN_BLOCK_SIZE=1
  40 readonly LARGE_LIMIT_BLOCKS=2
  41 readonly LARGE_RANDOM_TRIALS=1
  42
  43 # Global variables for stats
  44 TOTAL_OLD_BYTES=0
  45 TOTAL_NEW_BYTES=0
  46 TOTAL_FILE=0
  47 PROCESSED_FILE=0
  48
  49 declare -a THROBBER_STR=('-' '\\' '|' '/')
  50 THROBBER_COUNT=0
  51
  52 # Show throbber character at current cursor position.
  53 function throbber {
  54   echo -ne "${THROBBER_STR[$THROBBER_COUNT]}\b"
  55   let THROBBER_COUNT=($THROBBER_COUNT+1)%4
  56 }
  57
  58 # Usage: pngout_loop <file> <png_out_options> ...
  59 # Optimize the png file using pngout with the given options
  60 # using various block split thresholds and filter types.
  61 function pngout_loop {
  62   local file=$1
  63   shift
  64   local opts=$*
  65   if [ $OPTIMIZE_LEVEL == 1 ]; then
  66     for j in $(seq 0 5); do
  67       throbber
  68       pngout -q -k1 -s1 -f$j $opts $file
  69     done
  70   else
  71     for i in 0 128 256 512; do
  72       for j in $(seq 0 5); do
  73         throbber
  74         pngout -q -k1 -s1 -b$i -f$j $opts $file
  75       done
  76     done
  77   fi
  78 }
  79
  80 # Usage: get_color_depth_list
  81 # Returns the list of color depth options for current optimization level.
  82 function get_color_depth_list {
  83   if [ $OPTIMIZE_LEVEL == 1 ]; then
  84     echo "-d0"
  85   else
  86     echo "-d1 -d2 -d4 -d8"
  87   fi
  88 }
  89
  90 # Usage: process_grayscale <file>
  91 # Optimize grayscale images for all color bit depths.
  92 #
  93 # TODO(oshima): Experiment with -d0 w/o -c0.
  94 function process_grayscale {
  95   echo -n "|gray"
  96   for opt in $(get_color_depth_list); do
  97     pngout_loop $file -c0 $opt
  98   done
  99 }
 100
 101 # Usage: process_grayscale_alpha <file>
 102 # Optimize grayscale images with alpha for all color bit depths.
 103 function process_grayscale_alpha {
 104   echo -n "|gray-a"
 105   pngout_loop $file -c4
 106   for opt in $(get_color_depth_list); do
 107     pngout_loop $file -c3 $opt
 108   done
 109 }
 110
 111 # Usage: process_rgb <file>
 112 # Optimize rgb images with or without alpha for all color bit depths.
 113 function process_rgb {
 114   echo -n "|rgb"
 115   for opt in $(get_color_depth_list); do
 116     pngout_loop $file -c3 $opt
 117   done
 118   pngout_loop $file -c2
 119   pngout_loop $file -c6
 120 }
 121
 122 # Usage: huffman_blocks <file>
 123 # Optimize the huffman blocks.
 124 function huffman_blocks {
 125   local file=$1
 126   echo -n "|huffman"
 127   local size=$(stat -c%s $file)
 128   local min_block_size=$DEFAULT_MIN_BLOCK_SIZE
 129   local limit_blocks=$DEFAULT_LIMIT_BLOCKS
 130
 131   if [ $size -gt $LARGE_FILE_THRESHOLD ]; then
 132     min_block_size=$LARGE_MIN_BLOCK_SIZE
 133     limit_blocks=$LARGE_LIMIT_BLOCKS
 134   fi
 135   let max_blocks=$size/$min_block_size
 136   if [ $max_blocks -gt $limit_blocks ]; then
 137     max_blocks=$limit_blocks
 138   fi
 139
 140   for i in $(seq 2 $max_blocks); do
 141     throbber
 142     pngout -q -k1 -ks -s1 -n$i $file
 143   done
 144 }
 145
 146 # Usage: random_huffman_table_trial <file>
 147 # Try compressing by randomizing the initial huffman table.
 148 #
 149 # TODO(oshima): Try adjusting different parameters for large files to
 150 # reduce runtime.
 151 function random_huffman_table_trial {
 152   echo -n "|random"
 153   local file=$1
 154   local old_size=$(stat -c%s $file)
 155   local trials_count=$DEFAULT_RANDOM_TRIALS
 156
 157   if [ $old_size -gt $LARGE_FILE_THRESHOLD ]; then
 158     trials_count=$LARGE_RANDOM_TRIALS
 159   fi
 160   for i in $(seq 1 $trials_count); do
 161     throbber
 162     pngout -q -k1 -ks -s0 -r $file
 163   done
 164   local new_size=$(stat -c%s $file)
 165   if [ $new_size -lt $old_size ]; then
 166     random_huffman_table_trial $file
 167   fi
 168 }
 169
 170 # Usage: final_comprssion <file>
 171 # Further compress using optipng and advdef.
 172 # TODO(oshima): Experiment with 256.
 173 function final_compression {
 174   echo -n "|final"
 175   local file=$1
 176   if [ $OPTIMIZE_LEVEL == 2 ]; then
 177     for i in 32k 16k 8k 4k 2k 1k 512; do
 178       throbber
 179       optipng -q -nb -nc -zw$i -zc1-9 -zm1-9 -zs0-3 -f0-5 $file
 180     done
 181   fi
 182   for i in $(seq 1 4); do
 183     throbber
 184     advdef -q -z -$i $file
 185   done
 186   echo -ne "\r"
 187 }
 188
 189 # Usage: get_color_type <file>
 190 # Returns the color type name of the png file. Here is the list of names
 191 # for each color type codes.
 192 # 0 : grayscale
 193 # 2 : RGB
 194 # 3 : colormap
 195 # 4 : gray+alpha
 196 # 6 : RGBA
 197 # See http://en.wikipedia.org/wiki/Portable_Network_Graphics#Color_depth
 198 # for details about the color type code.
 199 function get_color_type {
 200   local file=$1
 201   echo $(file $file | awk -F, '{print $3}' | awk '{print $2}')
 202 }
 203
 204 # Usage: optimize_size <file>
 205 # Performs png file optimization.
 206 function optimize_size {
 207   tput el
 208   local file=$1
 209   echo -n "$file "
 210
 211   advdef -q -z -4 $file
 212
 213   pngout -q -s4 -c0 -force $file $file.tmp.png
 214   if [ -f $file.tmp.png ]; then
 215     rm $file.tmp.png
 216     process_grayscale $file
 217     process_grayscale_alpha $file
 218   else
 219     pngout -q -s4 -c4 -force $file $file.tmp.png
 220     if [ -f $file.tmp.png ]; then
 221       rm $file.tmp.png
 222       process_grayscale_alpha $file
 223     else
 224       process_rgb $file
 225     fi
 226   fi
 227
 228   echo -n "|filter"
 229   local old_color_type=$(get_color_type $file)
 230   optipng -q -zc9 -zm8 -zs0-3 -f0-5 $file -out $file.tmp.png
 231   local new_color_type=$(get_color_type $file.tmp.png)
 232   # optipng may corrupt a png file when reducing the color type
 233   # to grayscale/grayscale+alpha. Just skip such cases until
 234   # the bug is fixed. See crbug.com/174505, crbug.com/174084.
 235   # The issue is reported in
 236   # https://sourceforge.net/tracker/?func=detail&aid=3603630&group_id=151404&atid=780913
 237   if [[ $old_color_type == "RGBA" && $new_color_type =~ gray.* ]] ; then
 238     rm $file.tmp.png
 239     echo -n "[skip opting]"
 240   else
 241     mv $file.tmp.png $file
 242   fi
 243   pngout -q -k1 -s1 $file
 244
 245   huffman_blocks $file
 246
 247   # TODO(oshima): Experiment with strategy 1.
 248   echo -n "|strategy"
 249   if [ $OPTIMIZE_LEVEL == 2 ]; then
 250     for i in 3 2 0; do
 251       pngout -q -k1 -ks -s$i $file
 252     done
 253   else
 254     pngout -q -k1 -ks -s1 $file
 255   fi
 256
 257   if [ $OPTIMIZE_LEVEL == 2 ]; then
 258     random_huffman_table_trial $file
 259   fi
 260
 261   final_compression $file
 262 }
 263
 264 # Usage: process_file <file>
 265 function process_file {
 266   local file=$1
 267   local name=$(basename $file)
 268   # -rem alla removes all ancillary chunks except for tRNS
 269   pngcrush -d $TMP_DIR -brute -reduce -rem alla $file > /dev/null
 270
 271   if [ $OPTIMIZE_LEVEL != 0 ]; then
 272     optimize_size $TMP_DIR/$name
 273   fi
 274 }
 275
 276 # Usage: sanitize_file <file>
 277 function sanitize_file {
 278   local file=$1
 279   local name=$(basename $file)
 280   local old=$(stat -c%s $file)
 281   local tmp_file=$TMP_DIR/$name
 282
 283   process_file $file
 284
 285   local new=$(stat -c%s $tmp_file)
 286   let diff=$old-$new
 287   let percent=($diff*100)/$old
 288   let TOTAL_FILE+=1
 289
 290   tput el
 291   if [ $new -lt $old ]; then
 292     echo -ne "$file : $old => $new ($diff bytes : $percent %)\n"
 293     mv "$tmp_file" "$file"
 294     let TOTAL_OLD_BYTES+=$old
 295     let TOTAL_NEW_BYTES+=$new
 296     let PROCESSED_FILE+=1
 297   else
 298     if [ $OPTIMIZE_LEVEL == 0 ]; then
 299       echo -ne "$file : skipped\r"
 300     fi
 301     rm $tmp_file
 302   fi
 303 }
 304
 305 function sanitize_dir {
 306   local dir=$1
 307   for f in $(find $dir -name "*.png"); do
 308     sanitize_file $f
 309   done
 310 }
 311
 312 function install_if_not_installed {
 313   local program=$1
 314   dpkg -s $program > /dev/null 2>&1
 315   if [ "$?" != "0" ]; then
 316     read -p "Couldn't find $program. Do you want to install? (y/n)"
 317     [ "$REPLY" == "y" ] && sudo apt-get install $program
 318     [ "$REPLY" == "y" ] || exit
 319   fi
 320 }
 321
 322 function fail_if_not_installed {
 323   local program=$1
 324   local url=$2
 325   which $program > /dev/null
 326   if [ $? != 0 ]; then
 327     echo "Couldn't find $program. Please download and install it from $url"
 328     exit 1
 329   fi
 330 }
 331
 332 function show_help {
 333   local program=$(basename $0)
 334   echo \
 335 "Usage: $program [options] dir ...
 336
 337 $program is a utility to reduce the size of png files by removing
 338 unnecessary chunks and compressing the image.
 339
 340 Options:
 341   -o<optimize_level>  Specify optimization level: (default is 1)
 342       0  Just run pngcrush. It removes unnecessary chunks and perform basic
 343          optimization on the encoded data.
 344       1  Optimize png files using pngout/optipng and advdef. This can further
 345          reduce addtional 5~30%. This is the default level.
 346       2  Aggressively optimize the size of png files. This may produce
 347          addtional 1%~5% reduction.  Warning: this is *VERY*
 348          slow and can take hours to process all files.
 349   -h  Print this help text."
 350   exit 1
 351 }
 352
 353 if [ ! -e ../.gclient ]; then
 354   echo "$0 must be run in src directory"
 355   exit 1
 356 fi
 357
 358 OPTIMIZE_LEVEL=1
 359 # Parse options
 360 while getopts o:h opts
 361 do
 362   case $opts in
 363     o)
 364       if [[ ! "$OPTARG" =~ [012] ]]; then
 365         show_help
 366       fi
 367       OPTIMIZE_LEVEL=$OPTARG
 368       [ "$1" == "-o" ] && shift
 369       shift;;
 370     [h?])
 371       show_help;;
 372   esac
 373 done
 374
 375 # Make sure we have all necessary commands installed.
 376 install_if_not_installed pngcrush
 377 if [ $OPTIMIZE_LEVEL != 2 ]; then
 378   install_if_not_installed optipng
 379
 380   install_if_not_installed advancecomp
 381   fail_if_not_installed advdef "http://advancemame.sourceforge.net/comp-download.html"
 382
 383   fail_if_not_installed pngout "http://www.jonof.id.au/kenutils"
 384 fi
 385
 386 # Create tmp directory for crushed png file.
 387 TMP_DIR=$(mktemp -d)
 388
 389 # Make sure we cleanup temp dir
 390 trap "rm -rf $TMP_DIR" EXIT
 391
 392 # If no directories are specified, sanitize all directories.
 393 DIRS=$@
 394 set ${DIRS:=$ALL_DIRS}
 395
 396 echo "Optimize level=$OPTIMIZE_LEVEL"
 397 for d in $DIRS; do
 398   echo "Sanitizing png files in $d"
 399   sanitize_dir $d
 400   echo
 401 done
 402
 403 # Print the results.
 404 let diff=$TOTAL_OLD_BYTES-$TOTAL_NEW_BYTES
 405 let percent=$diff*100/$TOTAL_OLD_BYTES
 406 echo "Processed $PROCESSED_FILE files (out of $TOTAL_FILE files)" \
 407      "in $(date -u -d @$SECONDS +%T)s"
 408 echo "Result : $TOTAL_OLD_BYTES => $TOTAL_NEW_BYTES bytes" \
 409      "($diff bytes : $percent %)"
 410