diff -Nru xz-java-1.3/NEWS xz-java-1.4/NEWS
--- xz-java-1.3/NEWS	2013-05-12 18:19:32.000000000 +0000
+++ xz-java-1.4/NEWS	2013-09-22 10:39:20.000000000 +0000
@@ -2,6 +2,10 @@
 XZ for Java release notes
 =========================
 
+1.4 (2013-09-22)
+
+    * Add LZMAInputStream for decoding .lzma files and raw LZMA streams.
+
 1.3 (2013-05-12)
 
     * Fix a data corruption bug when flushing the LZMA2 encoder or
diff -Nru xz-java-1.3/build.properties xz-java-1.4/build.properties
--- xz-java-1.3/build.properties	2013-05-12 18:21:44.000000000 +0000
+++ xz-java-1.4/build.properties	2013-09-22 10:39:20.000000000 +0000
@@ -9,7 +9,7 @@
 
 title = XZ data compression
 homepage = http://tukaani.org/xz/java.html
-version = 1.3
+version = 1.4
 
 debug = false
 sourcever = 1.4
diff -Nru xz-java-1.3/build.xml xz-java-1.4/build.xml
--- xz-java-1.3/build.xml	2013-04-14 08:36:20.000000000 +0000
+++ xz-java-1.4/build.xml	2013-09-22 10:39:20.000000000 +0000
@@ -105,6 +105,14 @@
                 <attribute name="Class-Path" value="xz.jar"/>
             </manifest>
         </jar>
+
+        <jar destfile="${jar_dir}/LZMADecDemo.jar" basedir="${classes_dir}"
+             includes="LZMADecDemo.class">
+            <manifest>
+                <attribute name="Main-Class" value="LZMADecDemo"/>
+                <attribute name="Class-Path" value="xz.jar"/>
+            </manifest>
+        </jar>
     </target>
 
     <!-- It's an ugly quick hack. Maybe some day there will be a cleaner
diff -Nru xz-java-1.3/debian/changelog xz-java-1.4/debian/changelog
--- xz-java-1.3/debian/changelog	2013-05-14 10:55:40.000000000 +0000
+++ xz-java-1.4/debian/changelog	2013-09-22 22:01:45.000000000 +0000
@@ -1,3 +1,12 @@
+xz-java (1.4-1) unstable; urgency=low
+
+  * New upstream release
+  * Use canonical URLs for the Vcs-* fields
+  * Update the pom automatically during the build
+  * Enabled the debugging symbols in the compiled classes
+
+ -- Emmanuel Bourg <ebourg@apache.org>  Sun, 22 Sep 2013 23:32:48 +0200
+
 xz-java (1.3-1) unstable; urgency=low
 
   * New upstream release
diff -Nru xz-java-1.3/debian/control xz-java-1.4/debian/control
--- xz-java-1.3/debian/control	2013-05-14 10:55:40.000000000 +0000
+++ xz-java-1.4/debian/control	2013-09-22 21:38:50.000000000 +0000
@@ -6,8 +6,8 @@
 Build-Depends: debhelper (>= 7.0.50~), default-jdk, javahelper, ant,
  default-jdk-doc, maven-repo-helper
 Standards-Version: 3.9.4
-Vcs-Git: git://git.debian.org/git/pkg-java/xz-java.git
-Vcs-Browser: http://git.debian.org/?p=pkg-java/xz-java.git
+Vcs-Git: git://anonscm.debian.org/pkg-java/xz-java.git
+Vcs-Browser: http://anonscm.debian.org/gitweb/?p=pkg-java/xz-java.git
 Homepage: http://tukaani.org/xz/java.html
 
 Package: libxz-java
diff -Nru xz-java-1.3/debian/rules xz-java-1.4/debian/rules
--- xz-java-1.3/debian/rules	2013-05-14 10:55:40.000000000 +0000
+++ xz-java-1.4/debian/rules	2013-09-22 21:58:13.000000000 +0000
@@ -4,7 +4,7 @@
 
 override_dh_auto_build:
 	dh_auto_build
-	ant -Dextdoc_url=file:///usr/share/doc/default-jdk-doc/api jar doc
+	ant -Dextdoc_url=file:///usr/share/doc/default-jdk-doc/api -Ddebug=true jar doc maven
 
 override_dh_auto_clean:
 	dh_auto_clean
@@ -12,6 +12,7 @@
 	-rm -rf extdoc
 
 override_jh_installlibs:
+	cp build/maven/xz-*.pom debian/xz.pom
 	mh_installjar -plibxz-java --java-lib debian/xz.pom build/jar/xz.jar
 	mh_installpoms -plibxz-java
 	dh_installchangelogs -plibxz-java NEWS
diff -Nru xz-java-1.3/debian/xz.pom xz-java-1.4/debian/xz.pom
--- xz-java-1.3/debian/xz.pom	2013-05-14 10:55:40.000000000 +0000
+++ xz-java-1.4/debian/xz.pom	2013-09-22 21:58:35.000000000 +0000
@@ -16,7 +16,7 @@
 
     <groupId>org.tukaani</groupId>
     <artifactId>xz</artifactId>
-    <version>1.2</version>
+    <version>1.4</version>
     <packaging>jar</packaging>
 
     <name>XZ for Java</name>
