Update optimize_png_files.sh to work on msysgit bash.

tools/resources/optimize-png-files.sh

-#!/bin/bash
+#!/bin/bash -i
 # Copyright 2013 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.
 
 # The optimization code is based on pngslim (http://goo.gl/a0XHg)
 # and executes a similar pipleline to optimize the png file size.
 # The steps that require pngoptimizercl/pngrewrite/deflopt are omitted,
 # but this runs all other processes, including:
 # 1) various color-dependent optimizations using optipng.
 # 2) optimize the number of huffman blocks.
@@ skipping 35 matching lines @@
 # Global variables for stats
 TOTAL_OLD_BYTES=0
 TOTAL_NEW_BYTES=0
 TOTAL_FILE=0
 CORRUPTED_FILE=0
 PROCESSED_FILE=0
 
 declare -a THROBBER_STR=('-' '\\' '|' '/')
 THROBBER_COUNT=0
 
-VERBOSE=0
+VERBOSE=false
 
 # Echo only if verbose option is set.
 function info {
-  if [ $VERBOSE -eq 1 ]; then
+  if $VERBOSE ; then
     echo $@
   fi
 }
 
 # Show throbber character at current cursor position.
 function throbber {
   info -ne "${THROBBER_STR[$THROBBER_COUNT]}\b"
-  let THROBBER_COUNT=($THROBBER_COUNT+1)%4
+  let THROBBER_COUNT=$THROBBER_COUNT+1
+  let THROBBER_COUNT=$THROBBER_COUNT%4
 }
 
 # Usage: pngout_loop <file> <png_out_options> ...
 # Optimize the png file using pngout with the given options
 # using various block split thresholds and filter types.
 function pngout_loop {
   local file=$1
   shift
   local opts=$*
   if [ $OPTIMIZE_LEVEL == 1 ]; then
-    for j in $(seq 0 5); do
+    for j in $(eval echo {0..5}); do
       throbber
       pngout -q -k1 -s1 -f$j $opts $file
     done
   else
     for i in 0 128 256 512; do
-      for j in $(seq 0 5); do
+      for j in $(eval echo {0..5}); do
         throbber
         pngout -q -k1 -s1 -b$i -f$j $opts $file
       done
     done
   fi
 }
 
 # Usage: get_color_depth_list
 # Returns the list of color depth options for current optimization level.
 function get_color_depth_list {
   if [ $OPTIMIZE_LEVEL == 1 ]; then
     echo "-d0"
   else
     echo "-d1 -d2 -d4 -d8"
   fi
 }
 
 # Usage: process_grayscale <file>
 # Optimize grayscale images for all color bit depths.
 #
 # TODO(oshima): Experiment with -d0 w/o -c0.
 function process_grayscale {
-  info -n "|gray"
   for opt in $(get_color_depth_list); do
     pngout_loop $file -c0 $opt
   done
 }
 
 # Usage: process_grayscale_alpha <file>
 # Optimize grayscale images with alpha for all color bit depths.
 function process_grayscale_alpha {
-  info -n "|gray-a"
   pngout_loop $file -c4
   for opt in $(get_color_depth_list); do
     pngout_loop $file -c3 $opt
   done
 }
 
 # Usage: process_rgb <file>
 # Optimize rgb images with or without alpha for all color bit depths.
 function process_rgb {
-  info -n "|rgb"
   for opt in $(get_color_depth_list); do
     pngout_loop $file -c3 $opt
   done
   pngout_loop $file -c2
   pngout_loop $file -c6
 }
 
 # Usage: huffman_blocks <file>
 # Optimize the huffman blocks.
 function huffman_blocks {
   local file=$1
-  info -n "|huffman"
   local size=$(stat -c%s $file)
   local min_block_size=$DEFAULT_MIN_BLOCK_SIZE
   local limit_blocks=$DEFAULT_LIMIT_BLOCKS
 
   if [ $size -gt $LARGE_FILE_THRESHOLD ]; then
     min_block_size=$LARGE_MIN_BLOCK_SIZE
     limit_blocks=$LARGE_LIMIT_BLOCKS
   fi
   let max_blocks=$size/$min_block_size
   if [ $max_blocks -gt $limit_blocks ]; then
     max_blocks=$limit_blocks
   fi
 
-  for i in $(seq 2 $max_blocks); do
+  for i in $(eval echo {2..$max_blocks}); do
     throbber
     pngout -q -k1 -ks -s1 -n$i $file
   done
 }
 
 # Usage: random_huffman_table_trial <file>
 # Try compressing by randomizing the initial huffman table.
 #
 # TODO(oshima): Try adjusting different parameters for large files to
 # reduce runtime.
 function random_huffman_table_trial {
-  info -n "|random"

[oshima, 2014/05/22 18:51:43]

why removing them?

[Peter Kasting, 2014/05/22 18:57:31]

They usually extend the printed text for each filename onto a second line, at
which point you can't easily go back and erase things properly with the final
file status.  In other words, they contribute to the problem of unreadable
console spew when you're working with a lot of files.

Given that we have the throbber anyway, it didn't seem tremendously valuable to
have these.  If they're really important, I could instead reserve sufficient
space for the longest one, and then have each status overwrite the previous one.
 It'd be a bit trickier.

[oshima, 2014/05/22 20:38:05]

I added -v for development purpose to see each steps being preformed. I guess
you wanted to
use -v to make sure it processed all files? In that case, how about adding
verbose level and
print all for -v2, but print just filename + result for -v ?

   local file=$1
   local old_size=$(stat -c%s $file)
   local trials_count=$DEFAULT_RANDOM_TRIALS
 
   if [ $old_size -gt $LARGE_FILE_THRESHOLD ]; then
     trials_count=$LARGE_RANDOM_TRIALS
   fi
-  for i in $(seq 1 $trials_count); do
+  for i in $(eval echo {1..$trials_count}); do
     throbber
     pngout -q -k1 -ks -s0 -r $file
   done
   local new_size=$(stat -c%s $file)
   if [ $new_size -lt $old_size ]; then
     random_huffman_table_trial $file
   fi
 }
 
 # Usage: final_comprssion <file>
 # Further compress using optipng and advdef.
 # TODO(oshima): Experiment with 256.
 function final_compression {
-  info -n "|final"
   local file=$1
   if [ $OPTIMIZE_LEVEL == 2 ]; then
     for i in 32k 16k 8k 4k 2k 1k 512; do
       throbber
       optipng -q -nb -nc -zw$i -zc1-9 -zm1-9 -zs0-3 -f0-5 $file
     done
   fi
-  for i in $(seq 1 4); do
+  for i in $(eval echo {1..4}); do
     throbber
     advdef -q -z -$i $file
   done
-  info -ne "\r"
+
+  # Clear the current line.
+  if $VERBOSE ; then
+    printf "\033[0G\033[K"
+  fi
 }
 
 # Usage: get_color_type <file>
 # Returns the color type name of the png file. Here is the list of names
 # for each color type codes.
