From 260a62edadfb32ba0b9aabe72d0e8a5dc943bdd5 Mon Sep 17 00:00:00 2001
From: George Powley <george.s.powley@intel.com>
Date: Thu, 8 Dec 2016 13:48:46 -0500
Subject: [PATCH] add inflater factory

---
 src/main/java/htsjdk/samtools/BAMFileReader.java   | 183 ++++++++++++++++++---
 .../java/htsjdk/samtools/SamReaderFactory.java     |  42 ++++-
 .../util/AsyncBlockCompressedInputStream.java      |  20 ++-
 .../samtools/util/BlockCompressedInputStream.java  |  68 +++++++-
 .../java/htsjdk/samtools/util/BlockGunzipper.java  |  28 +++-
 .../htsjdk/samtools/util/zip/DeflaterFactory.java  |   6 +-
 .../htsjdk/samtools/util/zip/InflaterFactory.java  |  49 ++++++
 .../java/htsjdk/samtools/SamReaderFactoryTest.java |  30 ++++
 .../util/BlockCompressedInputStreamTest.java       |  98 ++++++++++-
 .../util/BlockCompressedOutputStreamTest.java      |   8 +-
 10 files changed, 486 insertions(+), 46 deletions(-)
 create mode 100644 src/main/java/htsjdk/samtools/util/zip/InflaterFactory.java

diff --git a/src/main/java/htsjdk/samtools/BAMFileReader.java b/src/main/java/htsjdk/samtools/BAMFileReader.java
index 2de91c176..c2f9d4ea3 100644
--- a/src/main/java/htsjdk/samtools/BAMFileReader.java
+++ b/src/main/java/htsjdk/samtools/BAMFileReader.java
@@ -25,13 +25,8 @@
 
 
 import htsjdk.samtools.seekablestream.SeekableStream;
-import htsjdk.samtools.util.AsyncBlockCompressedInputStream;
-import htsjdk.samtools.util.BinaryCodec;
-import htsjdk.samtools.util.BlockCompressedInputStream;
-import htsjdk.samtools.util.CloseableIterator;
-import htsjdk.samtools.util.CoordMath;
-import htsjdk.samtools.util.RuntimeIOException;
-import htsjdk.samtools.util.StringLineReader;
+import htsjdk.samtools.util.*;
+import htsjdk.samtools.util.zip.InflaterFactory;
 
 import java.io.DataInputStream;
 import java.io.File;
