import org.tukaani.xz.check.Check; //导入依赖的package包/类
SingleXZInputStream(InputStream in, int memoryLimit, boolean verifyCheck,
                    byte[] streamHeader) throws IOException {
    this.in = in;
    this.memoryLimit = memoryLimit;
    this.verifyCheck = verifyCheck;
    streamHeaderFlags = DecoderUtil.decodeStreamHeader(streamHeader);
    check = Check.getInstance(streamHeaderFlags.checkType);
}
 

import org.tukaani.xz.check.Check; //导入依赖的package包/类
private void initialize(InputStream in, int memoryLimit,
                        byte[] streamHeader) throws IOException {
    this.in = in;
    this.memoryLimit = memoryLimit;
    streamHeaderFlags = DecoderUtil.decodeStreamHeader(streamHeader);
    check = Check.getInstance(streamHeaderFlags.checkType);
}
 

import org.tukaani.xz.check.Check; //导入依赖的package包/类
private void initialize(InputStream in, int memoryLimit, byte[] streamHeader)
		throws IOException {
	this.in = in;
	this.memoryLimit = memoryLimit;
	streamHeaderFlags = DecoderUtil.decodeStreamHeader(streamHeader);
	check = Check.getInstance(streamHeaderFlags.checkType);
}
 

import org.tukaani.xz.check.Check; //导入依赖的package包/类
/**
 * Does the actual seeking. This is also called when <code>read</code>
 * needs a new Block to decode.
 */
private void seek() throws IOException {
    // If seek(long) wasn't called, we simply need to get the next Block
    // from the same Stream. If there are no more Blocks in this Stream,
    // then we behave as if seek(long) had been called.
    if (!seekNeeded) {
        if (curBlockInfo.hasNext()) {
            curBlockInfo.setNext();
            initBlockDecoder();
            return;
        }

        seekPos = curPos;
    }

    seekNeeded = false;

    // Check if we are seeking to or past the end of the file.
    if (seekPos >= uncompressedSize) {
        curPos = seekPos;
        blockDecoder = null;
        endReached = true;
        return;
    }

    endReached = false;

    // Locate the Block that contains the uncompressed target position.
    locateBlockByPos(curBlockInfo, seekPos);

    // Seek in the underlying stream and create a new Block decoder
    // only if really needed. We can skip it if the current position
    // is already in the correct Block and the target position hasn't
    // been decompressed yet.
    //
    // NOTE: If curPos points to the beginning of this Block, it's
    // because it was left there after decompressing an earlier Block.
    // In that case, decoding of the current Block hasn't been started
    // yet. (Decoding of a Block won't be started until at least one
    // byte will also be read from it.)
    if (!(curPos > curBlockInfo.uncompressedOffset && curPos <= seekPos)) {
        // Seek to the beginning of the Block.
        in.seek(curBlockInfo.compressedOffset);

        // Since it is possible that this Block is from a different
        // Stream than the previous Block, initialize a new Check.
        check = Check.getInstance(curBlockInfo.getCheckType());

        // Create a new Block decoder.
        initBlockDecoder();
        curPos = curBlockInfo.uncompressedOffset;
    }

    // If the target wasn't at a Block boundary, decompress and throw
    // away data to reach the target position.
    if (seekPos > curPos) {
        // NOTE: The "if" below is there just in case. In this situation,
        // blockDecoder.skip will always skip the requested amount
        // or throw an exception.
        long skipAmount = seekPos - curPos;
        if (blockDecoder.skip(skipAmount) != skipAmount)
            throw new CorruptedInputException();

        curPos = seekPos;
    }
}
 