-# 0 : grayscale
-# 2 : RGB
-# 3 : colormap
-# 4 : gray+alpha
-# 6 : RGBA
+# 0: grayscale
+# 2: RGB
+# 3: colormap
+# 4: gray+alpha
+# 6: RGBA
 # See http://en.wikipedia.org/wiki/Portable_Network_Graphics#Color_depth
 # for details about the color type code.
 function get_color_type {
   local file=$1
   echo $(file $file | awk -F, '{print $3}' | awk '{print $2}')
 }
 
 # Usage: optimize_size <file>
 # Performs png file optimization.
 function optimize_size {
-  tput el
+  # Print filename, trimmed to ensure it + throbber don't take more than 1 line
+  local filename_length=${#file}
+  local -i allowed_length=$COLUMNS-1
+  local -i trimmed_length=$filename_length-$COLUMNS-4
+  if [ "$filename_length" -lt "$allowed_length" ]; then
+    info -n "$file"
+  else
+    info -n "...${file:$trimmed_length}"
+  fi
+
   local file=$1
-  info -n "$file "
 
   advdef -q -z -4 $file
 
   pngout -q -s4 -c0 -force $file $file.tmp.png
   if [ -f $file.tmp.png ]; then
     rm $file.tmp.png
     process_grayscale $file
     process_grayscale_alpha $file
   else
     pngout -q -s4 -c4 -force $file $file.tmp.png
     if [ -f $file.tmp.png ]; then
       rm $file.tmp.png
       process_grayscale_alpha $file
     else
       process_rgb $file
     fi
   fi
 
-  info -n "|filter"
   local old_color_type=$(get_color_type $file)
   optipng -q -zc9 -zm8 -zs0-3 -f0-5 $file -out $file.tmp.png
   local new_color_type=$(get_color_type $file.tmp.png)
   # optipng may corrupt a png file when reducing the color type
   # to grayscale/grayscale+alpha. Just skip such cases until
   # the bug is fixed. See crbug.com/174505, crbug.com/174084.
   # The issue is reported in
   # https://sourceforge.net/tracker/?func=detail&aid=3603630&group_id=151404&atid=780913
-  if [[ $old_color_type == "RGBA" && $new_color_type =~ gray.* ]] ; then
+  if [[ $old_color_type == "RGBA" && $new_color_type == gray* ]] ; then
     rm $file.tmp.png
     info -n "[skip opting]"
   else
     mv $file.tmp.png $file
   fi
   pngout -q -k1 -s1 $file
 
   huffman_blocks $file
 
   # TODO(oshima): Experiment with strategy 1.
-  info -n "|strategy"
   if [ $OPTIMIZE_LEVEL == 2 ]; then
     for i in 3 2 0; do
       pngout -q -k1 -ks -s$i $file
     done
   else
     pngout -q -k1 -ks -s1 $file
   fi
 
   if [ $OPTIMIZE_LEVEL == 2 ]; then
     random_huffman_table_trial $file
   fi
 
   final_compression $file
 }
 
 # Usage: process_file <file>
 function process_file {
   local file=$1
   local name=$(basename $file)
   # -rem alla removes all ancillary chunks except for tRNS
-  pngcrush -d $TMP_DIR -brute -reduce -rem alla $file > /dev/null
+  pngcrush -d $TMP_DIR -brute -reduce -rem alla $file > /dev/null 2>&1
 
   if [ -f $TMP_DIR/$name -a $OPTIMIZE_LEVEL != 0 ]; then
     optimize_size $TMP_DIR/$name
   fi
 }
 
 # Usage: optimize_file <file>
 function optimize_file {
   local file=$1
   if $using_cygwin ; then
     file=$(cygpath -w $file)
   fi
 
   local name=$(basename $file)
   local old=$(stat -c%s $file)
   local tmp_file=$TMP_DIR/$name
   let TOTAL_FILE+=1
 
   process_file $file
 
-  if [ ! -e  $tmp_file ] ; then
+  if [ ! -e $tmp_file ] ; then
     let CORRUPTED_FILE+=1
-    echo "The png file ($file) may be corrupted. skipping"
+    echo "$file may be corrupted; skipping\n"
     return
   fi
 
   local new=$(stat -c%s $tmp_file)
   let diff=$old-$new
-  let percent=($diff*100)/$old
+  let percent=$diff*100
+  let percent=$percent/$old
 
-  tput el
   if [ $new -lt $old ]; then
-    echo -ne "$file : $old => $new ($diff bytes : $percent %)\n"
-    mv "$tmp_file" "$file"
+    echo -ne "$file: $old => $new ($diff bytes: $percent%)\n"
+    cp "$tmp_file" "$file"
     let TOTAL_OLD_BYTES+=$old
     let TOTAL_NEW_BYTES+=$new
     let PROCESSED_FILE+=1
   else
     if [ $OPTIMIZE_LEVEL == 0 ]; then
-      info -ne "$file : skipped\r"
+      info -ne "$file: Skipped\n"
+    else
+      echo -ne "$file: Unable to reduce size\n"

[oshima, 2014/05/22 18:51:43]

info

[Peter Kasting, 2014/05/22 18:57:31]

I used echo on purpose, to match the use of echo in the case above where the
filesize has decreased.  We could change both to "info" if you want, but it
seemed reasonable to at least print out per-file results in non-verbose mode.

What do you prefer?

     fi
     rm $tmp_file
   fi
 }
 
 function optimize_dir {
   local dir=$1
   if $using_cygwin ; then
     dir=$(cygpath -w $dir)
   fi
@@ skipping 59 matching lines @@
   echo "$0 must be run in src directory"
   exit 1
 fi
 
 if [ "$(expr substr $(uname -s) 1 6)" == "CYGWIN" ]; then
   using_cygwin=true
 else
   using_cygwin=false
 fi
 
+# The -i in the shebang line should result in $COLUMNS being set on newer
+# versions of bash.  If it's not set yet, attempt to set it.
+if [ -z $COLUMNS ]; then
+  which tput > /dev/null 2>&1
+  if [ "$?" == "0" ]; then
+    COLUMNS=$(tput cols)
+  else
+    # No tput either... give up and just guess 80 columns.
+    COLUMNS=80
+  fi
+  export COLUMNS
+fi
+
 OPTIMIZE_LEVEL=1
 # Parse options
 while getopts o:r:h:v opts
 do
   case $opts in
     r)
       COMMIT=$(git svn find-rev r$OPTARG | tail -1) || exit
       if [ -z "$COMMIT" ] ; then
         echo "Revision $OPTARG not found"
         show_help
       fi
       ;;
     o)