diff -Nru xz-java-1.3/fileset-src.txt xz-java-1.4/fileset-src.txt
--- xz-java-1.3/fileset-src.txt	2013-04-14 08:36:20.000000000 +0000
+++ xz-java-1.4/fileset-src.txt	2013-09-22 10:39:20.000000000 +0000
@@ -1,3 +1,4 @@
+src/LZMADecDemo.java
 src/XZDecDemo.java
 src/XZEncDemo.java
 src/XZSeekDecDemo.java
@@ -33,6 +34,7 @@
 src/org/tukaani/xz/LZMA2InputStream.java
 src/org/tukaani/xz/LZMA2Options.java
 src/org/tukaani/xz/LZMA2OutputStream.java
+src/org/tukaani/xz/LZMAInputStream.java
 src/org/tukaani/xz/MemoryLimitException.java
 src/org/tukaani/xz/PowerPCOptions.java
 src/org/tukaani/xz/RawCoder.java
@@ -86,6 +88,8 @@
 src/org/tukaani/xz/package-info.java
 src/org/tukaani/xz/rangecoder/RangeCoder.java
 src/org/tukaani/xz/rangecoder/RangeDecoder.java
+src/org/tukaani/xz/rangecoder/RangeDecoderFromBuffer.java
+src/org/tukaani/xz/rangecoder/RangeDecoderFromStream.java
 src/org/tukaani/xz/rangecoder/RangeEncoder.java
 src/org/tukaani/xz/simple/ARM.java
 src/org/tukaani/xz/simple/ARMThumb.java
diff -Nru xz-java-1.3/src/LZMADecDemo.java xz-java-1.4/src/LZMADecDemo.java
--- xz-java-1.3/src/LZMADecDemo.java	1970-01-01 00:00:00.000000000 +0000
+++ xz-java-1.4/src/LZMADecDemo.java	2013-09-22 10:39:20.000000000 +0000
@@ -0,0 +1,80 @@
+/*
+ * LZMADecDemo
+ *
+ * Author: Lasse Collin <lasse.collin@tukaani.org>
+ *
+ * This file has been put into the public domain.
+ * You can do whatever you want with this file.
+ */
+
+import java.io.*;
+import org.tukaani.xz.*;
+
+/**
+ * Decompresses .lzma files to standard output. If no arguments are given,
+ * reads from standard input.
+ *
+ * NOTE: For most purposes, .lzma is a legacy format and usually you should
+ * use .xz instead.
+ */
+class LZMADecDemo {
+    public static void main(String[] args) {
+        byte[] buf = new byte[8192];
+        String name = null;
+
+        try {
+            if (args.length == 0) {
+                name = "standard input";
+
+                // No need to use BufferedInputStream with System.in which
+                // seems to be fast with one-byte reads.
+                InputStream in = new LZMAInputStream(System.in);
+
+                int size;
+                while ((size = in.read(buf)) != -1)
+                    System.out.write(buf, 0, size);
+
+            } else {
+                // Read from files given on the command line.
+                for (int i = 0; i < args.length; ++i) {
+                    name = args[i];
+                    InputStream in = new FileInputStream(name);
+
+                    try {
+                        // In contrast to other classes in org.tukaani.xz,
+                        // LZMAInputStream doesn't do buffering internally
+                        // and reads one byte at a time. BufferedInputStream
+                        // gives a huge performance improvement here but even
+                        // then it's slower than the other input streams from
+                        // org.tukaani.xz.
+                        in = new BufferedInputStream(in);
+                        in = new LZMAInputStream(in);
+
+                        int size;
+                        while ((size = in.read(buf)) != -1)
+                            System.out.write(buf, 0, size);
+
+                    } finally {
+                        // Close FileInputStream (directly or indirectly
+                        // via LZMAInputStream, it doesn't matter).
+                        in.close();
+                    }
+                }
+            }
+        } catch (FileNotFoundException e) {
+            System.err.println("LZMADecDemo: Cannot open " + name + ": "
+                               + e.getMessage());
+            System.exit(1);
+
+        } catch (EOFException e) {
+            System.err.println("LZMADecDemo: Unexpected end of input on "
+                               + name);
+            System.exit(1);
+
+        } catch (IOException e) {
+            System.err.println("LZMADecDemo: Error decompressing from "
+                               + name + ": " + e.getMessage());
+            System.exit(1);
+        }
+    }
+}
diff -Nru xz-java-1.3/src/org/tukaani/xz/LZMA2InputStream.java xz-java-1.4/src/org/tukaani/xz/LZMA2InputStream.java
--- xz-java-1.3/src/org/tukaani/xz/LZMA2InputStream.java	2013-04-14 08:36:20.000000000 +0000
+++ xz-java-1.4/src/org/tukaani/xz/LZMA2InputStream.java	2013-09-22 10:39:20.000000000 +0000
@@ -14,7 +14,7 @@
 import java.io.DataInputStream;
 import java.io.IOException;
 import org.tukaani.xz.lz.LZDecoder;
