zopfli 0.0.1

data/vendor/zopfli/zlib_container.c

@@ -0,0 +1,79 @@
+/*
+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)
+*/
+
+#include "zlib_container.h"
+#include "util.h"
+
+#include <stdio.h>
+
+#include "deflate.h"
+
+
+/* Calculates the adler32 checksum of the data */
+static unsigned adler32(const unsigned char* data, size_t size)
+{
+  static const unsigned sums_overflow = 5550;
+  unsigned s1 = 1;
+  unsigned s2 = 1 >> 16;
+
+  while (size > 0) {
+    size_t amount = size > sums_overflow ? sums_overflow : size;
+    size -= amount;
+    while (amount > 0) {
+      s1 += (*data++);
+      s2 += s1;
+      amount--;
+    }
+    s1 %= 65521;
+    s2 %= 65521;
+  }
+
+  return (s2 << 16) | s1;
+}
+
+void ZopfliZlibCompress(const ZopfliOptions* options,
+                        const unsigned char* in, size_t insize,
+                        unsigned char** out, size_t* outsize) {
+  unsigned char bitpointer = 0;
+  unsigned checksum = adler32(in, (unsigned)insize);
+  unsigned cmf = 120;  /* CM 8, CINFO 7. See zlib spec.*/
+  unsigned flevel = 0;
+  unsigned fdict = 0;
+  unsigned cmfflg = 256 * cmf + fdict * 32 + flevel * 64;
+  unsigned fcheck = 31 - cmfflg % 31;
+  cmfflg += fcheck;
+
+  ZOPFLI_APPEND_DATA(cmfflg / 256, out, outsize);
+  ZOPFLI_APPEND_DATA(cmfflg % 256, out, outsize);
+
+  ZopfliDeflate(options, 2 /* dynamic block */, 1 /* final */,
+                in, insize, &bitpointer, out, outsize);
+
+  ZOPFLI_APPEND_DATA((checksum >> 24) % 256, out, outsize);
+  ZOPFLI_APPEND_DATA((checksum >> 16) % 256, out, outsize);
+  ZOPFLI_APPEND_DATA((checksum >> 8) % 256, out, outsize);
+  ZOPFLI_APPEND_DATA(checksum % 256, out, outsize);
+
+  if (options->verbose) {
+    fprintf(stderr,
+            "Original Size: %d, Compressed: %d, Compression: %f%% Removed\n",
+            (int)insize, (int)*outsize,
+            100.0f * (float)(insize - *outsize) / (float)insize);
+  }
+}

data/vendor/zopfli/zlib_container.h

@@ -0,0 +1,42 @@
+/*
+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)
+*/
+
+#ifndef ZOPFLI_ZLIB_H_
+#define ZOPFLI_ZLIB_H_
+
+/*
+Functions to compress according to the Zlib specification.
+*/
+
+#include "zopfli.h"
+
+/*
+Compresses according to the zlib specification and append the compressed
+result to the output.
+
+options: global program options
+out: pointer to the dynamic output array to which the result is appended. Must
+  be freed after use.
+outsize: pointer to the dynamic output array size.
+*/
+void ZopfliZlibCompress(const ZopfliOptions* options,
+                        const unsigned char* in, size_t insize,
+                        unsigned char** out, size_t* outsize);
+
+#endif  /* ZOPFLI_ZLIB_H_ */

data/vendor/zopfli/zopfli.h

@@ -0,0 +1,71 @@
+/*
+Copyright 2013 Google Inc. All Rights Reserved.
+Author: lode@google.com (Lode Vandevenne)
+*/
+
+#ifndef UTIL_COMPRESSION_ZOPFLI_INTERNAL_ZOPFLI_H_
+#define UTIL_COMPRESSION_ZOPFLI_INTERNAL_ZOPFLI_H_
+
+#include <stdlib.h> /* for size_t */
+
+/*
+Options used throughout the program.
+*/
+typedef struct ZopfliOptions {
+  /* Whether to print output */
+  int verbose;
+
+  /*
+  Maximum amount of times to rerun forward and backward pass to optimize LZ77
+  compression cost. Good values: 10, 15 for small files, 5 for files over
+  several MB in size or it will be too slow.
+  */
+  int numiterations;
+
+  /*
+  If true, splits the data in multiple deflate blocks with optimal choice
+  for the block boundaries. Block splitting gives better compression. Default:
+  true (1).
+  */
+  int blocksplitting;
+
+  /*
+  If true, chooses the optimal block split points only after doing the iterative
+  LZ77 compression. If false, chooses the block split points first, then does
+  iterative LZ77 on each individual block. Depending on the file, either first
+  or last gives the best compression. Default: false (0).
+  */
+  int blocksplittinglast;
+
+  /*
+  Maximum amount of blocks to split into (0 for unlimited, but this can give
+  extreme results that hurt compression on some files). Default value: 15.
+  */
+  int blocksplittingmax;
+} ZopfliOptions;
+
+/* Initializes options with default values. */
+void ZopfliInitOptions(ZopfliOptions* options);
+
+/* Output format */
+typedef enum {
+  ZOPFLI_FORMAT_GZIP,
+  ZOPFLI_FORMAT_ZLIB,
+  ZOPFLI_FORMAT_DEFLATE
+} ZopfliFormat;
+
+/*
+Compresses according to the given output format and appends the result to the
+output.
+
+options: global program options
+output_type: the output format to use
+out: pointer to the dynamic output array to which the result is appended. Must
+  be freed after use
+outsize: pointer to the dynamic output array size
+*/
+void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
+                    const unsigned char* in, size_t insize,
+                    unsigned char** out, size_t* outsize);
+
+#endif  /* UTIL_COMPRESSION_ZOPFLI_INTERNAL_ZOPFLI_H_ */