-      if [[ ! "$OPTARG" =~ [012] ]] ; then
+      if [[ "$OPTARG" != 0 && "$OPTARG" != 1 && "$OPTARG" != 2 ]] ; then
         show_help
       fi
       OPTIMIZE_LEVEL=$OPTARG
       ;;
     v)
-      let VERBOSE=1
+      VERBOSE=true
       ;;
     [h?])
       show_help;;
   esac
 done
 
 # Remove options from argument list.
 shift $(($OPTIND -1))
 
 # Make sure we have all necessary commands installed.
@@ skipping 15 matching lines @@
   fail_if_not_installed pngout $pngout_url
 fi
 
 # Create tmp directory for crushed png file.
 TMP_DIR=$(mktemp -d)
 if $using_cygwin ; then
   TMP_DIR=$(cygpath -w $TMP_DIR)
 fi
 
 # Make sure we cleanup temp dir
-trap "rm -rf $TMP_DIR" EXIT
+#trap "rm -rf $TMP_DIR" EXIT
 
 # If no directories are specified, optimize all directories.
 DIRS=$@
 set ${DIRS:=$ALL_DIRS}
 
 info "Optimize level=$OPTIMIZE_LEVEL"
 
 if [ -n "$COMMIT" ] ; then
  ALL_FILES=$(git diff --name-only $COMMIT HEAD $DIRS | grep "png$")
  ALL_FILES_LIST=( $ALL_FILES )