import org.tukaani.xz.check.Check; //导入依赖的package包/类
public BlockOutputStream(OutputStream out, FilterEncoder[] filters,
                         Check check) throws IOException {
    this.out = out;
    this.check = check;

    // Initialize the filter chain.
    outCounted = new CountingOutputStream(out);
    filterChain = outCounted;
    for (int i = filters.length - 1; i >= 0; --i)
        filterChain = filters[i].getOutputStream(filterChain);

    // Prepare to encode the Block Header field.
    ByteArrayOutputStream bufStream = new ByteArrayOutputStream();

    // Write a dummy Block Header Size field. The real value is written
    // once everything else except CRC32 has been written.
    bufStream.write(0x00);

    // Write Block Flags. Storing Compressed Size or Uncompressed Size
    // isn't supported for now.
    bufStream.write(filters.length - 1);

    // List of Filter Flags
    for (int i = 0; i < filters.length; ++i) {
        EncoderUtil.encodeVLI(bufStream, filters[i].getFilterID());
        byte[] filterProps = filters[i].getFilterProps();
        EncoderUtil.encodeVLI(bufStream, filterProps.length);
        bufStream.write(filterProps);
    }

    // Header Padding
    while ((bufStream.size() & 3) != 0)
        bufStream.write(0x00);

    byte[] buf = bufStream.toByteArray();

    // Total size of the Block Header: Take the size of the CRC32 field
    // into account.
    headerSize = buf.length + 4;

    // This is just a sanity check.
    if (headerSize > EncoderUtil.BLOCK_HEADER_SIZE_MAX)
        throw new UnsupportedOptionsException();

    // Block Header Size
    buf[0] = (byte)(buf.length / 4);

    // Write the Block Header field to the output stream.
    out.write(buf);
    EncoderUtil.writeCRC32(out, buf);

    // Calculate the maximum allowed size of the Compressed Data field.
    // It is hard to exceed it so this is mostly to be pedantic.
    compressedSizeLimit = (EncoderUtil.VLI_MAX & ~3)
                          - headerSize - check.getSize();
}
 

import org.tukaani.xz.check.Check; //导入依赖的package包/类
/**
 * Does the actual seeking. This is also called when <code>read</code> needs
 * a new Block to decode.
 */
private void seek() throws IOException {
	// If seek(long) wasn't called, we simply need to get the next Block
	// from the same Stream. If there are no more Blocks in this Stream,
	// then we behave as if seek(long) had been called.
	if (!seekNeeded) {
		if (curBlockInfo.hasNext()) {
			curBlockInfo.setNext();
			initBlockDecoder();
			return;
		}

		seekPos = curPos;
	}

	seekNeeded = false;

	// Check if we are seeking to or past the end of the file.
	if (seekPos >= uncompressedSize) {
		curPos = seekPos;
		blockDecoder = null;
		endReached = true;
		return;
	}

	endReached = false;

	// Locate the Block that contains the uncompressed target position.
	locateBlockByPos(curBlockInfo, seekPos);

	// Seek in the underlying stream and create a new Block decoder
	// only if really needed. We can skip it if the current position
	// is already in the correct Block and the target position hasn't
	// been decompressed yet.
	//
	// NOTE: If curPos points to the beginning of this Block, it's
	// because it was left there after decompressing an earlier Block.
	// In that case, decoding of the current Block hasn't been started
	// yet. (Decoding of a Block won't be started until at least one
	// byte will also be read from it.)
	if (!(curPos > curBlockInfo.uncompressedOffset && curPos <= seekPos)) {
		// Seek to the beginning of the Block.
		in.seek(curBlockInfo.compressedOffset);

		// Since it is possible that this Block is from a different
		// Stream than the previous Block, initialize a new Check.
		check = Check.getInstance(curBlockInfo.getCheckType());

		// Create a new Block decoder.
		initBlockDecoder();
		curPos = curBlockInfo.uncompressedOffset;
	}

	// If the target wasn't at a Block boundary, decompress and throw
	// away data to reach the target position.
	if (seekPos > curPos) {
		// NOTE: The "if" below is there just in case. In this situation,
		// blockDecoder.skip will always skip the requested amount
		// or throw an exception.
		long skipAmount = seekPos - curPos;
		if (blockDecoder.skip(skipAmount) != skipAmount)
			throw new CorruptedInputException();

		curPos = seekPos;
	}
}
 