@@ -92,40 +87,94 @@
     /**
      * Prepare to read BAM from a stream (not seekable)
      * @param stream source of bytes.
+     * @param indexFile BAM index file
      * @param eagerDecode if true, decode all BAM fields as reading rather than lazily.
+     * @param useAsynchronousIO if true, use asynchronous I/O
      * @param validationStringency Controls how to handle invalidate reads or header lines.
+     * @param samRecordFactory SAM record factory
+     * @throws IOException
      */
     BAMFileReader(final InputStream stream,
                   final File indexFile,
                   final boolean eagerDecode,
                   final boolean useAsynchronousIO,
                   final ValidationStringency validationStringency,
-                  final SAMRecordFactory factory)
-        throws IOException {
+                  final SAMRecordFactory samRecordFactory)
+            throws IOException {
+        this(stream, indexFile, eagerDecode, useAsynchronousIO, validationStringency, samRecordFactory,
+             BlockGunzipper.getDefaultInflaterFactory());
+    }
+
+    /**
+     * Prepare to read BAM from a stream (not seekable)
+     * @param stream source of bytes.
+     * @param indexFile BAM index file
+     * @param eagerDecode if true, decode all BAM fields as reading rather than lazily.
+     * @param useAsynchronousIO if true, use asynchronous I/O
+     * @param validationStringency Controls how to handle invalidate reads or header lines.
+     * @param samRecordFactory SAM record factory
+     * @param inflaterFactory InflaterFactory used by BlockCompressedInputStream
+     * @throws IOException
+     */
+    BAMFileReader(final InputStream stream,
+                  final File indexFile,
+                  final boolean eagerDecode,
+                  final boolean useAsynchronousIO,
+                  final ValidationStringency validationStringency,
+                  final SAMRecordFactory samRecordFactory,
+                  final InflaterFactory inflaterFactory)
+            throws IOException {
         mIndexFile = indexFile;
         mIsSeekable = false;
-        mCompressedInputStream = useAsynchronousIO ? new AsyncBlockCompressedInputStream(stream) : new BlockCompressedInputStream(stream);
+        mCompressedInputStream = useAsynchronousIO ? new AsyncBlockCompressedInputStream(stream, inflaterFactory) : new BlockCompressedInputStream(stream, inflaterFactory);
         mStream = new BinaryCodec(new DataInputStream(mCompressedInputStream));
         this.eagerDecode = eagerDecode;
         this.mValidationStringency = validationStringency;
-        this.samRecordFactory = factory;
+        this.samRecordFactory = samRecordFactory;
         this.mFileHeader = readHeader(this.mStream, this.mValidationStringency, null);
     }
 
     /**
      * Prepare to read BAM from a file (seekable)
      * @param file source of bytes.
+     * @param indexFile BAM index file
+     * @param eagerDecode if true, decode all BAM fields as reading rather than lazily.
+     * @param useAsynchronousIO if true, use asynchronous I/O
+     * @param validationStringency Controls how to handle invalidate reads or header lines.
+     * @param samRecordFactory SAM record factory
+     * @throws IOException
+     */
+    BAMFileReader(final File file,
+                  final File indexFile,
+                  final boolean eagerDecode,
+                  final boolean useAsynchronousIO,
+                  final ValidationStringency validationStringency,
+                  final SAMRecordFactory samRecordFactory)
+        throws IOException {
+        this(file, indexFile, eagerDecode, useAsynchronousIO, validationStringency, samRecordFactory, BlockGunzipper.getDefaultInflaterFactory());
+    }
+
+    /**
+     * Prepare to read BAM from a file (seekable)
+     * @param file source of bytes.
+     * @param indexFile BAM index file
      * @param eagerDecode if true, decode all BAM fields as reading rather than lazily.
+     * @param useAsynchronousIO if true, use asynchronous I/O
      * @param validationStringency Controls how to handle invalidate reads or header lines.
+     * @param samRecordFactory SAM record factory
+     * @param inflaterFactory InflaterFactory used by BlockCompressedInputStream
+     * @throws IOException
      */
     BAMFileReader(final File file,
                   final File indexFile,
                   final boolean eagerDecode,
                   final boolean useAsynchronousIO,
                   final ValidationStringency validationStringency,
-                  final SAMRecordFactory factory)
+                  final SAMRecordFactory samRecordFactory,
+                  final InflaterFactory inflaterFactory)
         throws IOException {
-        this(useAsynchronousIO ? new AsyncBlockCompressedInputStream(file) : new BlockCompressedInputStream(file), indexFile!=null ? indexFile : SamFiles.findIndex(file), eagerDecode, useAsynchronousIO, file.getAbsolutePath(), validationStringency, factory);
+        this(useAsynchronousIO ? new AsyncBlockCompressedInputStream(file, inflaterFactory) : new BlockCompressedInputStream(file, inflaterFactory),
+                indexFile!=null ? indexFile : SamFiles.findIndex(file), eagerDecode, useAsynchronousIO, file.getAbsolutePath(), validationStringency, samRecordFactory);
         if (mIndexFile != null && mIndexFile.lastModified() < file.lastModified()) {
             System.err.println("WARNING: BAM index file " + mIndexFile.getAbsolutePath() +
                     " is older than BAM " + file.getAbsolutePath());
@@ -134,33 +183,110 @@
         mStream.setInputFileName(file.getAbsolutePath());
     }
 
+    /**
+     * Prepare to read BAM from a stream (seekable)
+     * @param strm source of bytes
+     * @param indexFile BAM index file
+     * @param eagerDecode if true, decode all BAM fields as reading rather than lazily.
+     * @param useAsynchronousIO if true, use asynchronous I/O
+     * @param validationStringency Controls how to handle invalidate reads or header lines.
+     * @param samRecordFactory SAM record factory
+     * @throws IOException
+     */
     BAMFileReader(final SeekableStream strm,
                   final File indexFile,
                   final boolean eagerDecode,
                   final boolean useAsynchronousIO,
                   final ValidationStringency validationStringency,
-                  final SAMRecordFactory factory)
+                  final SAMRecordFactory samRecordFactory)
         throws IOException {
-        this(useAsynchronousIO ? new AsyncBlockCompressedInputStream(strm) : new BlockCompressedInputStream(strm), indexFile, eagerDecode, useAsynchronousIO, strm.getSource(), validationStringency, factory);
+        this(strm, indexFile, eagerDecode, useAsynchronousIO, validationStringency, samRecordFactory, BlockGunzipper.getDefaultInflaterFactory());
     }
 
+    /**
+     * Prepare to read BAM from a stream (seekable)
+     * @param strm source of bytes
+     * @param indexFile BAM index file
+     * @param eagerDecode if true, decode all BAM fields as reading rather than lazily.
+     * @param useAsynchronousIO if true, use asynchronous I/O
+     * @param validationStringency Controls how to handle invalidate reads or header lines.
+     * @param samRecordFactory SAM record factory
+     * @param inflaterFactory InflaterFactory used by BlockCompressedInputStream
+     * @throws IOException
+     */
+    BAMFileReader(final SeekableStream strm,
+                  final File indexFile,
+                  final boolean eagerDecode,
+                  final boolean useAsynchronousIO,
+                  final ValidationStringency validationStringency,
+                  final SAMRecordFactory samRecordFactory,
+                  final InflaterFactory inflaterFactory)
+        throws IOException {
+        this(useAsynchronousIO ? new AsyncBlockCompressedInputStream(strm, inflaterFactory) : new BlockCompressedInputStream(strm, inflaterFactory),
+                indexFile, eagerDecode, useAsynchronousIO, strm.getSource(), validationStringency, samRecordFactory);
+    }
+
+    /**
+     * Prepare to read BAM from a stream (seekable)
+     * @param strm source of bytes
+     * @param indexStream BAM index stream
+     * @param eagerDecode if true, decode all BAM fields as reading rather than lazily.
+     * @param useAsynchronousIO if true, use asynchronous I/O
+     * @param validationStringency Controls how to handle invalidate reads or header lines.
+     * @param samRecordFactory SAM record factory
+     * @throws IOException
+     */
     BAMFileReader(final SeekableStream strm,
                   final SeekableStream indexStream,
                   final boolean eagerDecode,
                   final boolean useAsynchronousIO,
                   final ValidationStringency validationStringency,
-                  final SAMRecordFactory factory)
+                  final SAMRecordFactory samRecordFactory)
         throws IOException {
-        this(useAsynchronousIO ? new AsyncBlockCompressedInputStream(strm) : new BlockCompressedInputStream(strm), indexStream, eagerDecode, useAsynchronousIO, strm.getSource(), validationStringency, factory);
+        this(strm, indexStream, eagerDecode, useAsynchronousIO, validationStringency, samRecordFactory, BlockGunzipper.getDefaultInflaterFactory());
     }
 