data/vendor/zopfli/zopfli_bin.c

@@ -0,0 +1,204 @@
+/*
+Copyright 2011 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)
+*/
+
+/*
+Zopfli compressor program. It can output gzip-, zlib- or deflate-compatible
+data. By default it creates a .gz file. This tool can only compress, not
+decompress. Decompression can be done by any standard gzip, zlib or deflate
+decompressor.
+*/
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "deflate.h"
+#include "gzip_container.h"
+#include "zlib_container.h"
+
+/*
+Loads a file into a memory array.
+*/
+static void LoadFile(const char* filename,
+                     unsigned char** out, size_t* outsize) {
+  FILE* file;
+
+  *out = 0;
+  *outsize = 0;
+  file = fopen(filename, "rb");
+  if (!file) return;
+
+  fseek(file , 0 , SEEK_END);
+  *outsize = ftell(file);
+  rewind(file);
+
+  *out = (unsigned char*)malloc(*outsize);
+
+  if (*outsize && (*out)) {
+    size_t testsize = fread(*out, 1, *outsize, file);
+    if (testsize != *outsize) {
+      /* It could be a directory */
+      free(*out);
+      *out = 0;
+      *outsize = 0;
+    }
+  }
+
+  assert(!(*outsize) || out);  /* If size is not zero, out must be allocated. */
+  fclose(file);
+}
+
+/*
+Saves a file from a memory array, overwriting the file if it existed.
+*/
+static void SaveFile(const char* filename,
+                     const unsigned char* in, size_t insize) {
+  FILE* file = fopen(filename, "wb" );
+  assert(file);
+  fwrite((char*)in, 1, insize, file);
+  fclose(file);
+}
+
+/*
+outfilename: filename to write output to, or 0 to write to stdout instead
+*/
+static void CompressFile(const ZopfliOptions* options,
+                         ZopfliFormat output_type,
+                         const char* infilename,
+                         const char* outfilename) {
+  unsigned char* in;
+  size_t insize;
+  unsigned char* out = 0;
+  size_t outsize = 0;
+  LoadFile(infilename, &in, &insize);
+  if (insize == 0) {
+    fprintf(stderr, "Invalid filename: %s\n", infilename);
+    return;
+  }
+
+  ZopfliCompress(options, output_type, in, insize, &out, &outsize);
+
+  if (outfilename) {
+    SaveFile(outfilename, out, outsize);
+  } else {
+    size_t i;
+    for (i = 0; i < outsize; i++) {
+      /* Works only if terminal does not convert newlines. */
+      printf("%c", out[i]);
+    }
+  }
+
+  free(out);
+  free(in);
+}
+
+/*
+Add two strings together. Size does not matter. Result must be freed.
+*/
+static char* AddStrings(const char* str1, const char* str2) {
+  size_t len = strlen(str1) + strlen(str2);
+  char* result = (char*)malloc(len + 1);
+  if (!result) exit(-1); /* Allocation failed. */
+  strcpy(result, str1);
+  strcat(result, str2);
+  return result;
+}
+
+static char StringsEqual(const char* str1, const char* str2) {
+  return strcmp(str1, str2) == 0;
+}
+
+int main(int argc, char* argv[]) {
+  ZopfliOptions options;
+  ZopfliFormat output_type = ZOPFLI_FORMAT_GZIP;
+  const char* filename = 0;
+  int output_to_stdout = 0;
+  int i;
+
+  ZopfliInitOptions(&options);
+
+  for (i = 1; i < argc; i++) {
+    if (StringsEqual(argv[i], "-v")) options.verbose = 1;
+    else if (StringsEqual(argv[i], "-c")) output_to_stdout = 1;
+    else if (StringsEqual(argv[i], "--deflate")) {
+      output_type = ZOPFLI_FORMAT_DEFLATE;
+    }
+    else if (StringsEqual(argv[i], "--zlib")) output_type = ZOPFLI_FORMAT_ZLIB;
+    else if (StringsEqual(argv[i], "--gzip")) output_type = ZOPFLI_FORMAT_GZIP;
+    else if (StringsEqual(argv[i], "--i5")) options.numiterations = 5;
+    else if (StringsEqual(argv[i], "--i10")) options.numiterations = 10;
+    else if (StringsEqual(argv[i], "--i15")) options.numiterations = 15;
+    else if (StringsEqual(argv[i], "--i25")) options.numiterations = 25;
+    else if (StringsEqual(argv[i], "--i50")) options.numiterations = 50;
+    else if (StringsEqual(argv[i], "--i100")) options.numiterations = 100;
+    else if (StringsEqual(argv[i], "--i250")) options.numiterations = 250;
+    else if (StringsEqual(argv[i], "--i500")) options.numiterations = 500;
+    else if (StringsEqual(argv[i], "--i1000")) options.numiterations = 1000;
+    else if (StringsEqual(argv[i], "-h")) {
+      fprintf(stderr, "Usage: zopfli [OPTION]... FILE\n"
+          "  -h    gives this help\n"
+          "  -c    write the result on standard output, instead of disk"
+          " filename + '.gz'\n"
+          "  -v    verbose mode\n"
+          "  --gzip  output to gzip format (default)\n"
+          "  --deflate  output to deflate format instead of gzip\n"
+          "  --zlib  output to zlib format instead of gzip\n");
+      fprintf(stderr, "  --i5  less compression, but faster\n"
+          "  --i10  less compression, but faster\n"
+          "  --i15  default compression, 15 iterations\n"
+          "  --i25  more compression, but slower\n"
+          "  --i50  more compression, but slower\n"
+          "  --i100  more compression, but slower\n"
+          "  --i250  more compression, but slower\n"
+          "  --i500  more compression, but slower\n"
+          "  --i1000  more compression, but slower\n");
+      return 0;
+    }
+  }
+
+  for (i = 1; i < argc; i++) {
+    if (argv[i][0] != '-') {
+      char* outfilename;
+      filename = argv[i];
+      if (output_to_stdout) {
+        outfilename = 0;
+      } else if (output_type == ZOPFLI_FORMAT_GZIP) {
+        outfilename = AddStrings(filename, ".gz");
+      } else if (output_type == ZOPFLI_FORMAT_ZLIB) {
+        outfilename = AddStrings(filename, ".zlib");
+      } else {
+        assert(output_type == ZOPFLI_FORMAT_DEFLATE);
+        outfilename = AddStrings(filename, ".deflate");
+      }
+      if (options.verbose && outfilename) {
+        fprintf(stderr, "Saving to: %s\n", outfilename);
+      }
+      CompressFile(&options, output_type, filename, outfilename);
+      free(outfilename);
+    }
+  }
+
+  if (!filename) {
+    fprintf(stderr,
+            "Please provide filename\nFor help, type: %s -h\n", argv[0]);
+  }
+
+  return 0;
+}