-import org.tukaani.xz.rangecoder.RangeDecoder;
+import org.tukaani.xz.rangecoder.RangeDecoderFromBuffer;
 import org.tukaani.xz.lzma.LZMADecoder;
 
 /**
@@ -46,7 +46,8 @@
     private DataInputStream in;
 
     private final LZDecoder lz;
-    private final RangeDecoder rc = new RangeDecoder(COMPRESSED_SIZE_MAX);
+    private final RangeDecoderFromBuffer rc
+            = new RangeDecoderFromBuffer(COMPRESSED_SIZE_MAX);
     private LZMADecoder lzma;
 
     private int uncompressedSize = 0;
@@ -69,7 +70,7 @@
      * @return      approximate memory requirements as kibibytes (KiB)
      */
     public static int getMemoryUsage(int dictSize) {
-        // The base state is aroudn 30-40 KiB (probabilities etc.),
+        // The base state is around 30-40 KiB (probabilities etc.),
         // range decoder needs COMPRESSED_SIZE_MAX bytes for buffering,
         // and LZ decoder needs a dictionary buffer.
         return 40 + COMPRESSED_SIZE_MAX / 1024 + getDictSize(dictSize) / 1024;
@@ -117,7 +118,7 @@
     /**
      * Creates a new LZMA2 decompressor using a preset dictionary.
      * <p>
-     * This is like <code>LZMAInputStream(InputStream, int)</code> except
+     * This is like <code>LZMA2InputStream(InputStream, int)</code> except
      * that the dictionary may be initialized using a preset dictionary.
      * If a preset dictionary was used when compressing the data, the
      * same preset dictionary must be provided when decompressing.
@@ -174,7 +175,7 @@
      * <p>
      * If <code>len</code> is zero, no bytes are read and <code>0</code>
      * is returned. Otherwise this will block until <code>len</code>
-     * bytes have been decompressed, the end of LZMA2 stream is reached,
+     * bytes have been decompressed, the end of the LZMA2 stream is reached,
      * or an exception is thrown.
      *
      * @param       buf         target buffer for uncompressed data
@@ -226,6 +227,8 @@
                 } else {
                     lz.setLimit(copySizeMax);
                     lzma.decode();
+                    if (!rc.isInBufferOK())
+                        throw new CorruptedInputException();
                 }
 
                 int copiedSize = lz.flush(buf, off);
@@ -318,7 +321,7 @@
      * thrown before the number of bytes claimed to be available have
      * been read from this input stream.
      * <p>
-     * In LZMAInputStream, the return value will be non-zero when the
+     * In LZMA2InputStream, the return value will be non-zero when the
      * decompressor is in the middle of an LZMA2 chunk. The return value
      * will then be the number of uncompressed bytes remaining from that
      * chunk.
diff -Nru xz-java-1.3/src/org/tukaani/xz/LZMAInputStream.java xz-java-1.4/src/org/tukaani/xz/LZMAInputStream.java
--- xz-java-1.3/src/org/tukaani/xz/LZMAInputStream.java	1970-01-01 00:00:00.000000000 +0000
+++ xz-java-1.4/src/org/tukaani/xz/LZMAInputStream.java	2013-09-22 10:39:20.000000000 +0000
@@ -0,0 +1,568 @@
+/*
+ * LZMAInputStream
+ *
+ * Authors: Lasse Collin <lasse.collin@tukaani.org>
+ *          Igor Pavlov <http://7-zip.org/>
+ *
+ * This file has been put into the public domain.
+ * You can do whatever you want with this file.
+ */
+
+package org.tukaani.xz;
+
+import java.io.InputStream;
+import java.io.DataInputStream;
+import java.io.IOException;
+import org.tukaani.xz.lz.LZDecoder;
+import org.tukaani.xz.rangecoder.RangeDecoderFromStream;
+import org.tukaani.xz.lzma.LZMADecoder;
+
+/**
+ * Decompresses legacy .lzma files and raw LZMA streams (no .lzma header).
+ * <p>
+ * <b>IMPORTANT:</b> In contrast to other classes in this package, this class
+ * reads data from its input stream one byte at a time. If the input stream
+ * is for example {@link java.io.FileInputStream}, wrapping it into
+ * {@link java.io.BufferedInputStream} tends to improve performance a lot.
+ * This is not automatically done by this class because there may be use
+ * cases where it is desired that this class won't read any bytes past
+ * the end of the LZMA stream.
+ * <p>
+ * Even when using <code>BufferedInputStream</code>, the performance tends
+ * to be worse (maybe 10-20&nbsp;% slower) than with {@link LZMA2InputStream}
+ * or {@link XZInputStream} (when the .xz file contains LZMA2-compressed data).
+ *
+ * @since 1.4
+ */
+public class LZMAInputStream extends InputStream {
+    /**
+     * Largest dictionary size supported by this implementation.
+     * <p>
+     * LZMA allows dictionaries up to one byte less than 4 GiB. This
+     * implementation supports only 16 bytes less than 2 GiB. This
+     * limitation is due to Java using signed 32-bit integers for array
+     * indexing. The limitation shouldn't matter much in practice since so
+     * huge dictionaries are not normally used.
+     */
+    public static final int DICT_SIZE_MAX = Integer.MAX_VALUE & ~15;
+
+    private InputStream in;
+    private LZDecoder lz;
+    private RangeDecoderFromStream rc;
+    private LZMADecoder lzma;
+
+    private boolean endReached = false;
+
+    /**
+     * Number of uncompressed bytes left to be decompressed, or -1 if
+     * the end marker is used.
+     */
+    private long remainingSize;
+
+    private IOException exception = null;
+
+    /**
+     * Gets approximate decompressor memory requirements as kibibytes for
+     * the given dictionary size and LZMA properties byte (lc, lp, and pb).
+     *
+     * @param       dictSize    LZMA dictionary size as bytes, should be
+     *                          in the range [<code>0</code>,
+     *                          <code>DICT_SIZE_MAX</code>]
+     *
+     * @param       propsByte   LZMA properties byte that encodes the values
+     *                          of lc, lp, and pb
+     *
+     * @return      approximate memory requirements as kibibytes (KiB)
+     *
+     * @throws      UnsupportedOptionsException
+     *                          if <code>dictSize</code> is outside
+     *                          the range [<code>0</code>,
+     *                          <code>DICT_SIZE_MAX</code>]
+     *
+     * @throws      CorruptedInputException
+     *                          if <code>propsByte</code> is invalid
+     */
+    public static int getMemoryUsage(int dictSize, byte propsByte)
+            throws UnsupportedOptionsException, CorruptedInputException {
+        if (dictSize < 0 || dictSize > DICT_SIZE_MAX)
+            throw new UnsupportedOptionsException(
+                    "LZMA dictionary is too big for this implementation");
+
+        int props = propsByte & 0xFF;
+        if (props > (4 * 5 + 4) * 9 + 8)
+            throw new CorruptedInputException("Invalid LZMA properties byte");
+
+        props %= 9 * 5;
+        int lp = props / 9;
+        int lc = props - lp * 9;
+
+        return getMemoryUsage(dictSize, lc, lp);
+    }
+
+    /**
+     * Gets approximate decompressor memory requirements as kibibytes for
+     * the given dictionary size, lc, and lp. Note that pb isn't needed.
+     *
+     * @param       dictSize    LZMA dictionary size as bytes, must be
+     *                          in the range [<code>0</code>,
+     *                          <code>DICT_SIZE_MAX</code>]
+     *
+     * @param       lc          number of literal context bits, must be
+     *                          in the range [0, 8]
+     *
+     * @param       lp          number of literal position bits, must be
+     *                          in the range [0, 4]
+     *
+     * @return      approximate memory requirements as kibibytes (KiB)
+     */
+    public static int getMemoryUsage(int dictSize, int lc, int lp) {
+        if (lc < 0 || lc > 8 || lp < 0 || lp > 4)
+            throw new IllegalArgumentException("Invalid lc or lp");
+
+        // Probability variables have the type "short". There are
+        // 0x300 (768) probability variables in each literal subcoder.
+        // The number of literal subcoders is 2^(lc + lp).
+        //
+        // Roughly 10 KiB for the base state + LZ decoder's dictionary buffer
+        // + sizeof(short) * number probability variables per literal subcoder
+        //   * number of literal subcoders
+        return 10 + getDictSize(dictSize) / 1024
+               + ((2 * 0x300) << (lc + lp)) / 1024;
+    }
+
+    private static int getDictSize(int dictSize) {
+        if (dictSize < 0 || dictSize > DICT_SIZE_MAX)
+            throw new IllegalArgumentException(
+                    "LZMA dictionary is too big for this implementation");
+
+        // For performance reasons, use a 4 KiB dictionary if something
+        // smaller was requested. It's a rare situation and the performance
+        // difference isn't huge, and it starts to matter mostly when the
+        // dictionary is just a few bytes. But we need to handle the special
+        // case of dictSize == 0 anyway, which is an allowed value but in
+        // practice means one-byte dictionary.
+        //
+        // Note that using a dictionary bigger than specified in the headers
+        // can hide errors if there is a reference to data beyond the original
+        // dictionary size but is still within 4 KiB.
+        if (dictSize < 4096)
+            dictSize = 4096;
+
+        // Round dictionary size upward to a multiple of 16. This way LZMA
+        // can use LZDecoder.getPos() for calculating LZMA's posMask.
+        return (dictSize + 15) & ~15;
+    }
+
+    /**
+     * Creates a new .lzma file format decompressor without
+     * a memory usage limit.
+     *
+     * @param       in          input stream from which .lzma data is read;
+     *                          it might be a good idea to wrap it in
+     *                          <code>BufferedInputStream</code>, see the
+     *                          note at the top of this page
+     *
+     * @throws      CorruptedInputException
+     *                          file is corrupt or perhaps not in
+     *                          the .lzma format at all
+     *
+     * @throws      UnsupportedOptionsException
+     *                          dictionary size or uncompressed size is too
+     *                          big for this implementation
+     *
+     * @throws      EOFException
+     *                          file is truncated or perhaps not in
+     *                          the .lzma format at all
+     *
+     * @throws      IOException may be thrown by <code>in</code>
+     */
+    public LZMAInputStream(InputStream in) throws IOException {
+        this(in, -1);
+    }
+
+    /**
+     * Creates a new .lzma file format decompressor with an optional
+     * memory usage limit.
+     *
+     * @param       in          input stream from which .lzma data is read;
+     *                          it might be a good idea to wrap it in
+     *                          <code>BufferedInputStream</code>, see the
+     *                          note at the top of this page
+     *
+     * @param       memoryLimit memory usage limit in kibibytes (KiB)
+     *                          or <code>-1</code> to impose no
+     *                          memory usage limit
+     *
+     * @throws      CorruptedInputException
+     *                          file is corrupt or perhaps not in
+     *                          the .lzma format at all
+     *
+     * @throws      UnsupportedOptionsException
+     *                          dictionary size or uncompressed size is too
+     *                          big for this implementation
+     *
+     * @throws      MemoryLimitException
+     *                          memory usage limit was exceeded
+     *
+     * @throws      EOFException
+     *                          file is truncated or perhaps not in
+     *                          the .lzma format at all
+     *
+     * @throws      IOException may be thrown by <code>in</code>
+     */
+    public LZMAInputStream(InputStream in, int memoryLimit)
+            throws IOException {
+        DataInputStream inData = new DataInputStream(in);
+
+        // Properties byte (lc, lp, and pb)
+        byte propsByte = inData.readByte();
+
+        // Dictionary size is an unsigned 32-bit little endian integer.
+        int dictSize = 0;
+        for (int i = 0; i < 4; ++i)
+            dictSize |= inData.readUnsignedByte() << (8 * i);
+
+        // Uncompressed size is an unsigned 64-bit little endian integer.
+        // The maximum 64-bit value is a special case (becomes -1 here)
+        // which indicates that the end marker is used instead of knowing
+        // the uncompressed size beforehand.
+        long uncompSize = 0;
+        for (int i = 0; i < 8; ++i)
+            uncompSize |= (long)inData.readUnsignedByte() << (8 * i);
+
+        // Check the memory usage limit.
+        int memoryNeeded = getMemoryUsage(dictSize, propsByte);
+        if (memoryLimit != -1 && memoryNeeded > memoryLimit)
+            throw new MemoryLimitException(memoryNeeded, memoryLimit);
+
+        initialize(in, uncompSize, propsByte, dictSize, null);
+    }
+
+    /**
+     * Creates a new input stream that decompresses raw LZMA data (no .lzma
+     * header) from <code>in</code>.
+     * <p>
+     * The caller needs to know if the "end of payload marker (EOPM)" alias
+     * "end of stream marker (EOS marker)" alias "end marker" present.
+     * If the end marker isn't used, the caller must know the exact
+     * uncompressed size of the stream.
+     * <p>
+     * The caller also needs to provide the LZMA properties byte that encodes
+     * the number of literal context bits (lc), literal position bits (lp),
+     * and position bits (pb).
+     * <p>
+     * The dictionary size used when compressing is also needed. Specifying
+     * a too small dictionary size will prevent decompressing the stream.
+     * Specifying a too big dictionary is waste of memory but decompression
+     * will work.
+     * <p>
+     * There is no need to specify a dictionary bigger than
+     * the uncompressed size of the data even if a bigger dictionary
+     * was used when compressing. If you know the uncompressed size
+     * of the data, this might allow saving some memory.
+     *
+     * @param       in          input stream from which compressed
+     *                          data is read
+     *
+     * @param       uncompSize  uncompressed size of the LZMA stream or -1
+     *                          if the end marker is used in the LZMA stream
+     *
+     * @param       propsByte   LZMA properties byte that has the encoded
+     *                          values for literal context bits (lc), literal
+     *                          position bits (lp), and position bits (pb)
+     *
+     * @param       dictSize    dictionary size as bytes, must be in the range
+     *                          [<code>0</code>, <code>DICT_SIZE_MAX</code>]
+     *
+     * @throws      CorruptedInputException
+     *                          if <code>propsByte</code> is invalid or
+     *                          the first input byte is not 0x00
+     *
+     * @throws      UnsupportedOptionsException
+     *                          dictionary size or uncompressed size is too
+     *                          big for this implementation
+     *
+     *
+     */
+    public LZMAInputStream(InputStream in, long uncompSize, byte propsByte,
+                           int dictSize) throws IOException {
+        initialize(in, uncompSize, propsByte, dictSize, null);
+    }
+
+    /**
+     * Creates a new input stream that decompresses raw LZMA data (no .lzma
+     * header) from <code>in</code> optionally with a preset dictionary.
+     *
+     * @param       in          input stream from which LZMA-compressed
+     *                          data is read
+     *
+     * @param       uncompSize  uncompressed size of the LZMA stream or -1
+     *                          if the end marker is used in the LZMA stream
+     *
+     * @param       propsByte   LZMA properties byte that has the encoded
+     *                          values for literal context bits (lc), literal
+     *                          position bits (lp), and position bits (pb)
+     *
+     * @param       dictSize    dictionary size as bytes, must be in the range
+     *                          [<code>0</code>, <code>DICT_SIZE_MAX</code>]
+     *
+     * @param       presetDict  preset dictionary or <code>null</code>
+     *                          to use no preset dictionary
+     *
+     * @throws      CorruptedInputException
+     *                          if <code>propsByte</code> is invalid or
+     *                          the first input byte is not 0x00
+     *
+     * @throws      UnsupportedOptionsException
+     *                          dictionary size or uncompressed size is too
+     *                          big for this implementation
+     *
+     * @throws      EOFException file is truncated or corrupt
+     *
+     * @throws      IOException may be thrown by <code>in</code>
+     */
+    public LZMAInputStream(InputStream in, long uncompSize, byte propsByte,
+                           int dictSize, byte[] presetDict)
+            throws IOException {
+        initialize(in, uncompSize, propsByte, dictSize, presetDict);
+    }
+
+    /**
+     * Creates a new input stream that decompresses raw LZMA data (no .lzma
+     * header) from <code>in</code> optionally with a preset dictionary.
+     *
+     * @param       in          input stream from which LZMA-compressed
+     *                          data is read
+     *
+     * @param       uncompSize  uncompressed size of the LZMA stream or -1
+     *                          if the end marker is used in the LZMA stream
+     *
+     * @param       lc          number of literal context bits, must be
+     *                          in the range [0, 8]
+     *
+     * @param       lp          number of literal position bits, must be
+     *                          in the range [0, 4]
+     *
+     * @param       pb          number position bits, must be
+     *                          in the range [0, 4]
+     *
+     * @param       dictSize    dictionary size as bytes, must be in the range
+     *                          [<code>0</code>, <code>DICT_SIZE_MAX</code>]
+     *
+     * @param       presetDict  preset dictionary or <code>null</code>
+     *                          to use no preset dictionary
+     *
+     * @throws      CorruptedInputException
+     *                          if the first input byte is not 0x00
+     *
+     * @throws      EOFException file is truncated or corrupt
+     *
+     * @throws      IOException may be thrown by <code>in</code>
+     */
+    public LZMAInputStream(InputStream in, long uncompSize,
+                           int lc, int lp, int pb,
+                           int dictSize, byte[] presetDict)
+            throws IOException {
+        initialize(in, uncompSize, lc, lp, pb, dictSize, presetDict);
+    }
+
+    private void initialize(InputStream in, long uncompSize, byte propsByte,
+                            int dictSize, byte[] presetDict)
+            throws IOException {
+        // Validate the uncompressed size since the other "initialize" throws
+        // IllegalArgumentException if uncompSize < -1.
+        if (uncompSize < -1)
+            throw new UnsupportedOptionsException(
+                    "Uncompressed size is too big");
+
+        // Decode the properties byte. In contrast to LZMA2, there is no
+        // limit of lc + lp <= 4.
+        int props = propsByte & 0xFF;
+        if (props > (4 * 5 + 4) * 9 + 8)
+            throw new CorruptedInputException("Invalid LZMA properties byte");
+
+        int pb = props / (9 * 5);
+        props -= pb * 9 * 5;
+        int lp = props / 9;
+        int lc = props - lp * 9;
+
+        // Validate the dictionary size since the other "initialize" throws
+        // IllegalArgumentException if dictSize is not supported.
+        if (dictSize < 0 || dictSize > DICT_SIZE_MAX)
+            throw new UnsupportedOptionsException(
+                    "LZMA dictionary is too big for this implementation");
+
+        initialize(in, uncompSize, lc, lp, pb, dictSize, presetDict);
+    }
+
+    private void initialize(InputStream in, long uncompSize,
+                            int lc, int lp, int pb,
+                            int dictSize, byte[] presetDict)
+            throws IOException {
+        // getDictSize validates dictSize and gives a message in
+        // the exception too, so skip validating dictSize here.
+        if (uncompSize < -1 || lc < 0 || lc > 8 || lp < 0 || lp > 4
+                || pb < 0 || pb > 4)
+            throw new IllegalArgumentException();
+
+        this.in = in;
+
+        // If uncompressed size is known, use it to avoid wasting memory for
+        // a uselessly large dictionary buffer.
+        dictSize = getDictSize(dictSize);
+        if (uncompSize >= 0 && dictSize > uncompSize)
+            dictSize = getDictSize((int)uncompSize);
+
+        lz = new LZDecoder(getDictSize(dictSize), presetDict);
+        rc = new RangeDecoderFromStream(in);
+        lzma = new LZMADecoder(lz, rc, lc, lp, pb);
+        remainingSize = uncompSize;
+    }
+
+    /**
+     * Decompresses the next byte from this input stream.
+     * <p>
+     * Reading lots of data with <code>read()</code> from this input stream
+     * may be inefficient. Wrap it in <code>java.io.BufferedInputStream</code>
+     * if you need to read lots of data one byte at a time.
+     *
+     * @return      the next decompressed byte, or <code>-1</code>
+     *              to indicate the end of the compressed stream
+     *
+     * @throws      CorruptedInputException
+     *
+     * @throws      XZIOException if the stream has been closed
+     *
+     * @throws      EOFException
+     *                          compressed input is truncated or corrupt
+     *
+     * @throws      IOException may be thrown by <code>in</code>
+     */
+    public int read() throws IOException {
+        byte[] buf = new byte[1];
+        return read(buf, 0, 1) == -1 ? -1 : (buf[0] & 0xFF);
+    }
+
+    /**
+     * Decompresses into an array of bytes.
+     * <p>
+     * If <code>len</code> is zero, no bytes are read and <code>0</code>
+     * is returned. Otherwise this will block until <code>len</code>
+     * bytes have been decompressed, the end of the LZMA stream is reached,
+     * or an exception is thrown.
+     *
+     * @param       buf         target buffer for uncompressed data
+     * @param       off         start offset in <code>buf</code>
+     * @param       len         maximum number of uncompressed bytes to read
+     *
+     * @return      number of bytes read, or <code>-1</code> to indicate
+     *              the end of the compressed stream
+     *
+     * @throws      CorruptedInputException
+     *
+     * @throws      XZIOException if the stream has been closed
+     *
+     * @throws      EOFException compressed input is truncated or corrupt
+     *
+     * @throws      IOException may be thrown by <code>in</code>
+     */
+    public int read(byte[] buf, int off, int len) throws IOException {
+        if (off < 0 || len < 0 || off + len < 0 || off + len > buf.length)
+            throw new IndexOutOfBoundsException();
+
+        if (len == 0)
+            return 0;
+
+        if (in == null)
+            throw new XZIOException("Stream closed");
+
+        if (exception != null)
+            throw exception;
+
+        if (endReached)
+            return -1;
+
+        try {
+            int size = 0;
+
+            while (len > 0) {
+                // If uncompressed size is known and thus no end marker will
+                // be present, set the limit so that the uncompressed size
+                // won't be exceeded.
+                int copySizeMax = len;
+                if (remainingSize >= 0 && remainingSize < len)
+                    copySizeMax = (int)remainingSize;
+
+                lz.setLimit(copySizeMax);
+
+                // Decode into the dictionary buffer.
+                try {
+                    lzma.decode();
+                } catch (CorruptedInputException e) {
+                    // The end marker is encoded with a LZMA symbol that
+                    // indicates maximum match distance. This is larger
+                    // than any supported dictionary and thus causes
+                    // CorruptedInputException from LZDecoder.repeat.
+                    if (remainingSize != -1 || !lzma.endMarkerDetected())
+                        throw e;
+
+                    endReached = true;
+
+                    // The exception makes lzma.decode() miss the last range
+                    // decoder normalization, so do it here. This might
+                    // cause an IOException if it needs to read a byte
+                    // from the input stream.
+                    rc.normalize();
+                }
+
+                // Copy from the dictionary to buf.
+                int copiedSize = lz.flush(buf, off);
+                off += copiedSize;
+                len -= copiedSize;
+                size += copiedSize;
+
+                if (remainingSize >= 0) {
+                    // Update the number of bytes left to be decompressed.
+                    remainingSize -= copiedSize;
+                    assert remainingSize >= 0;
+
+                    if (remainingSize == 0)
+                        endReached = true;
+                }
+
+                if (endReached) {
+                    // Checking these helps a lot when catching corrupt
+                    // or truncated .lzma files. LZMA Utils doesn't do
+                    // the first check and thus it accepts many invalid
+                    // files that this implementation and XZ Utils don't.
+                    if (!rc.isFinished() || lz.hasPending())
+                        throw new CorruptedInputException();
+
+                    return size == 0 ? -1 : size;
+                }
+            }
+
+            return size;
+
+        } catch (IOException e) {
+            exception = e;
+            throw e;
+        }
+    }
+
+    /**
+     * Closes the stream and calls <code>in.close()</code>.
+     * If the stream was already closed, this does nothing.
+     *
+     * @throws  IOException if thrown by <code>in.close()</code>
+     */
+    public void close() throws IOException {
+        if (in != null) {
+            try {
+                in.close();
+            } finally {
+                in = null;
+            }
+        }
+    }
+}
diff -Nru xz-java-1.3/src/org/tukaani/xz/lzma/LZMADecoder.java xz-java-1.4/src/org/tukaani/xz/lzma/LZMADecoder.java
--- xz-java-1.3/src/org/tukaani/xz/lzma/LZMADecoder.java	2013-04-14 08:36:20.000000000 +0000
+++ xz-java-1.4/src/org/tukaani/xz/lzma/LZMADecoder.java	2013-09-22 10:39:20.000000000 +0000
@@ -13,7 +13,6 @@
 import java.io.IOException;
 import org.tukaani.xz.lz.LZDecoder;
 import org.tukaani.xz.rangecoder.RangeDecoder;
-import org.tukaani.xz.CorruptedInputException;
 
 public final class LZMADecoder extends LZMACoder {
     private final LZDecoder lz;
@@ -37,6 +36,16 @@
         repLenDecoder.reset();
     }
 
+    /**
+     * Returns true if LZMA end marker was detected. It is encoded as
+     * the maximum match distance which with signed ints becomes -1. This
+     * function is needed only for LZMA1. LZMA2 doesn't use the end marker
+     * in the LZMA layer.
+     */
+    public boolean endMarkerDetected() {
+        return reps[0] == -1;
+    }
+
     public void decode() throws IOException {
         lz.repeatPending();
 
@@ -49,14 +58,15 @@
                 int len = rc.decodeBit(isRep, state.get()) == 0
                           ? decodeMatch(posState)
                           : decodeRepMatch(posState);
+
+                // NOTE: With LZMA1 streams that have the end marker,
+                // this will throw CorruptedInputException. LZMAInputStream
+                // handles it specially.
                 lz.repeat(reps[0], len);
             }
         }
 
         rc.normalize();