+    /**
+     * Prepare to read BAM from a stream (seekable)
+     * @param strm source of bytes
+     * @param indexStream BAM index stream
+     * @param eagerDecode if true, decode all BAM fields as reading rather than lazily.
+     * @param useAsynchronousIO if true, use asynchronous I/O
+     * @param validationStringency Controls how to handle invalidate reads or header lines.
+     * @param samRecordFactory SAM record factory
+     * @param inflaterFactory InflaterFactory used by BlockCompressedInputStream
+     * @throws IOException
+     */
+    BAMFileReader(final SeekableStream strm,
+                  final SeekableStream indexStream,
+                  final boolean eagerDecode,
+                  final boolean useAsynchronousIO,
+                  final ValidationStringency validationStringency,
+                  final SAMRecordFactory samRecordFactory,
+                  final InflaterFactory inflaterFactory)
+        throws IOException {
+        this(useAsynchronousIO ? new AsyncBlockCompressedInputStream(strm, inflaterFactory) : new BlockCompressedInputStream(strm, inflaterFactory),
+                indexStream, eagerDecode, useAsynchronousIO, strm.getSource(), validationStringency, samRecordFactory);
+    }
+
+    /**
+     * Prepare to read BAM from a compressed stream (seekable)
+     * @param compressedInputStream source of bytes
+     * @param indexFile BAM index file
+     * @param eagerDecode if true, decode all BAM fields as reading rather than lazily.
+     * @param useAsynchronousIO if true, use asynchronous I/O
+     * @param source string used when reporting errors
+     * @param validationStringency Controls how to handle invalidate reads or header lines.
+     * @param samRecordFactory SAM record factory
+     * @throws IOException
+     */
     private BAMFileReader(final BlockCompressedInputStream compressedInputStream,
                           final File indexFile,
                           final boolean eagerDecode,
                           final boolean useAsynchronousIO,
                           final String source,
                           final ValidationStringency validationStringency,
-                          final SAMRecordFactory factory)
+                          final SAMRecordFactory samRecordFactory)
         throws IOException {
         mIndexFile = indexFile;
         mIsSeekable = true;
@@ -168,18 +294,29 @@ private BAMFileReader(final BlockCompressedInputStream compressedInputStream,
         mStream = new BinaryCodec(new DataInputStream(mCompressedInputStream));
         this.eagerDecode = eagerDecode;
         this.mValidationStringency = validationStringency;
-        this.samRecordFactory = factory;
+        this.samRecordFactory = samRecordFactory;
         this.mFileHeader = readHeader(this.mStream, this.mValidationStringency, source);
         mFirstRecordPointer = mCompressedInputStream.getFilePointer();
-    }    
+    }
 
