zopfli 0.0.2 → 0.0.3

data/vendor/zopfli/src/zopflipng/lodepng/lodepng_util.h

@@ -0,0 +1,151 @@
+/*
+LodePNG Utils
+
+Copyright (c) 2005-2012 Lode Vandevenne
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgment in the product documentation would be
+    appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+
+    3. This notice may not be removed or altered from any source
+    distribution.
+*/
+
+/*
+Extra C++ utilities for LodePNG, for convenience.
+*/
+
+#include <string>
+#include <vector>
+#include "lodepng.h"
+
+#pragma once
+
+namespace lodepng
+{
+
+/*
+Returns info from the header of the PNG by value, purely for convenience.
+Does NOT check for errors. Returns bogus info if the PNG has an error.
+Does not require cleanup of allocated memory because no palette or text chunk
+info is in the LodePNGInfo object after checking only the header of the PNG.
+*/
+LodePNGInfo getPNGHeaderInfo(const std::vector<unsigned char>& png);
+
+/*
+Get the names and sizes of all chunks in the PNG file.
+Returns 0 if ok, non-0 if error happened.
+*/
+unsigned getChunkInfo(std::vector<std::string>& names, std::vector<size_t>& sizes,
+                      const std::vector<unsigned char>& png);
+
+/*
+Returns the names and full chunks (including the name and everything else that
+makes up the chunk) for all chunks except IHDR, PLTE, IDAT and IEND.
+It separates the chunks into 3 separate lists, representing the chunks between
+certain critical chunks: 0: IHDR-PLTE, 1: PLTE-IDAT, 2: IDAT-IEND
+Returns 0 if ok, non-0 if error happened.
+*/
+unsigned getChunks(std::vector<std::string> names[3],
+                   std::vector<std::vector<unsigned char> > chunks[3],
+                   const std::vector<unsigned char>& png);
+
+/*
+Inserts chunks into the given png file. The chunks must be fully encoded,
+including length, type, content and CRC.
+The array index determines where it goes:
+0: between IHDR and PLTE, 1: between PLTE and IDAT, 2: between IDAT and IEND.
+They're appended at the end of those locations within the PNG.
+Returns 0 if ok, non-0 if error happened.
+*/
+unsigned insertChunks(std::vector<unsigned char>& png,
+                      const std::vector<std::vector<unsigned char> > chunks[3]);
+
+/*
+Get the filtertypes of each scanline in this PNG file.
+Returns 0 if ok, 1 if PNG decoding error happened.
+
+For a non-interlaced PNG, it returns one filtertype per scanline, in order.
+
+For interlaced PNGs, it returns a result as if it's not interlaced. It returns
+one filtertype per scanline, in order. The values match pass 6 and 7 of the
+Adam7 interlacing, alternating between the two, so that the values correspond
+the most to their scanlines.
+*/
+unsigned getFilterTypes(std::vector<unsigned char>& filterTypes, const std::vector<unsigned char>& png);
+
+/*
+Get the filtertypes of each scanline in every interlace pass this PNG file.
+Returns 0 if ok, 1 if PNG decoding error happened.
+
+For a non-interlaced PNG, it returns one filtertype per scanline, in order, in
+a single std::vector in filterTypes.
+
+For an interlaced PNG, it returns 7 std::vectors in filterTypes, one for each
+Adam7 pass. The amount of values per pass can be calculated as follows, where
+w and h are the size of the image and all divisions are integer divisions:
+pass 1: (h + 7) / 8
+pass 2: w <= 4 ? 0 : (h + 7) / 8
+pass 3: h <= 4 ? 0 : (h + 7) / 8
+pass 4: w <= 2 ? 0 : (h + 3) / 4
+pass 5: h <= 2 ? 0 : (h + 3) / 4
+pass 6: w <= 1 ? 0 : (h + 1) / 2
+pass 7: h <= 1 ? 0 : (h + 1) / 2
+*/
+unsigned getFilterTypesInterlaced(std::vector<std::vector<unsigned char> >& filterTypes,
+                                  const std::vector<unsigned char>& png);
+
+/*
+Returns the value of the i-th pixel in an image with 1, 2, 4 or 8-bit color.
+E.g. if bits is 4 and i is 5, it returns the 5th nibble (4-bit group), which
+is the second half of the 3th byte, in big endian (PNG's endian order).
+*/
+int getPaletteValue(const unsigned char* data, size_t i, int bits);
+
+/*
+The information for extractZlibInfo.
+*/
+struct ZlibBlockInfo
+{
+  int btype; //block type (0-2)
+  size_t compressedbits; //size of compressed block in bits
+  size_t uncompressedbytes; //size of uncompressed block in bytes
+
+  // only filled in for block type 2
+  size_t treebits; //encoded tree size in bits
+  int hlit; //the HLIT value that was filled in for this tree
+  int hdist; //the HDIST value that was filled in for this tree
+  int hclen; //the HCLEN value that was filled in for this tree
+  std::vector<int> clcl; //19 code length code lengths (compressed tree's tree)
+  std::vector<int> treecodes; //N tree codes, with values 0-18. Values 17 or 18 are followed by the repetition value.
+  std::vector<int> litlenlengths; //288 code lengths for lit/len symbols
+  std::vector<int> distlengths; //32 code lengths for dist symbols
+
+  // only filled in for block types 1 or 2
+  std::vector<int> lz77_lcode; //LZ77 codes. 0-255: literals. 256: end symbol. 257-285: length code of length/dist pairs
+  // the next vectors have the same size as lz77_lcode, but an element only has meaningful value if lz77_lcode contains a length code.
+  std::vector<int> lz77_dcode;
+  std::vector<int> lz77_lbits;
+  std::vector<int> lz77_dbits;
+  std::vector<int> lz77_lvalue;
+  std::vector<int> lz77_dvalue;
+  size_t numlit; //number of lit codes in this block
+  size_t numlen; //number of len codes in this block
+};
+
+//Extracts all info needed from a PNG file to reconstruct the zlib compression exactly.
+void extractZlibInfo(std::vector<ZlibBlockInfo>& zlibinfo, const std::vector<unsigned char>& in);
+
+} // namespace lodepng