-
-        if (!rc.isInBufferOK())
-            throw new CorruptedInputException();
     }
 
     private int decodeMatch(int posState) throws IOException {
diff -Nru xz-java-1.3/src/org/tukaani/xz/rangecoder/RangeDecoder.java xz-java-1.4/src/org/tukaani/xz/rangecoder/RangeDecoder.java
--- xz-java-1.3/src/org/tukaani/xz/rangecoder/RangeDecoder.java	2013-04-14 08:36:20.000000000 +0000
+++ xz-java-1.4/src/org/tukaani/xz/rangecoder/RangeDecoder.java	2013-09-22 10:39:20.000000000 +0000
@@ -12,58 +12,12 @@
 
 import java.io.DataInputStream;
 import java.io.IOException;
-import org.tukaani.xz.CorruptedInputException;
 
-public final class RangeDecoder extends RangeCoder {
-    private static final int INIT_SIZE = 5;
+public abstract class RangeDecoder extends RangeCoder {
+    int range = 0;
+    int code = 0;
 
-    private final byte[] buf;
-    private int pos = 0;
-    private int end = 0;
-
-    private int range = 0;
-    private int code = 0;
-
-    public RangeDecoder(int inputSizeMax) {
-        buf = new byte[inputSizeMax - INIT_SIZE];
-    }
-
-    public void prepareInputBuffer(DataInputStream in, int len)
-            throws IOException {
-        if (len < INIT_SIZE)
-            throw new CorruptedInputException();
-
-        if (in.readUnsignedByte() != 0x00)
-            throw new CorruptedInputException();
-
-        code = in.readInt();
-        range = 0xFFFFFFFF;
-
-        pos = 0;
-        end = len - INIT_SIZE;
-        in.readFully(buf, 0, end);
-    }
-
-    public boolean isInBufferOK() {
-        return pos <= end;
-    }
-
-    public boolean isFinished() {
-        return pos == end && code == 0;
-    }
-
-    public void normalize() throws IOException {
-        if ((range & TOP_MASK) == 0) {
-            try {
-                // If the input is corrupt, this might throw
-                // ArrayIndexOutOfBoundsException.
-                code = (code << SHIFT_BITS) | (buf[pos++] & 0xFF);
-                range <<= SHIFT_BITS;
-            } catch (ArrayIndexOutOfBoundsException e) {
-                throw new CorruptedInputException();
-            }
-        }
-    }
+    public abstract void normalize() throws IOException;
 
     public int decodeBit(short[] probs, int index) throws IOException {
         normalize();
diff -Nru xz-java-1.3/src/org/tukaani/xz/rangecoder/RangeDecoderFromBuffer.java xz-java-1.4/src/org/tukaani/xz/rangecoder/RangeDecoderFromBuffer.java
--- xz-java-1.3/src/org/tukaani/xz/rangecoder/RangeDecoderFromBuffer.java	1970-01-01 00:00:00.000000000 +0000
+++ xz-java-1.4/src/org/tukaani/xz/rangecoder/RangeDecoderFromBuffer.java	2013-09-22 10:39:20.000000000 +0000
@@ -0,0 +1,64 @@
+/*
+ * RangeDecoderFromBuffer
+ *
+ * Authors: Lasse Collin <lasse.collin@tukaani.org>
+ *          Igor Pavlov <http://7-zip.org/>
+ *
+ * This file has been put into the public domain.
+ * You can do whatever you want with this file.
+ */
+
+package org.tukaani.xz.rangecoder;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import org.tukaani.xz.CorruptedInputException;
+
+public final class RangeDecoderFromBuffer extends RangeDecoder {
+    private static final int INIT_SIZE = 5;
+
+    private final byte[] buf;
+    private int pos = 0;
+    private int end = 0;
+
+    public RangeDecoderFromBuffer(int inputSizeMax) {
+        buf = new byte[inputSizeMax - INIT_SIZE];
+    }
+
+    public void prepareInputBuffer(DataInputStream in, int len)
+            throws IOException {
+        if (len < INIT_SIZE)
+            throw new CorruptedInputException();
+
+        if (in.readUnsignedByte() != 0x00)
+            throw new CorruptedInputException();
+
+        code = in.readInt();
+        range = 0xFFFFFFFF;
+
+        pos = 0;
+        end = len - INIT_SIZE;
+        in.readFully(buf, 0, end);
+    }
+
+    public boolean isInBufferOK() {
+        return pos <= end;
+    }
+
+    public boolean isFinished() {
+        return pos == end && code == 0;
+    }
+
+    public void normalize() throws IOException {
+        if ((range & TOP_MASK) == 0) {
+            try {
+                // If the input is corrupt, this might throw
+                // ArrayIndexOutOfBoundsException.
+                code = (code << SHIFT_BITS) | (buf[pos++] & 0xFF);
+                range <<= SHIFT_BITS;
+            } catch (ArrayIndexOutOfBoundsException e) {
+                throw new CorruptedInputException();
+            }
+        }
+    }
+}
diff -Nru xz-java-1.3/src/org/tukaani/xz/rangecoder/RangeDecoderFromStream.java xz-java-1.4/src/org/tukaani/xz/rangecoder/RangeDecoderFromStream.java
--- xz-java-1.3/src/org/tukaani/xz/rangecoder/RangeDecoderFromStream.java	1970-01-01 00:00:00.000000000 +0000
+++ xz-java-1.4/src/org/tukaani/xz/rangecoder/RangeDecoderFromStream.java	2013-09-22 10:39:20.000000000 +0000
@@ -0,0 +1,41 @@
+/*
+ * RangeDecoderFromStream
+ *
+ * Authors: Lasse Collin <lasse.collin@tukaani.org>
+ *          Igor Pavlov <http://7-zip.org/>
+ *
+ * This file has been put into the public domain.
+ * You can do whatever you want with this file.
+ */
+
+package org.tukaani.xz.rangecoder;
+
+import java.io.InputStream;
+import java.io.DataInputStream;
+import java.io.IOException;
+import org.tukaani.xz.CorruptedInputException;
+
+public final class RangeDecoderFromStream extends RangeDecoder {
+    private final DataInputStream inData;
+
+    public RangeDecoderFromStream(InputStream in) throws IOException {
+        inData = new DataInputStream(in);
+
+        if (inData.readUnsignedByte() != 0x00)
+            throw new CorruptedInputException();
+
+        code = inData.readInt();
+        range = 0xFFFFFFFF;
+    }
+
+    public boolean isFinished() {
+        return code == 0;
+    }
+
+    public void normalize() throws IOException {
+        if ((range & TOP_MASK) == 0) {
+            code = (code << SHIFT_BITS) | inData.readUnsignedByte();
+            range <<= SHIFT_BITS;
+        }
+    }
+}