+    /**
+     * Prepare to read BAM from a compressed stream (seekable)
+     * @param compressedInputStream source of bytes
+     * @param indexStream BAM index stream
+     * @param eagerDecode if true, decode all BAM fields as reading rather than lazily.
+     * @param useAsynchronousIO if true, use asynchronous I/O
+     * @param source string used when reporting errors
+     * @param validationStringency Controls how to handle invalidate reads or header lines.
+     * @param samRecordFactory SAM record factory
+     * @throws IOException
+     */
     private BAMFileReader(final BlockCompressedInputStream compressedInputStream,
                           final SeekableStream indexStream,
                           final boolean eagerDecode,
                           final boolean useAsynchronousIO,
                           final String source,
                           final ValidationStringency validationStringency,
-                          final SAMRecordFactory factory)
+                          final SAMRecordFactory samRecordFactory)
         throws IOException {
         mIndexStream = indexStream;
         mIsSeekable = true;
@@ -187,7 +324,7 @@ private BAMFileReader(final BlockCompressedInputStream compressedInputStream,
         mStream = new BinaryCodec(new DataInputStream(mCompressedInputStream));
         this.eagerDecode = eagerDecode;
         this.mValidationStringency = validationStringency;
-        this.samRecordFactory = factory;
+        this.samRecordFactory = samRecordFactory;
         this.mFileHeader = readHeader(this.mStream, this.mValidationStringency, source);
         mFirstRecordPointer = mCompressedInputStream.getFilePointer();
     }
@@ -234,7 +371,7 @@ protected void enableIndexMemoryMapping(final boolean enabled) {
         this.mCompressedInputStream.setCheckCrcs(enabled);
     }
 
-    @Override void setSAMRecordFactory(final SAMRecordFactory factory) { this.samRecordFactory = factory; }
+    @Override void setSAMRecordFactory(final SAMRecordFactory samRecordFactory) { this.samRecordFactory = samRecordFactory; }
 
     @Override
     public SamReader.Type type() {
diff --git a/src/main/java/htsjdk/samtools/SamReaderFactory.java b/src/main/java/htsjdk/samtools/SamReaderFactory.java
index 8f203d5c0..466258aec 100644
--- a/src/main/java/htsjdk/samtools/SamReaderFactory.java
+++ b/src/main/java/htsjdk/samtools/SamReaderFactory.java
@@ -29,6 +29,7 @@
 import htsjdk.samtools.seekablestream.SeekableStream;
 import htsjdk.samtools.sra.SRAAccession;
 import htsjdk.samtools.util.*;
+import htsjdk.samtools.util.zip.InflaterFactory;
 
 import java.io.File;
 import java.io.IOException;
@@ -115,6 +116,13 @@ public SamReader open(final Path path,
     /** Set this factory's {@link htsjdk.samtools.SAMRecordFactory} to the provided one, then returns itself. */
     abstract public SamReaderFactory samRecordFactory(final SAMRecordFactory samRecordFactory);
 
+    /**
+     * Set this factory's {@link htsjdk.samtools.util.zip.InflaterFactory} to the provided one, then returns itself.
+     * Note: The inflaterFactory provided here is only used for BAM decompression implemented with {@link BAMFileReader},
+     * it is not used for CRAM or other formats like a gzipped SAM file.
+     */
+    abstract public SamReaderFactory inflaterFactory(final InflaterFactory inflaterFactory);
+
     /** Enables the provided {@link Option}s, then returns itself. */
     abstract public SamReaderFactory enable(final Option... options);
 
@@ -146,12 +154,14 @@ public SamReader open(final Path path,
     abstract public SamReaderFactory setUseAsyncIo(final boolean asynchronousIO);
 
     private static SamReaderFactoryImpl DEFAULT =
-            new SamReaderFactoryImpl(Option.DEFAULTS, defaultValidationStringency, DefaultSAMRecordFactory.getInstance());
+            new SamReaderFactoryImpl(Option.DEFAULTS, defaultValidationStringency,
+                    DefaultSAMRecordFactory.getInstance(), BlockGunzipper.getDefaultInflaterFactory());
 
     public static void setDefaultValidationStringency(final ValidationStringency defaultValidationStringency) {
         SamReaderFactory.defaultValidationStringency = defaultValidationStringency;
         // The default may have changed, so reset the default SamReader
-        DEFAULT = new SamReaderFactoryImpl(Option.DEFAULTS, defaultValidationStringency, DefaultSAMRecordFactory.getInstance());
+        DEFAULT = new SamReaderFactoryImpl(Option.DEFAULTS, defaultValidationStringency,
+                DefaultSAMRecordFactory.getInstance(), BlockGunzipper.getDefaultInflaterFactory());
     }
 
     /** Creates a copy of the default {@link SamReaderFactory}. */
@@ -164,7 +174,8 @@ public static SamReaderFactory makeDefault() {
      * no path wrapper, and {@link htsjdk.samtools.DefaultSAMRecordFactory}.
      */
     public static SamReaderFactory make() {
-        return new SamReaderFactoryImpl(EnumSet.noneOf(Option.class), ValidationStringency.DEFAULT_STRINGENCY, DefaultSAMRecordFactory.getInstance());
+        return new SamReaderFactoryImpl(EnumSet.noneOf(Option.class), ValidationStringency.DEFAULT_STRINGENCY,
+                DefaultSAMRecordFactory.getInstance(), BlockGunzipper.getDefaultInflaterFactory());
     }
 
     private static class SamReaderFactoryImpl extends SamReaderFactory {
@@ -175,12 +186,14 @@ public static SamReaderFactory make() {
         private SAMRecordFactory samRecordFactory;
         private CustomReaderFactory customReaderFactory;
         private CRAMReferenceSource referenceSource;
+        private InflaterFactory inflaterFactory;
 
-        private SamReaderFactoryImpl(final EnumSet<Option> enabledOptions, final ValidationStringency validationStringency, final SAMRecordFactory samRecordFactory) {
+        private SamReaderFactoryImpl(final EnumSet<Option> enabledOptions, final ValidationStringency validationStringency, final SAMRecordFactory samRecordFactory, final InflaterFactory inflaterFactory) {
             this.enabledOptions = EnumSet.copyOf(enabledOptions);
             this.samRecordFactory = samRecordFactory;
             this.validationStringency = validationStringency;
             this.customReaderFactory = CustomReaderFactory.getInstance();
+            this.inflaterFactory = inflaterFactory;
         }
    
         @Override
@@ -209,6 +222,12 @@ public SamReaderFactory samRecordFactory(final SAMRecordFactory samRecordFactory
         }
 
         @Override
+        public SamReaderFactory inflaterFactory(final InflaterFactory inflaterFactory) {
+            this.inflaterFactory = inflaterFactory;
+            return this;
+        }
+
+        @Override
         public SamReaderFactory enable(final Option... options) {
             Collections.addAll(this.enabledOptions, options);
             return this;
@@ -302,7 +321,8 @@ public SamReader open(final SamInputResource resource) {
                                 false,
                                 asynchronousIO,
                                 validationStringency,
-                                this.samRecordFactory
+                                this.samRecordFactory,
+                                this.inflaterFactory
                         );
                     } else if (SamStreams.sourceLikeCram(data.asUnbufferedSeekableStream())) {
                         if (referenceSource == null) {
@@ -342,18 +362,22 @@ public SamReader open(final SamInputResource resource) {
                             if (null == sourceSeekable || null == indexSeekable) {
                                 // not seekable.
                                 // it's OK that we consumed a bit of the stream already, this ctor expects it.
-                                primitiveSamReader = new BAMFileReader(bufferedStream, indexFile, false, asynchronousIO, validationStringency, this.samRecordFactory);
+                                primitiveSamReader = new BAMFileReader(bufferedStream, indexFile, false, asynchronousIO,
+                                        validationStringency, this.samRecordFactory, this.inflaterFactory);
                             } else {
                                 // seekable.
                                 // need to return to the beginning because it's the same stream we used earlier
                                 // and read a bit from, and that form of the ctor expects the stream to start at 0.
                                 sourceSeekable.seek(0);
                                 primitiveSamReader = new BAMFileReader(
-                                        sourceSeekable, indexSeekable, false, asynchronousIO, validationStringency, this.samRecordFactory);
+                                        sourceSeekable, indexSeekable, false, asynchronousIO, validationStringency,
+                                        this.samRecordFactory, this.inflaterFactory);
                             }
                         } else {
                             bufferedStream.close();
-                            primitiveSamReader = new BAMFileReader(sourceFile, indexFile, false, asynchronousIO, validationStringency, this.samRecordFactory);
+                            primitiveSamReader = new BAMFileReader(
+                                sourceFile, indexFile, false, asynchronousIO,
+                                validationStringency, this.samRecordFactory, this.inflaterFactory);
                         }
                     } else if (BlockCompressedInputStream.isValidFile(bufferedStream)) {
                         primitiveSamReader = new SAMTextReader(new BlockCompressedInputStream(bufferedStream), validationStringency, this.samRecordFactory);
@@ -411,7 +435,7 @@ private boolean isSra(final File sourceFile) {
         }
 
         public static SamReaderFactory copyOf(final SamReaderFactoryImpl target) {
-            return new SamReaderFactoryImpl(target.enabledOptions, target.validationStringency, target.samRecordFactory);
+            return new SamReaderFactoryImpl(target.enabledOptions, target.validationStringency, target.samRecordFactory, target.inflaterFactory);
         }
     }
 
diff --git a/src/main/java/htsjdk/samtools/util/AsyncBlockCompressedInputStream.java b/src/main/java/htsjdk/samtools/util/AsyncBlockCompressedInputStream.java
index de319d8bf..cbb168d43 100644
--- a/src/main/java/htsjdk/samtools/util/AsyncBlockCompressedInputStream.java
+++ b/src/main/java/htsjdk/samtools/util/AsyncBlockCompressedInputStream.java
@@ -26,6 +26,7 @@
 
 import htsjdk.samtools.Defaults;
 import htsjdk.samtools.seekablestream.SeekableStream;
+import htsjdk.samtools.util.zip.InflaterFactory;
 
 import java.io.File;
 import java.io.IOException;
@@ -79,19 +80,36 @@ public AsyncBlockCompressedInputStream(final InputStream stream) {
         super(stream, true);
     }
 
+    public AsyncBlockCompressedInputStream(final InputStream stream, InflaterFactory inflaterFactory) {
+        super(stream, true, inflaterFactory);
+    }
+
     public AsyncBlockCompressedInputStream(final File file)
         throws IOException {
         super(file);
     }
 
+    public AsyncBlockCompressedInputStream(final File file, InflaterFactory inflaterFactory)
+            throws IOException {
+        super(file, inflaterFactory);
+    }
+
     public AsyncBlockCompressedInputStream(final URL url) {
         super(url);
     }
 
+    public AsyncBlockCompressedInputStream(final URL url, InflaterFactory inflaterFactory) {
+        super(url, inflaterFactory);
+    }
+
     public AsyncBlockCompressedInputStream(final SeekableStream strm) {
         super(strm);
     }
-    
+
+    public AsyncBlockCompressedInputStream(final SeekableStream strm, InflaterFactory inflaterFactory) {
+        super(strm, inflaterFactory);
+    }
+
     @Override
     protected DecompressedBlock nextBlock(byte[] bufferAvailableForReuse) {
         if (bufferAvailableForReuse != null) {
diff --git a/src/main/java/htsjdk/samtools/util/BlockCompressedInputStream.java b/src/main/java/htsjdk/samtools/util/BlockCompressedInputStream.java
index 8b5e922db..8ad303e55 100755
--- a/src/main/java/htsjdk/samtools/util/BlockCompressedInputStream.java
+++ b/src/main/java/htsjdk/samtools/util/BlockCompressedInputStream.java
@@ -30,6 +30,7 @@
 import htsjdk.samtools.seekablestream.SeekableFileStream;
 import htsjdk.samtools.seekablestream.SeekableHTTPStream;
 import htsjdk.samtools.seekablestream.SeekableStream;
+import htsjdk.samtools.util.zip.InflaterFactory;
 
 import java.io.ByteArrayOutputStream;
 import java.io.File;
@@ -40,6 +41,7 @@
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.util.Arrays;
+import java.util.zip.Inflater;
 
 /**
  * Utility class for reading BGZF block compressed files.  The caller can treat this file like any other InputStream.
@@ -65,19 +67,41 @@
     private DecompressedBlock mCurrentBlock = null;
     private int mCurrentOffset = 0;
     private long mStreamOffset = 0;
-    private final BlockGunzipper blockGunzipper = new BlockGunzipper();
+    private final BlockGunzipper blockGunzipper;
 
     /**
      * Note that seek() is not supported if this ctor is used.
+     * @param stream source of bytes
      */
     public BlockCompressedInputStream(final InputStream stream) {
-        this(stream, true);
+        this(stream, true, BlockGunzipper.getDefaultInflaterFactory());
     }
 
     /**
      * Note that seek() is not supported if this ctor is used.
+     * @param stream source of bytes
+     * @param inflaterFactory {@link InflaterFactory} used by {@link BlockGunzipper}
+     */
+    public BlockCompressedInputStream(final InputStream stream, final InflaterFactory inflaterFactory) {
+        this(stream, true, inflaterFactory);
+    }
+
+    /**
+     * Note that seek() is not supported if this ctor is used.
+     * @param stream source of bytes
+     * @param allowBuffering if true, allow buffering
      */
     public BlockCompressedInputStream(final InputStream stream, final boolean allowBuffering) {
+        this(stream, allowBuffering, BlockGunzipper.getDefaultInflaterFactory());
+    }
+
+    /**
+     * Note that seek() is not supported if this ctor is used.
+     * @param stream source of bytes
+     * @param allowBuffering if true, allow buffering
+     * @param inflaterFactory {@link InflaterFactory} used by {@link BlockGunzipper}
+     */
+    public BlockCompressedInputStream(final InputStream stream, final boolean allowBuffering, final InflaterFactory inflaterFactory) {
         if (allowBuffering) {
             mStream = IOUtil.toBufferedStream(stream);
         }
@@ -86,30 +110,68 @@ public BlockCompressedInputStream(final InputStream stream, final boolean allowB
         }
 
         mFile = null;
+        blockGunzipper = new BlockGunzipper(inflaterFactory);
     }
 
     /**
      * Use this ctor if you wish to call seek()
+     * @param file source of bytes
+     * @throws IOException
      */
     public BlockCompressedInputStream(final File file) throws IOException {
+        this(file, BlockGunzipper.getDefaultInflaterFactory());
+    }
+
+    /**
+     * Use this ctor if you wish to call seek()
+     * @param file source of bytes
+     * @param inflaterFactory {@link InflaterFactory} used by {@link BlockGunzipper}
+     * @throws IOException
+     */
+    public BlockCompressedInputStream(final File file, final InflaterFactory inflaterFactory) throws IOException {
         mFile = new SeekableFileStream(file);
         mStream = null;
-
+        blockGunzipper = new BlockGunzipper(inflaterFactory);
     }
 
+    /**
+     * @param url source of bytes
+     */
     public BlockCompressedInputStream(final URL url) {
+        this(url, BlockGunzipper.getDefaultInflaterFactory());
+    }
+
+    /**
+     * @param url source of bytes
+     * @param inflaterFactory {@link InflaterFactory} used by {@link BlockGunzipper}
+     */
+    public BlockCompressedInputStream(final URL url, final InflaterFactory inflaterFactory) {
         mFile = new SeekableBufferedStream(new SeekableHTTPStream(url));
         mStream = null;
+        blockGunzipper = new BlockGunzipper(inflaterFactory);
     }
 
     /**
      * For providing some arbitrary data source.  No additional buffering is
      * provided, so if the underlying source is not buffered, wrap it in a
      * SeekableBufferedStream before passing to this ctor.
+     * @param strm source of bytes
      */
     public BlockCompressedInputStream(final SeekableStream strm) {
+        this(strm, BlockGunzipper.getDefaultInflaterFactory());
+    }
+
+    /**
+     * For providing some arbitrary data source.  No additional buffering is
+     * provided, so if the underlying source is not buffered, wrap it in a
+     * SeekableBufferedStream before passing to this ctor.
+     * @param strm source of bytes
+     * @param inflaterFactory {@link InflaterFactory} used by {@link BlockGunzipper}
+     */
+    public BlockCompressedInputStream(final SeekableStream strm, final InflaterFactory inflaterFactory) {
         mFile = strm;
         mStream = null;
+        blockGunzipper = new BlockGunzipper(inflaterFactory);
     }
 
     /**
diff --git a/src/main/java/htsjdk/samtools/util/BlockGunzipper.java b/src/main/java/htsjdk/samtools/util/BlockGunzipper.java
index 18e9285d5..429eb004e 100644
--- a/src/main/java/htsjdk/samtools/util/BlockGunzipper.java
+++ b/src/main/java/htsjdk/samtools/util/BlockGunzipper.java
@@ -24,6 +24,7 @@
 package htsjdk.samtools.util;
 
 import htsjdk.samtools.SAMFormatException;
+import htsjdk.samtools.util.zip.InflaterFactory;
 
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
@@ -43,10 +44,35 @@
  * @author alecw@broadinstitute.org
  */
 public class BlockGunzipper {
-    private final Inflater inflater = new Inflater(true); // GZIP mode
+    private static InflaterFactory defaultInflaterFactory = new InflaterFactory();
+    private final Inflater inflater;
     private final CRC32 crc32 = new CRC32();
     private boolean checkCrcs = false;
 
+    /**
+     * Create BlockGunziper using the provided inflaterFactory
+     * @param inflaterFactory
+     */
+    BlockGunzipper(InflaterFactory inflaterFactory) {
+        inflater = inflaterFactory.makeInflater(true); // GZIP mode
+    }
+
+    /**
+     * Sets the default {@link InflaterFactory} that will be used for all instances unless specified otherwise in the constructor.
+     * If this method is not called the default is a factory that will create the JDK {@link Inflater}.
+     * @param inflaterFactory non-null default factory.
+     */
+    public static void setDefaultInflaterFactory(final InflaterFactory inflaterFactory) {
+        if (inflaterFactory == null) {
+            throw new IllegalArgumentException("null inflaterFactory");
+        }
+        defaultInflaterFactory = inflaterFactory;
+    }
+
+    public static InflaterFactory getDefaultInflaterFactory() {
+        return defaultInflaterFactory;
+    }
+
     /** Allows the caller to decide whether or not to check CRCs on when uncompressing blocks. */
     public void setCheckCrcs(final boolean check) {
         this.checkCrcs = check;
diff --git a/src/main/java/htsjdk/samtools/util/zip/DeflaterFactory.java b/src/main/java/htsjdk/samtools/util/zip/DeflaterFactory.java
index c15e7c663..fb3ac9a18 100644
--- a/src/main/java/htsjdk/samtools/util/zip/DeflaterFactory.java
+++ b/src/main/java/htsjdk/samtools/util/zip/DeflaterFactory.java
@@ -40,9 +40,9 @@ public DeflaterFactory() {
      * Returns a deflater object that will be used when writing BAM files.
      * Subclasses may override to provide their own deflater implementation.
      * @param compressionLevel the compression level (0-9)
-     * @param nowrap if true then use GZIP compatible compression
+     * @param gzipCompatible if true then use GZIP compatible compression
      */
-    public Deflater makeDeflater(final int compressionLevel, final boolean nowrap) {
-        return new Deflater(compressionLevel, nowrap);
+    public Deflater makeDeflater(final int compressionLevel, final boolean gzipCompatible) {
+        return new Deflater(compressionLevel, gzipCompatible);
     }
 }
diff --git a/src/main/java/htsjdk/samtools/util/zip/InflaterFactory.java b/src/main/java/htsjdk/samtools/util/zip/InflaterFactory.java
new file mode 100644
index 000000000..c03dc9a0f
--- /dev/null
+++ b/src/main/java/htsjdk/samtools/util/zip/InflaterFactory.java
@@ -0,0 +1,49 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2013 The Broad Institute
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package htsjdk.samtools.util.zip;
+
+import htsjdk.samtools.util.BlockGunzipper;
+import java.util.zip.Inflater;
+
+/**
+ * Factory for {@link Inflater} objects used by {@link BlockGunzipper}.
+ * This class may be extended to provide alternative inflaters (e.g., for improved performance).
+ * The default implementation returns a JDK {@link Inflater}
+ */
+public class InflaterFactory {
+
+    public InflaterFactory() {
+        //Note: made explicit constructor to make searching for references easier
+    }
+
+    /**
+     * Returns an inflater object that will be used when reading DEFLATE compressed files.
+     * Subclasses may override to provide their own inflater implementation.
+     * The default implementation returns a JDK {@link Inflater}
+     * @param gzipCompatible if true then use GZIP compatible compression
+     */
+    public Inflater makeInflater(final boolean gzipCompatible) {
+        return new Inflater(gzipCompatible);
+    }
+}
diff --git a/src/test/java/htsjdk/samtools/SamReaderFactoryTest.java b/src/test/java/htsjdk/samtools/SamReaderFactoryTest.java
index 1d5163346..82d49c842 100644
--- a/src/test/java/htsjdk/samtools/SamReaderFactoryTest.java
+++ b/src/test/java/htsjdk/samtools/SamReaderFactoryTest.java
@@ -11,6 +11,7 @@
 import java.nio.channels.SeekableByteChannel;
 import java.nio.file.Paths;
 import java.util.function.Function;
+import htsjdk.samtools.util.zip.InflaterFactory;
 import org.testng.Assert;
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
@@ -27,6 +28,7 @@
 import java.util.List;
 import java.util.Set;
 import java.util.function.BiFunction;
+import java.util.zip.Inflater;
 
 public class SamReaderFactoryTest {
     private static final File TEST_DATA_DIR = new File("src/test/resources/htsjdk/samtools");
@@ -42,6 +44,34 @@ public void variousFormatReaderTest(final String inputFile) throws IOException {
         reader.close();
     }
 
+    @Test
+    public void variousFormatReaderInflatorFactoryTest() throws IOException {
+        final String inputFile = "compressed.bam";
+        final int[] inflateCalls = {0}; //Note: using an array is a HACK to fool the compiler
+        class MyInflater extends Inflater {
+            MyInflater(boolean gzipCompatible){
+                super(gzipCompatible);
+            }
+            @Override
+            public int inflate(byte[] b, int off, int len) throws java.util.zip.DataFormatException {
+                inflateCalls[0]++;
+                return super.inflate(b, off, len);
+            }
+        }
+        final InflaterFactory myInflaterFactory = new InflaterFactory() {
+            public Inflater makeInflater(final boolean gzipCompatible) {
+                return new MyInflater(gzipCompatible);
+            }
+        };
+
+        final File input = new File(TEST_DATA_DIR, inputFile);
+        try (final SamReader reader = SamReaderFactory.makeDefault().inflaterFactory(myInflaterFactory).open(input)) {
+            for (final SAMRecord ignored : reader) { }
+            reader.close();
+        }
+        Assert.assertNotEquals(inflateCalls[0], 0, "Not using Inflater from InflateFactory on file : " + inputFile);
+    }
+
     private int countRecordsInQueryInterval(final SamReader reader, final QueryInterval query) {
         final SAMRecordIterator iter = reader.queryOverlapping(new QueryInterval[] { query });
         int count = 0;
diff --git a/src/test/java/htsjdk/samtools/util/BlockCompressedInputStreamTest.java b/src/test/java/htsjdk/samtools/util/BlockCompressedInputStreamTest.java
index e36032cdd..8bd7f6933 100644
--- a/src/test/java/htsjdk/samtools/util/BlockCompressedInputStreamTest.java
+++ b/src/test/java/htsjdk/samtools/util/BlockCompressedInputStreamTest.java
@@ -1,13 +1,19 @@
 package htsjdk.samtools.util;
 
+import java.io.*;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.zip.Inflater;
+
 import java.io.File;
 import java.io.FileInputStream;
 import java.nio.file.Files;
-import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.List;
 
+import htsjdk.samtools.util.zip.InflaterFactory;
 import org.testng.Assert;
+import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
 import htsjdk.samtools.seekablestream.SeekableFileStream;
@@ -86,4 +92,92 @@ public void available_should_return_number_of_bytes_left_in_current_block() thro
 			}
 		}
 	}
+
+    private static class MyInflater extends Inflater {
+        MyInflater(boolean gzipCompatible) {
+            super(gzipCompatible);
+        }
+        @Override
+        public int inflate(byte[] b, int off, int len) throws java.util.zip.DataFormatException {
+            inflateCalls++;
+            return super.inflate(b, off, len);
+        }
+        static int inflateCalls;
+    }
+
+    @DataProvider(name = "customInflaterInput")
+    public Object[][] customInflateInput() throws IOException {
+        final File tempFile = File.createTempFile("testCustomInflater.", ".bam");
+        tempFile.deleteOnExit();
+        System.out.println("Creating file " + tempFile);
+
+        final List<String> linesWritten = new ArrayList<>();
+        final BlockCompressedOutputStream bcos = new BlockCompressedOutputStream(tempFile, 5);
+        String s = "Hi, Mom!\n";
+        bcos.write(s.getBytes()); //Call 1
+        linesWritten.add(s);
+        s = "Hi, Dad!\n";
+        bcos.write(s.getBytes()); //Call 2
+        linesWritten.add(s);
+        bcos.flush();
+        final StringBuilder sb = new StringBuilder(BlockCompressedStreamConstants.DEFAULT_UNCOMPRESSED_BLOCK_SIZE * 2);
+        s = "1234567890123456789012345678901234567890123456789012345678901234567890\n";
+        while (sb.length() <= BlockCompressedStreamConstants.DEFAULT_UNCOMPRESSED_BLOCK_SIZE) {
+            sb.append(s);
+            linesWritten.add(s);
+        }
+        bcos.write(sb.toString().getBytes()); //Call 3
+        bcos.close();
+
+        final InflaterFactory myInflaterFactory = new InflaterFactory() {
+            public Inflater makeInflater(final boolean gzipCompatible) {
+                return new MyInflater(gzipCompatible);
+            }
+        };
+
+        // test catching null InflaterFactory
+        try {
+            BlockGunzipper.setDefaultInflaterFactory(null);
+            Assert.fail("Did not catch 'null' InflaterFactory");
+        }
+        catch (java.lang.IllegalArgumentException e) { /* expected */ }
+
+        BlockGunzipper.setDefaultInflaterFactory(myInflaterFactory);
+
+        return new Object[][]{
+                // use default InflaterFactory
+                {new BlockCompressedInputStream(new FileInputStream(tempFile), false), linesWritten, 4},
+                {new BlockCompressedInputStream(tempFile), linesWritten, 4},
+                {new AsyncBlockCompressedInputStream(tempFile), linesWritten, 4},
+                {new BlockCompressedInputStream(new URL("http://broadinstitute.github.io/picard/testdata/index_test.bam")), null, 21},
+                // provide InflaterFactory
+                {new BlockCompressedInputStream(new FileInputStream(tempFile), false, myInflaterFactory), linesWritten, 4},
+                {new BlockCompressedInputStream(tempFile, myInflaterFactory), linesWritten, 4},
+                {new AsyncBlockCompressedInputStream(tempFile, myInflaterFactory), linesWritten, 4},
+                {new BlockCompressedInputStream(new URL("http://broadinstitute.github.io/picard/testdata/index_test.bam"), myInflaterFactory), null, 21}
+        };
+    }
+
+    @Test(dataProvider = "customInflaterInput")
+    public void testCustomInflater(final BlockCompressedInputStream bcis,
+                                   final List<String> expectedOutput,
+                                   final int expectedInflateCalls) throws Exception
+    {
+        // clear inflate call counter in MyInflater
+        MyInflater.inflateCalls = 0;
+
+        try (final BufferedReader reader = new BufferedReader(new InputStreamReader(bcis))) {
+            String line;
+            for (int i = 0; (line = reader.readLine()) != null; ++i) {
+                // check expected output, if provided
+                if (expectedOutput != null) {
+                    Assert.assertEquals(line + "\n", expectedOutput.get(i));
+                }
+            }
+        }
+        bcis.close();
+
+        // verify custom inflater was used by checking number of inflate calls
+        Assert.assertEquals(MyInflater.inflateCalls, expectedInflateCalls, "inflate calls");
+    }
 }
diff --git a/src/test/java/htsjdk/samtools/util/BlockCompressedOutputStreamTest.java b/src/test/java/htsjdk/samtools/util/BlockCompressedOutputStreamTest.java
index 8a0d97ffe..f90af4b01 100644
--- a/src/test/java/htsjdk/samtools/util/BlockCompressedOutputStreamTest.java
+++ b/src/test/java/htsjdk/samtools/util/BlockCompressedOutputStreamTest.java
@@ -170,8 +170,8 @@ public void testCustomDeflater() throws Exception {
         final int[] deflateCalls = {0}; //Note: using and array is a HACK to fool the compiler
 
         class MyDeflater extends Deflater{
-            MyDeflater(int level, boolean nowrap){
-                super(level, nowrap);
+            MyDeflater(int level, boolean gzipCompatible){
+                super(level, gzipCompatible);
             }
             @Override
             public int deflate(byte[] b, int off, int len) {
@@ -181,8 +181,8 @@ public int deflate(byte[] b, int off, int len) {
 
         }
         final DeflaterFactory myDeflaterFactory= new DeflaterFactory(){
-            public Deflater makeDeflater(final int compressionLevel, final boolean nowrap) {
-                return new MyDeflater(compressionLevel, nowrap);
+            public Deflater makeDeflater(final int compressionLevel, final boolean gzipCompatible) {
+                return new MyDeflater(compressionLevel, gzipCompatible);
             }
         };
         final List<String> linesWritten = new ArrayList<>();