import org.tukaani.xz.check.Check; //导入依赖的package包/类
public BlockOutputStream(OutputStream out, FilterEncoder[] filters,
		Check check) throws IOException {
	this.out = out;
	this.check = check;

	// Initialize the filter chain.
	outCounted = new CountingOutputStream(out);
	filterChain = outCounted;
	for (int i = filters.length - 1; i >= 0; --i)
		filterChain = filters[i].getOutputStream(filterChain);

	// Prepare to encode the Block Header field.
	ByteArrayOutputStream bufStream = new ByteArrayOutputStream();

	// Write a dummy Block Header Size field. The real value is written
	// once everything else except CRC32 has been written.
	bufStream.write(0x00);

	// Write Block Flags. Storing Compressed Size or Uncompressed Size
	// isn't supported for now.
	bufStream.write(filters.length - 1);

	// List of Filter Flags
	for (int i = 0; i < filters.length; ++i) {
		EncoderUtil.encodeVLI(bufStream, filters[i].getFilterID());
		byte[] filterProps = filters[i].getFilterProps();
		EncoderUtil.encodeVLI(bufStream, filterProps.length);
		bufStream.write(filterProps);
	}

	// Header Padding
	while ((bufStream.size() & 3) != 0)
		bufStream.write(0x00);

	byte[] buf = bufStream.toByteArray();

	// Total size of the Block Header: Take the size of the CRC32 field
	// into account.
	headerSize = buf.length + 4;

	// This is just a sanity check.
	if (headerSize > EncoderUtil.BLOCK_HEADER_SIZE_MAX)
		throw new UnsupportedOptionsException();

	// Block Header Size
	buf[0] = (byte) (buf.length / 4);

	// Write the Block Header field to the output stream.
	out.write(buf);
	EncoderUtil.writeCRC32(out, buf);

	// Calculate the maximum allowed size of the Compressed Data field.
	// It is hard to exceed it so this is mostly to be pedantic.
	compressedSizeLimit = (EncoderUtil.VLI_MAX & ~3) - headerSize
			- check.getSize();
}
 

import org.tukaani.xz.check.Check; //导入依赖的package包/类
/**
 * Creates a new XZ compressor using 1-4 filters and the specified
 * integrity check type.
 *
 * @param       out         output stream to which the compressed data
 *                          will be written
 *
 * @param       filterOptions
 *                          array of filter options to use
 *
 * @param       checkType   type of the integrity check,
 *                          for example XZ.CHECK_CRC32
 *
 * @throws      UnsupportedOptionsException
 *                          invalid filter chain
 *
 * @throws      IOException may be thrown from <code>out</code>
 */
public XZOutputStream(OutputStream out, FilterOptions[] filterOptions,
                      int checkType) throws IOException {
    this.out = out;
    updateFilters(filterOptions);

    streamFlags.checkType = checkType;
    check = Check.getInstance(checkType);

    encodeStreamHeader();
}
 

import org.tukaani.xz.check.Check; //导入依赖的package包/类
/**
 * Creates a new XZ compressor using 1-4 filters and the specified integrity
 * check type.
 * 
 * @param out
 *            output stream to which the compressed data will be written
 * 
 * @param filterOptions
 *            array of filter options to use
 * 
 * @param checkType
 *            type of the integrity check, for example XZ.CHECK_CRC32
 * 
 * @throws UnsupportedOptionsException
 *             invalid filter chain
 * 
 * @throws IOException
 *             may be thrown from <code>out</code>
 */
public XZOutputStream(OutputStream out, FilterOptions[] filterOptions,
		int checkType) throws IOException {
	this.out = out;
	updateFilters(filterOptions);

	streamFlags.checkType = checkType;
	check = Check.getInstance(checkType);

	encodeStreamHeader();
}