data/vendor/zopfli/src/zopflipng/zopflipng_bin.cc

@@ -0,0 +1,407 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: lode.vandevenne@gmail.com (Lode Vandevenne)
+// Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
+
+// Command line tool to recompress and optimize PNG images, using zopflipng_lib.
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "lodepng/lodepng.h"
+#include "zopflipng_lib.h"
+
+// Returns directory path (including last slash) in dir, filename without
+// extension in file, extension (including the dot) in ext
+void GetFileNameParts(const std::string& filename,
+    std::string* dir, std::string* file, std::string* ext) {
+  size_t npos = (size_t)(-1);
+  size_t slashpos = filename.find_last_of("/\\");
+  std::string nodir;
+  if (slashpos == npos) {
+    *dir = "";
+    nodir = filename;
+  } else {
+    *dir = filename.substr(0, slashpos + 1);
+    nodir = filename.substr(slashpos + 1);
+  }
+  size_t dotpos = nodir.find_last_of('.');
+  if (dotpos == (size_t)(-1)) {
+    *file = nodir;
+    *ext = "";
+  } else {
+    *file = nodir.substr(0, dotpos);
+    *ext = nodir.substr(dotpos);
+  }
+}
+
+// Returns the size of the file
+size_t GetFileSize(const std::string& filename) {
+  size_t size;
+  FILE* file = fopen(filename.c_str(), "rb");
+  if (!file) return 0;
+  fseek(file , 0 , SEEK_END);
+  size = static_cast<size_t>(ftell(file));
+  fclose(file);
+  return size;
+}
+
+void ShowHelp() {
+  printf("ZopfliPNG, a Portable Network Graphics (PNG) image optimizer.\n"
+         "\n"
+         "Usage: zopflipng [options]... infile.png outfile.png\n"
+         "       zopflipng [options]... --prefix=[fileprefix] [files.png]...\n"
+         "\n"
+         "If the output file exists, it is considered a result from a"
+         " previous run and not overwritten if its filesize is smaller.\n"
+         "\n"
+         "Options:\n"
+         "-m: compress more: use more iterations (depending on file size) and"
+         " use block split strategy 3\n"
+         "--prefix=[fileprefix]: Adds a prefix to output filenames. May also"
+         " contain a directory path. When using a prefix, multiple input files"
+         " can be given and the output filenames are generated with the"
+         " prefix\n"
+         " If --prefix is specified without value, 'zopfli_' is used.\n"
+         " If input file names contain the prefix, they are not processed but"
+         " considered as output from previous runs. This is handy when using"
+         " *.png wildcard expansion with multiple runs.\n"
+         "-y: do not ask about overwriting files.\n"
+         "--lossy_transparent: remove colors behind alpha channel 0. No visual"
+         " difference, removes hidden information.\n"
+         "--lossy_8bit: convert 16-bit per channel image to 8-bit per"
+         " channel.\n"
+         "-d: dry run: don't save any files, just see the console output"
+         " (e.g. for benchmarking)\n"
+         "--always_zopflify: always output the image encoded by Zopfli, even if"
+         " it's bigger than the original, for benchmarking the algorithm. Not"
+         " good for real optimization.\n"
+         "-q: use quick, but not very good, compression"
+         " (e.g. for only trying the PNG filter and color types)\n"
+         "--iterations=[number]: number of iterations, more iterations makes it"
+         " slower but provides slightly better compression. Default: 15 for"
+         " small files, 5 for large files.\n"
+         "--splitting=[0-3]: block split strategy:"
+         " 0=none, 1=first, 2=last, 3=try both and take the best\n"
+         "--filters=[types]: filter strategies to try:\n"
+         " 0-4: give all scanlines PNG filter type 0-4\n"
+         " m: minimum sum\n"
+         " e: entropy\n"
+         " p: predefined (keep from input, this likely overlaps another"
+         " strategy)\n"
+         " b: brute force (experimental)\n"
+         " By default, if this argument is not given, one that is most likely"
+         " the best for this image is chosen by trying faster compression with"
+         " each type.\n"
+         " If this argument is used, all given filter types"
+         " are tried with slow compression and the best result retained. A good"
+         " set of filters to try is --filters=0me.\n"
+         "--keepchunks=nAME,nAME,...: keep metadata chunks with these names"
+         " that would normally be removed, e.g. tEXt,zTXt,iTXt,gAMA, ... \n"
+         " Due to adding extra data, this increases the result size. By default"
+         " ZopfliPNG only keeps the following chunks because they are"
+         " essential: IHDR, PLTE, tRNS, IDAT and IEND.\n"
+         "\n"
+         "Usage examples:\n"
+         "Optimize a file and overwrite if smaller: zopflipng infile.png"
+         " outfile.png\n"
+         "Compress more: zopflipng -m infile.png outfile.png\n"
+         "Optimize multiple files: zopflipng --prefix a.png b.png c.png\n"
+         "Compress really good and trying all filter strategies: zopflipng"
+         " --iterations=500 --splitting=3 --filters=01234mepb"
+         " --lossy_8bit --lossy_transparent infile.png outfile.png\n");
+}
+
+void PrintSize(const char* label, size_t size) {
+  printf("%s: %d (%dK)\n", label, (int) size, (int) size / 1024);
+}
+
+void PrintResultSize(const char* label, size_t oldsize, size_t newsize) {
+  printf("%s: %d (%dK). Percentage of original: %.3f%%\n",
+         label, (int) newsize, (int) newsize / 1024, newsize * 100.0 / oldsize);
+}
+
+int main(int argc, char *argv[]) {
+  if (argc < 2) {
+    ShowHelp();
+    return 0;
+  }
+
+  ZopfliPNGOptions png_options;
+
+  // cmd line options
+  bool always_zopflify = false;  // overwrite file even if we have bigger result
+  bool yes = false;  // do not ask to overwrite files
+  bool dryrun = false;  // never save anything
+
+  std::string user_out_filename;  // output filename if no prefix is used
+  bool use_prefix = false;
+  std::string prefix = "zopfli_";  // prefix for output filenames
+
+  std::vector<std::string> files;
+  std::vector<char> options;
+  for (int i = 1; i < argc; i++) {
+    std::string arg = argv[i];
+    if (arg[0] == '-' && arg.size() > 1 && arg[1] != '-') {
+      for (size_t pos = 1; pos < arg.size(); pos++) {
+        char c = arg[pos];
+        if (c == 'y') {
+          yes = true;
+        } else if (c == 'd') {
+          dryrun = true;
+        } else if (c == 'm') {
+          png_options.num_iterations *= 4;
+          png_options.num_iterations_large *= 4;
+          png_options.block_split_strategy = 3;
+        } else if (c == 'q') {
+          png_options.use_zopfli = false;
+        } else if (c == 'h') {
+          ShowHelp();
+          return 0;
+        } else {
+          printf("Unknown flag: %c\n", c);
+          return 0;
+        }
+      }
+    } else if (arg[0] == '-' && arg.size() > 1 && arg[1] == '-') {
+      size_t eq = arg.find('=');
+      std::string name = arg.substr(0, eq);
+      std::string value = eq >= arg.size() - 1 ? "" : arg.substr(eq + 1);
+      int num = atoi(value.c_str());
+      if (name == "--always_zopflify") {
+        always_zopflify = true;
+      } else if (name == "--lossy_transparent") {
+        png_options.lossy_transparent = true;
+      } else if (name == "--lossy_8bit") {
+        png_options.lossy_8bit = true;
+      } else if (name == "--iterations") {
+        if (num < 1) num = 1;
+        png_options.num_iterations = num;
+        png_options.num_iterations_large = num;
+      } else if (name == "--splitting") {
+        if (num < 0 || num > 3) num = 1;
+        png_options.block_split_strategy = num;
+      } else if (name == "--filters") {
+        for (size_t j = 0; j < value.size(); j++) {
+          ZopfliPNGFilterStrategy strategy = kStrategyZero;
+          char f = value[j];
+          switch (f) {
+            case '0': strategy = kStrategyZero; break;
+            case '1': strategy = kStrategyOne; break;
+            case '2': strategy = kStrategyTwo; break;
+            case '3': strategy = kStrategyThree; break;
+            case '4': strategy = kStrategyFour; break;
+            case 'm': strategy = kStrategyMinSum; break;
+            case 'e': strategy = kStrategyEntropy; break;
+            case 'p': strategy = kStrategyPredefined; break;
+            case 'b': strategy = kStrategyBruteForce; break;
+            default:
+              printf("Unknown filter strategy: %c\n", f);
+              return 1;
+          }
+          png_options.filter_strategies.push_back(strategy);
+          // Enable auto filter strategy only if no user-specified filter is
+          // given.
+          png_options.auto_filter_strategy = false;
+        }
+      } else if (name == "--keepchunks") {
+        bool correct = true;
+        if ((value.size() + 1) % 5 != 0) correct = false;
+        for (size_t i = 0; i + 4 <= value.size() && correct; i += 5) {
+          png_options.keepchunks.push_back(value.substr(i, 4));
+          if (i > 4 && value[i - 1] != ',') correct = false;
+        }
+        if (!correct) {
+          printf("Error: keepchunks format must be like for example:\n"
+                 " --keepchunks=gAMA,cHRM,sRGB,iCCP\n");
+          return 0;
+        }
+      } else if (name == "--prefix") {
+        use_prefix = true;
+        if (!value.empty()) prefix = value;
+      } else if (name == "--help") {
+        ShowHelp();
+        return 0;
+      } else {
+        printf("Unknown flag: %s\n", name.c_str());
+        return 0;
+      }
+    } else {
+      files.push_back(argv[i]);
+    }
+  }
+
+  if (!use_prefix) {
+    if (files.size() == 2) {
+      // The second filename is the output instead of an input if no prefix is
+      // given.
+      user_out_filename = files[1];
+      files.resize(1);
+    } else {
+      printf("Please provide one input and output filename\n\n");
+      ShowHelp();
+      return 0;
+    }
+  }
+
+  size_t total_in_size = 0;
+  // Total output size, taking input size if the input file was smaller
+  size_t total_out_size = 0;
+  // Total output size that zopfli produced, even if input was smaller, for
+  // benchmark information
+  size_t total_out_size_zopfli = 0;
+  size_t total_errors = 0;
+  size_t total_files = 0;
+  size_t total_files_smaller = 0;
+  size_t total_files_saved = 0;
+  size_t total_files_equal = 0;
+
+  for (size_t i = 0; i < files.size(); i++) {
+    if (use_prefix && files.size() > 1) {
+      std::string dir, file, ext;
+      GetFileNameParts(files[i], &dir, &file, &ext);
+      // avoid doing filenames which were already output by this so that you
+      // don't get zopfli_zopfli_zopfli_... files after multiple runs.
+      if (file.find(prefix) == 0) continue;
+    }
+
+    total_files++;
+
+    printf("Optimizing %s\n", files[i].c_str());
+    std::vector<unsigned char> image;
+    unsigned w, h;
+    std::vector<unsigned char> origpng;
+    unsigned error;
+    lodepng::State inputstate;
+    std::vector<unsigned char> resultpng;
+
+    lodepng::load_file(origpng, files[i]);
+    error = ZopfliPNGOptimize(origpng, png_options, true, &resultpng);
+
+    if (error) {
+      printf("Decoding error %i: %s\n", error, lodepng_error_text(error));
+    }
+
+    // Verify result, check that the result causes no decoding errors
+    if (!error) {
+      error = lodepng::decode(image, w, h, inputstate, resultpng);
+      if (error) printf("Error: verification of result failed.\n");
+    }
+
+    if (error) {
+      printf("There was an error\n");
+      total_errors++;
+    } else {
+      size_t origsize = GetFileSize(files[i]);
+      size_t resultsize = resultpng.size();
+
+      if (resultsize < origsize) {
+        printf("Result is smaller\n");
+      } else if (resultsize == origsize) {
+        printf("Result has exact same size\n");
+      } else {
+        printf(always_zopflify
+            ? "Original was smaller\n"
+            : "Preserving original PNG since it was smaller\n");
+      }
+      PrintSize("Input size", origsize);
+      PrintResultSize("Result size", origsize, resultsize);
+
+      std::string out_filename = user_out_filename;
+      if (use_prefix) {
+        std::string dir, file, ext;
+        GetFileNameParts(files[i], &dir, &file, &ext);
+        out_filename = dir + prefix + file + ext;
+      }
+      bool different_output_name = out_filename != files[i];
+
+      total_in_size += origsize;
+      total_out_size_zopfli += resultpng.size();
+      if (resultpng.size() < origsize) total_files_smaller++;
+      else if (resultpng.size() == origsize) total_files_equal++;
+
+      if (!always_zopflify && resultpng.size() > origsize) {
+        // Set output file to input since input was smaller.
+        resultpng = origpng;
+      }
+
+      size_t origoutfilesize = GetFileSize(out_filename);
+      bool already_exists = true;
+      if (origoutfilesize == 0) already_exists = false;
+
+      // When using a prefix, and the output file already exist, assume it's
+      // from a previous run. If that file is smaller, it may represent a
+      // previous run with different parameters that gave a smaller PNG image.
+      // In that case, do not overwrite it. This behaviour can be removed by
+      // adding the always_zopflify flag.
+      bool keep_earlier_output_file = already_exists &&
+          resultpng.size() >= origoutfilesize && !always_zopflify && use_prefix;
+
+      if (keep_earlier_output_file) {
+        // An output file from a previous run is kept, add that files' size
+        // to the output size statistics.
+        total_out_size += origoutfilesize;
+        if (different_output_name) {
+          printf(resultpng.size() == origoutfilesize
+              ? "File not written because a previous run was as good.\n"
+              : "File not written because a previous run was better.\n");
+        }
+      } else {
+        bool confirmed = true;
+        if (!yes && !dryrun && already_exists) {
+          printf("File %s exists, overwrite? (y/N) ", out_filename.c_str());
+          char answer = 0;
+          // Read the first character, the others and enter with getchar.
+          while (int input = getchar()) {
+            if (input == '\n' || input == EOF) break;
+            else if (!answer) answer = input;
+          }
+          confirmed = answer == 'y' || answer == 'Y';
+        }
+        if (confirmed) {
+          if (!dryrun) {
+            lodepng::save_file(resultpng, out_filename);
+            total_files_saved++;
+          }
+          total_out_size += resultpng.size();
+        } else {
+          // An output file from a previous run is kept, add that files' size
+          // to the output size statistics.
+          total_out_size += origoutfilesize;
+        }
+      }
+    }
+    printf("\n");
+  }
+
+  if (total_files > 1) {
+    printf("Summary for all files:\n");
+    printf("Files tried: %d\n", (int) total_files);
+    printf("Files smaller: %d\n", (int) total_files_smaller);
+    if (total_files_equal) {
+      printf("Files equal: %d\n", (int) total_files_equal);
+    }
+    printf("Files saved: %d\n", (int) total_files_saved);
+    if (total_errors) printf("Errors: %d\n", (int) total_errors);
+    PrintSize("Total input size", total_in_size);
+    PrintResultSize("Total output size", total_in_size, total_out_size);
+    PrintResultSize("Benchmark result size",
+                    total_in_size, total_out_size_zopfli);
+  }
+
+  if (dryrun) printf("No files were written because dry run was specified\n");
+
+  return total_errors;
+}