@@ skipping 13 matching lines @@
       info ""
     elif [ -f $d ] ; then
       optimize_file $d
     else
       echo "Not a file or directory: $d";
     fi
   done
 fi
 
 # Print the results.
-if [ $PROCESSED_FILE == 0 ]; then
-  echo "Did not find any files (out of $TOTAL_FILE files)" \
-       "that could be optimized" \
-       "in $(date -u -d @$SECONDS +%T)s"
-else
+echo "Optimized $PROCESSED_FILE/$TOTAL_FILE files in" \
+     "$(date -d "0 + $SECONDS sec" +%Ts)"
+if [ $PROCESSED_FILE != 0 ]; then
   let diff=$TOTAL_OLD_BYTES-$TOTAL_NEW_BYTES
   let percent=$diff*100/$TOTAL_OLD_BYTES
-  echo "Processed $PROCESSED_FILE files (out of $TOTAL_FILE files)" \
-       "in $(date -u -d @$SECONDS +%T)s"
-  echo "Result : $TOTAL_OLD_BYTES => $TOTAL_NEW_BYTES bytes" \
-       "($diff bytes : $percent %)"
+  echo "Result: $TOTAL_OLD_BYTES => $TOTAL_NEW_BYTES bytes" \
+       "($diff bytes: $percent%)"
 fi
 if [ $CORRUPTED_FILE != 0 ]; then
   echo "Warning: corrupted files found: $CORRUPTED_FILE"
   echo "Please contact the author of the CL that landed corrupted png files"
 fi