data/vendor/zopfli/zopfli_lib.c

@@ -0,0 +1,37 @@
+/*
+Copyright 2013 Google Inc. All Rights Reserved.
+Author: lode@google.com (Lode Vandevenne)
+*/
+
+#include "zopfli.h"
+
+#include "deflate.h"
+#include "gzip_container.h"
+#include "zlib_container.h"
+
+#include <assert.h>
+
+void ZopfliInitOptions(ZopfliOptions* options) {
+  options->verbose = 0;
+  options->numiterations = 15;
+  options->blocksplitting = 1;
+  options->blocksplittinglast = 0;
+  options->blocksplittingmax = 15;
+}
+
+void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
+                    const unsigned char* in, size_t insize,
+                    unsigned char** out, size_t* outsize)
+{
+  if (output_type == ZOPFLI_FORMAT_GZIP) {
+    ZopfliGzipCompress(options, in, insize, out, outsize);
+  } else if (output_type == ZOPFLI_FORMAT_ZLIB) {
+    ZopfliZlibCompress(options, in, insize, out, outsize);
+  } else if (output_type == ZOPFLI_FORMAT_DEFLATE) {
+    unsigned char bp = 0;
+    ZopfliDeflate(options, 2 /* Dynamic block */, 1,
+                  in, insize, &bp, out, outsize);
+  } else {
+    assert(0);
+  }
+}

data/zopfli.gemspec

@@ -0,0 +1,49 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'zopfli/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "zopfli"
+  spec.version       = Zopfli::VERSION
+  spec.authors       = ["miyucy"]
+  spec.email         = ["fistfvck@gmail.com"]
+  spec.description   = %q{zopfli}
+  spec.summary       = %q{zopfli}
+  spec.homepage      = "http://github.com/miyucy/zopfli"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/extconf.rb"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+
+  # get an array of submodule dirs by executing 'pwd' inside each submodule
+  `git submodule --quiet foreach pwd`.split($\).each do |submodule_path|
+    # for each submodule, change working directory to that submodule
+    Dir.chdir(submodule_path) do
+
+      # issue git ls-files in submodule's directory
+      submodule_files = `git ls-files`.split($\)
+
+      # prepend the submodule path to create absolute file paths
+      submodule_files_fullpaths = submodule_files.map do |filename|
+        "#{submodule_path}/#{filename}"
+      end
+
+      # remove leading path parts to get paths relative to the gem's root dir
+      # (this assumes, that the gemspec resides in the gem's root dir)
+      submodule_files_paths = submodule_files_fullpaths.map do |filename|
+        filename.gsub "#{File.dirname(__FILE__)}/", ""
+      end
+
+      # add relative paths to gem.files
+      spec.files += submodule_files_paths
+    end
+  end
+end