[ZLIB] Add support for windowBits, memLevel, raw

sdk/lib/io/data_transformer.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.io;
 
 
 /**
  * An instance of the default implementation of the [ZLibCodec].
  */
 const ZLibCodec ZLIB = const ZLibCodec();
 
 
 /**
  * The [ZLibCodec] encodes raw bytes to ZLib compressed bytes and decodes ZLib
  * compressed bytes to raw bytes.
  */
 class ZLibCodec extends Codec<List<int>, List<int>> {
   /**
    * The compression level of the [ZLibCodec].
    */
   final int level;
 
   /**
+  * The windowBits parameter is the base two logarithm of the window size (the
+  * size of the history buffer). It should be in the range 8..15. Larger values
+  * of this parameter result in better compression at the expense of memory
+  * usage. The default value is 15
+  */
+  final int windowBits;
+
+  /**
+  * The [memLevel] parameter specifies how much memory should be allocated for
+  * the internal compression state. [memLevel]=1 uses minimum memory but is slow
+  * and reduces compression ratio; [memLevel]=9 uses maximum memory for optimal
+  * speed. The default value is 8
+  * The memory requirements for deflate are (in bytes):
+  *         (1 << (windowBits + 2)) +  (1 << (memLevel + 9))
+  * that is: 128K for windowBits = 15 + 128K for memLevel = 8  (default values)
+  */
+  final int memLevel;
+
+  /**
+  * When [raw] is true, deflate generates raw data with no zlib header or
+  * trailer, and will not compute an adler32 check value
+  */
+  final bool raw;
+
+  /**
    * Get a [Converter] for encoding to `ZLib` compressed data.
    */
   Converter<List<int>, List<int>> get encoder =>
-      new ZLibEncoder(gzip: false, level: level);
+      new ZLibEncoder(gzip: false, level: level, windowBits: windowBits,
+                      raw: raw, memLevel: memLevel);
 
   /**
    * Get a [Converter] for decoding `ZLib` compressed data.
    */
-  Converter<List<int>, List<int>> get decoder => const ZLibDecoder();
+  Converter<List<int>, List<int>> get decoder => new ZLibDecoder(
+      windowBits: windowBits, raw: raw);
 
   /**
-   * The compression-[level] can be set in the range of `1..10`, with `6` being
+   * The compression-[level] can be set in the range of `-1..9`, with `6` being
    * the default compression level. Levels above 6 will have higher compression
    * rates at the cost of more CPU and memory usage. Levels below 6 will use
    * less CPU and memory, but at the cost of lower compression rates.
    */
-  const ZLibCodec({this.level: 6});
+  const ZLibCodec({this.level: 6, this.windowBits: 15, this.raw: false,

[Anders Johnsen, 2014/01/15 10:52:08]

Please add some constants to ZLibCodec, ZLIB_LEVEL_DEFAULT, ZLIB_LEVEL_MIN, etc.

[Anders Johnsen, 2014/01/15 10:52:08]

Make raw the last argument.

[vicb, 2014/01/15 11:08:04]

That's in the pipe

[vicb, 2014/01/15 11:08:04]

Could I ask why ? (is order important for named params)

[Anders Johnsen, 2014/01/15 11:34:17]

Matter of taste I suppose :) `raw` is kind of different than the other flags, so
I think it should be in the front or back. And given that level is the most
common one, I suggested in the back. It's purely a suggestion, and you are free
to leave it as it, if you prefer.

[vicb, 2014/01/23 09:14:04]

I've moved raw to be the last parameter everywhere

+                  this.memLevel: 8});
 }
 
 
 /**
  * An instance of the default implementation of the [GZipCodec].
  */
 const GZipCodec GZIP = const GZipCodec();
 
 
 /**
  * The [GZipCodec] encodes raw bytes to GZip compressed bytes and decodes GZip
  * compressed bytes to raw bytes.
  *
  * The difference between [ZLibCodec] and [GZipCodec] is that the [GZipCodec]
  * wraps the `ZLib` compressed bytes in `GZip` frames.
  */
 class GZipCodec extends Codec<List<int>, List<int>> {
   /**
    * The compression level of the [ZLibCodec].
    */
   final int level;
 
   /**
+  * The windowBits parameter is the base two logarithm of the window size (the
+  * size of the history buffer). It should be in the range 8..15. Larger values
+  * of this parameter result in better compression at the expense of memory
+  * usage. The default value is 15
+  */
+  final int windowBits;
+
+  /**
+  * The [memLevel] parameter specifies how much memory should be allocated for
+  * the internal compression state. [memLevel]=1 uses minimum memory but is slow
+  * and reduces compression ratio; [memLevel]=9 uses maximum memory for optimal
+  * speed. The default value is 8
+  * The memory requirements for deflate are (in bytes):
+  *         (1 << (windowBits + 2)) +  (1 << (memLevel + 9))
+  * that is: 128K for windowBits = 15 + 128K for memLevel = 8  (default values)
+  */
+  final int memLevel;
+
+  /**
+  * When [raw] is true, deflate generates raw data with no zlib header or
+  * trailer, and will not compute an adler32 check value
+  */
+  final bool raw;
+
+  /**
    * Get a [Converter] for encoding to `GZip` compressed data.
    */
   Converter<List<int>, List<int>> get encoder =>
-      new ZLibEncoder(gzip: true, level: level);
+      new ZLibEncoder(gzip: true, level: level, windowBits: windowBits,
+                      raw: raw, memLevel: memLevel);
 
   /**
    * Get a [Converter] for decoding `GZip` compressed data.
    */
-  Converter<List<int>, List<int>> get decoder => const ZLibDecoder();
+  Converter<List<int>, List<int>> get decoder => new ZLibDecoder(
+      windowBits: windowBits, raw: raw);
 
   /**
-   * The compression-[level] can be set in the range of `1..10`, with `6` being
-   * the default compression level. Levels above 6 will have higher compression
-   * rates at the cost of more CPU and memory usage. Levels below 6 will use
-   * less CPU and memory, but at the cost of lower compression rates.
+   * The compression-[level] can be set in the range of `-1..9`, with `6` being
+   * the default compression level. Levels above `6` will have higher
+   * compression rates at the cost of more CPU and memory usage. Levels below
+   * `6` will use less CPU and memory, but at the cost of lower compression
+   * rates.
    */
-  const GZipCodec({this.level: 6});
+  const GZipCodec({this.level: 6, this.windowBits: 15, this.raw: false,
+                  this.memLevel: 8});
 }
 
 
 /**
  * The [ZLibEncoder] is the encoder used by [ZLibCodec] and [GZipCodec] to
  * compress data.
  */
 class ZLibEncoder extends Converter<List<int>, List<int>> {
   /**
    * If [gzip] is true, `GZip` frames will be added to the compressed data.
    */
   final bool gzip;
 
   /**
    * The compression level used by the encoder.
    */
   final int level;
 
   /**
+  * The windowBits parameter is the base two logarithm of the window size (the
+  * size of the history buffer). It should be in the range 8..15. Larger values
+  * of this parameter result in better compression at the expense of memory
+  * usage. The default value is 15
+  */
+  final int windowBits;
+
+  /**
+  * The [memLevel] parameter specifies how much memory should be allocated for
+  * the internal compression state. [memLevel]=1 uses minimum memory but is slow
+  * and reduces compression ratio; [memLevel]=9 uses maximum memory for optimal
+  * speed. The default value is 8
+  * The memory requirements for deflate are (in bytes):
+  *         (1 << (windowBits + 2)) +  (1 << (memLevel + 9))
+  * that is: 128K for windowBits = 15 + 128K for memLevel = 8  (default values)
+  */
+  final int memLevel;
+
+  /**
+  * When [raw] is true, deflate generates raw data with no zlib header or
+  * trailer, and will not compute an adler32 check value
+  */
+  final bool raw;
+
+  /**
    * Create a new [ZLibEncoder] converter. If the [gzip] flag is set, the
    * encoder will wrap the encoded ZLib data in GZip frames.
    */
-  const ZLibEncoder({this.gzip: false, this.level: 6});
-
+  const ZLibEncoder({this.gzip: false, this.level: 6, this.windowBits: 15,
+                    this.raw: false, this.memLevel: 8});
 
   /**
    * Convert a list of bytes using the options given to the [ZLibEncoder]
    * constructor.
    */
   List<int> convert(List<int> bytes) {
     _BufferSink sink = new _BufferSink();
     startChunkedConversion(sink)
       ..add(bytes)
       ..close();
     return sink.builder.takeBytes();
   }
 
   /**
    * Start a chunked conversion using the options given to the [ZLibEncoder]
    * constructor. While it accepts any [ChunkedConversionSink] taking
    * [List<int>]'s, the optimal sink to be passed as [sink] is a
    * [ByteConversionSink].
    */
   ByteConversionSink startChunkedConversion(
       ChunkedConversionSink<List<int>> sink) {
     if (sink is! ByteConversionSink) {
       sink = new ByteConversionSink.from(sink);
     }
-    return new _ZLibEncoderSink(sink, gzip, level);
+    return new _ZLibEncoderSink(sink, gzip, level, windowBits, raw, memLevel);
   }
 }
 
 
 /**
  * The [ZLibDecoder] is the decoder used by [ZLibCodec] and [GZipCodec] to
  * decompress data.
  */
 class ZLibDecoder extends Converter<List<int>, List<int>> {
+  /**
+  * The windowBits parameter is the base two logarithm of the window size (the
+  * size of the history buffer). It should be in the range 8..15. Larger values
+  * of this parameter result in better compression at the expense of memory
+  * usage. The default value is 15
+  */
+  final int windowBits;
 
   /**
-   * Create a new [ZLibEncoder] converter.
+  * When [raw] is true, deflate generates raw data with no zlib header or
+  * trailer, and will not compute an adler32 check value
+  */
+  final bool raw;
+
+  /**
+   * Create a new [ZLibDecoder] converter.
    */
-  const ZLibDecoder();
+  const ZLibDecoder({this.windowBits: 15, this.raw: false});
 
   /**
    * Convert a list of bytes using the options given to the [ZLibDecoder]
    * constructor.
    */
   List<int> convert(List<int> bytes) {
     _BufferSink sink = new _BufferSink();
     startChunkedConversion(sink)
       ..add(bytes)
       ..close();
     return sink.builder.takeBytes();
   }
 
   /**
    * Start a chunked conversion. While it accepts any [ChunkedConversionSink]
    * taking [List<int>]'s, the optimal sink to be passed as [sink] is a
    * [ByteConversionSink].
    */
   ByteConversionSink startChunkedConversion(
       ChunkedConversionSink<List<int>> sink) {
     if (sink is! ByteConversionSink) {
       sink = new ByteConversionSink.from(sink);
     }
-    return new _ZLibDecoderSink(sink);
+    return new _ZLibDecoderSink(sink, windowBits, raw);
   }
 }
 
 
 class _BufferSink extends ByteConversionSink {
   final BytesBuilder builder = new BytesBuilder();
 
   void add(List<int> chunk) {
     builder.add(chunk);
   }
 
   void addSlice(List<int> chunk, int start, int end, bool isLast) {
     if (chunk is Uint8List) {
       Uint8List list = chunk;
       builder.add(new Uint8List.view(list.buffer, start, end - start));
     } else {
       builder.add(chunk.sublist(start, end));
     }
   }
 
   void close() {}
 }
 
 
 class _ZLibEncoderSink extends _FilterSink {
-  _ZLibEncoderSink(ByteConversionSink sink, bool gzip, int level)
-      : super(sink, _Filter.newZLibDeflateFilter(gzip, level));
+  _ZLibEncoderSink(ByteConversionSink sink, bool gzip, int level,
+                   int windowBits, bool raw, int memLevel)
+      : super(sink, _Filter.newZLibDeflateFilter(gzip, level, windowBits, raw,
+                                                 memLevel));
 }
 
 
 class _ZLibDecoderSink extends _FilterSink {
-  _ZLibDecoderSink(ByteConversionSink sink)
-      : super(sink, _Filter.newZLibInflateFilter());
+  _ZLibDecoderSink(ByteConversionSink sink, int windowBits, bool raw)
+      : super(sink, _Filter.newZLibInflateFilter(windowBits, raw));
 }
 
 
 class _FilterSink extends ByteConversionSink {
   final _Filter _filter;
   final ByteConversionSink _sink;
   bool _closed = false;
   bool _empty = true;
 
-  _FilterSink(ByteConversionSink this._sink, _Filter this._filter);
+  _FilterSink(this._sink, this._filter);
 
   void add(List<int> data) {
     addSlice(data, 0, data.length, false);
   }
 
   void addSlice(List<int> data, int start, int end, bool isLast) {
     if (_closed) return;
     if (start < 0 || start > data.length) {
       throw new ArgumentError("Invalid start position");
     }
@@ skipping 57 matching lines @@
    */
   List<int> processed({bool flush: true, bool end: false});
 
   /**
    * Mark the filter as closed. Always call this method for any filter created
    * to avoid leaking resources. [end] can be called at any time, but any
    * successive calls to [process] or [processed] will fail.
    */
   void end();
 
-  external static _Filter newZLibDeflateFilter(bool gzip, int level);
-  external static _Filter newZLibInflateFilter();
+  external static _Filter newZLibDeflateFilter(bool gzip, int level,
+                                               int windowBits, bool raw,
+                                               int memLevel);
+  external static _Filter newZLibInflateFilter(int windowBits, bool raw);
 }