UnixCompressFilter.java

  1. /* Copyright 2002-2020 CS GROUP
  2.  * Licensed to CS GROUP (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.data;

  19. import java.io.IOException;
  20. import java.io.InputStream;
  21. import java.util.Arrays;

  23. import org.hipparchus.util.FastMath;
  24. import org.orekit.errors.OrekitException;
  25. import org.orekit.errors.OrekitIOException;
  26. import org.orekit.errors.OrekitMessages;

  28. /** Filter for Unix compressed data.
  29.  * @author Luc Maisonobe
  30.  * @since 9.2
  31.  */
  32. public class UnixCompressFilter implements DataFilter {

  34.     /** Suffix for Unix compressed files. */
  35.     private static final String SUFFIX = ".Z";

  37.     /** {@inheritDoc} */
  38.     @Override
  39.     public NamedData filter(final NamedData original) {
  40.         final String                 oName   = original.getName();
  41.         final NamedData.StreamOpener oOpener = original.getStreamOpener();
  42.         if (oName.endsWith(SUFFIX)) {
  43.             final String                 fName   = oName.substring(0, oName.length() - SUFFIX.length());
  44.             final NamedData.StreamOpener fOpener = () -> new ZInputStream(oName, new Buffer(oOpener.openStream()));
  45.             return new NamedData(fName, fOpener);
  46.         } else {
  47.             return original;
  48.         }
  49.     }

  51.     /** Filtering of Unix compressed stream. */
  52.     private static class ZInputStream extends InputStream {

  54.         /** First magic header byte. */
  55.         private static final int MAGIC_HEADER_1 = 0x1f;

  57.         /** Second magic header byte. */
  58.         private static final int MAGIC_HEADER_2 = 0x9d;

  60.         /** Byte bits width. */
  61.         private static final int BYTE_WIDTH = 8;

  63.         /** Initial bits width. */
  64.         private static final int INIT_WIDTH = 9;

  66.         /** Reset table code. */
  67.         private static final int RESET_TABLE = 256;

  69.         /** First non-predefined entry. */
  70.         private static final int FIRST = 257;

  72.         /** File name. */
  73.         private final String name;

  75.         /** Indicator for end of input. */
  76.         private boolean endOfInput;

  78.         /** Common sequences table. */
  79.         private final UncompressedSequence[] table;

  81.         /** Next available entry in the table. */
  82.         private int available;

  84.         /** Flag for block mode when table is full. */
  85.         private final boolean blockMode;

  87.         /** Maximum width allowed. */
  88.         private final int maxWidth;

  90.         /** Current input width in bits. */
  91.         private int currentWidth;

  93.         /** Maximum key that can be encoded with current width. */
  94.         private int currentMaxKey;

  96.         /** Number of bits read since last reset. */
  97.         private int bitsRead;

  99.         /** Lookahead byte, already read but not yet used. */
  100.         private int lookAhead;

  102.         /** Number of bits in the lookahead byte. */
  103.         private int lookAheadWidth;

  105.         /** Input buffer. */
  106.         private Buffer input;

  108.         /** Previous uncompressed sequence output. */
  109.         private UncompressedSequence previousSequence;

  111.         /** Uncompressed sequence being output. */
  112.         private UncompressedSequence currentSequence;

  114.         /** Number of bytes of the current sequence already output. */
  115.         private int alreadyOutput;

  117.         /** Simple constructor.
  118.          * @param name file name
  119.          * @param input underlying compressed stream
  120.          * @exception IOException if first bytes cannot be read
  121.          */
  122.         ZInputStream(final String name, final Buffer input)
  123.             throws IOException {

  125.             this.name       = name;
  126.             this.input      = input;
  127.             this.endOfInput = false;

  129.             // check header
  130.             if (input.getByte() != MAGIC_HEADER_1 || input.getByte() != MAGIC_HEADER_2) {
  131.                 throw new OrekitException(OrekitMessages.NOT_A_SUPPORTED_UNIX_COMPRESSED_FILE, name);
  132.             }

  134.             final int header3 = input.getByte();
  135.             this.blockMode = (header3 & 0x80) != 0;
  136.             this.maxWidth  = header3 & 0x1f;

  138.             // set up table, with at least all entries for one byte
  139.             this.table = new UncompressedSequence[1 << FastMath.max(INIT_WIDTH, maxWidth)];
  140.             for (int i = 0; i < FIRST; ++i) {
  141.                 table[i] = new UncompressedSequence(null, (byte) i);
  142.             }

  144.             // initialize decompression state
  145.             initialize();

  147.         }

  149.         /** Initialize compression state.
  150.          */
  151.         private void initialize() {
  152.             this.available        = FIRST;
  153.             this.bitsRead         = 0;
  154.             this.lookAhead        = 0;
  155.             this.lookAheadWidth   = 0;
  156.             this.currentWidth     = INIT_WIDTH;
  157.             this.currentMaxKey    = (1 << currentWidth) - 1;
  158.             this.previousSequence = null;
  159.             this.currentSequence  = null;
  160.             this.alreadyOutput    = 0;
  161.         }

  163.         /** Read next input key.
  164.          * @return next input key or -1 if end of stream is reached
  165.          * @exception IOException if a read error occurs
  166.          */
  167.         private int nextKey() throws IOException {

  169.             int keyMask = (1 << currentWidth) - 1;

  171.             while (true) {
  172.                 // initialize key with the last bits remaining from previous read
  173.                 int key = lookAhead & keyMask;

  175.                 // read more bits until key is complete
  176.                 for (int remaining = currentWidth - lookAheadWidth; remaining > 0; remaining -= BYTE_WIDTH) {
  177.                     lookAhead       = input.getByte();
  178.                     lookAheadWidth += BYTE_WIDTH;
  179.                     if (lookAhead < 0) {
  180.                         if (key == 0 || key == keyMask) {
  181.                             // the key is either a set of padding 0 bits
  182.                             // or a full key containing -1 if read() is called several times after EOF
  183.                             return -1;
  184.                         } else {
  185.                             // end of stream encountered in the middle of a read
  186.                             throw new OrekitIOException(OrekitMessages.UNEXPECTED_END_OF_FILE, name);
  187.                         }
  188.                     }
  189.                     key = (key | lookAhead << (currentWidth - remaining)) & keyMask;
  190.                 }

  192.                 // store the extra bits already read in the lookahead byte for next call
  193.                 lookAheadWidth -= currentWidth;
  194.                 lookAhead       = lookAhead >>> (BYTE_WIDTH - lookAheadWidth);

  196.                 bitsRead += currentWidth;

  198.                 if (blockMode && key == RESET_TABLE) {

  200.                     // skip the padding bits inserted when compressor flushed its buffer
  201.                     final int superSize = currentWidth * 8;
  202.                     int padding = (superSize - 1 - (bitsRead + superSize - 1) % superSize) / 8;
  203.                     while (padding-- > 0) {
  204.                         input.getByte();
  205.                     }

  207.                     // reset the table to handle a new block and read again next key
  208.                     Arrays.fill(table, FIRST, table.length, null);
  209.                     initialize();

  211.                     // reset the lookahead mask as the current width has changed
  212.                     keyMask = (1 << currentWidth) - 1;

  214.                 } else {
  215.                     // return key at current width
  216.                     return key;
  217.                 }

  219.             }

  221.         }

  223.         /** Select next uncompressed sequence to output.
  224.          * @return true if there is a next sequence
  225.          * @exception IOException if a read error occurs
  226.          */
  227.         private boolean selectNext() throws IOException {

  229.             // read next input key
  230.             final int key = nextKey();
  231.             if (key < 0) {
  232.                 // end of stream reached
  233.                 return false;
  234.             }

  236.             if (previousSequence != null && available < table.length) {
  237.                 // update the table with the next uncompressed byte appended to previous sequence
  238.                 final byte nextByte;
  239.                 if (key == available) {
  240.                     nextByte = previousSequence.getByte(0);
  241.                 } else if (table[key] != null) {
  242.                     nextByte = table[key].getByte(0);
  243.                 } else {
  244.                     throw new OrekitIOException(OrekitMessages.CORRUPTED_FILE, name);
  245.                 }
  246.                 table[available++] = new UncompressedSequence(previousSequence, nextByte);
  247.                 if (available > currentMaxKey && currentWidth < maxWidth) {
  248.                     // we need to increase the key size
  249.                     currentMaxKey = (1 << ++currentWidth) - 1;
  250.                 }
  251.             }

  253.             currentSequence = table[key];
  254.             if (currentSequence == null) {
  255.                 // the compressed file references a non-existent table entry
  256.                 // (this is not the well-known case of entry being used just before
  257.                 //  being defined, which is already handled above), the file is corrupted
  258.                 throw new OrekitIOException(OrekitMessages.CORRUPTED_FILE, name);
  259.             }
  260.             alreadyOutput   = 0;

  262.             return true;

  264.         }

  266.         /** {@inheritDoc} */
  267.         @Override
  268.         public int read() throws IOException {
  269.             final byte[] b = new byte[1];
  270.             return read(b, 0, 1) < 0 ? -1 : b[0];
  271.         }

  273.         /** {@inheritDoc} */
  274.         @Override
  275.         public int read(final byte[] b, final int offset, final int len) throws IOException {

  277.             if (currentSequence == null) {
  278.                 if (endOfInput || !selectNext()) {
  279.                     // we have reached end of data
  280.                     endOfInput = true;
  281.                     return -1;
  282.                 }
  283.             }

  285.             // copy as many bytes as possible from current sequence
  286.             final int n = FastMath.min(len, currentSequence.length() - alreadyOutput);
  287.             for (int i = 0; i < n; ++i) {
  288.                 b[offset + i] = currentSequence.getByte(alreadyOutput++);
  289.             }
  290.             if (alreadyOutput >= currentSequence.length()) {
  291.                 // we have just exhausted the current sequence
  292.                 previousSequence = currentSequence;
  293.                 currentSequence  = null;
  294.                 alreadyOutput    = 0;
  295.             }

  297.             return n;

  299.         }

  301.         /** {@inheritDoc} */
  302.         @Override
  303.         public int available() {
  304.             return currentSequence == null ? 0 : currentSequence.length() - alreadyOutput;
  305.         }

  307.     }

  309.     /** Uncompressed bits sequence. */
  310.     private static class UncompressedSequence {

  312.         /** Prefix sequence (null if this is a start sequence). */
  313.         private final UncompressedSequence prefix;

  315.         /** Last byte in the sequence. */
  316.         private final byte last;

  318.         /** Index of the last byte in the sequence (i.e. length - 1). */
  319.         private final int index;

  321.         /** Simple constructor.
  322.          * @param prefix prefix of the sequence (null if this is a start sequence)
  323.          * @param last last byte of the sequence
  324.          */
  325.         UncompressedSequence(final UncompressedSequence prefix, final byte last) {
  326.             this.prefix = prefix;
  327.             this.last   = last;
  328.             this.index  = prefix == null ? 0 : prefix.index + 1;
  329.         }

  331.         /** Get the length of the sequence.
  332.          * @return length of the sequence
  333.          */
  334.         public int length() {
  335.             return index + 1;
  336.         }

  338.         /** Get a byte from the sequence.
  339.          * @param outputIndex index of the byte in the sequence, counting from 0
  340.          * @return byte at {@code outputIndex}
  341.          */
  342.         public byte getByte(final int outputIndex) {
  343.             return index == outputIndex ? last : prefix.getByte(outputIndex);
  344.         }

  346.     }

  348.     /** Buffer for reading input data. */
  349.     private static class Buffer {

  351.         /** Size of input/output buffers. */
  352.         private static final int BUFFER_SIZE = 4096;

  354.         /** Underlying compressed stream. */
  355.         private final InputStream input;

  357.         /** Buffer data. */
  358.         private final byte[] data;

  360.         /** Start of pending data. */
  361.         private int start;

  363.         /** End of pending data. */
  364.         private int end;

  366.         /** Simple constructor.
  367.          * @param input input stream
  368.          */
  369.         Buffer(final InputStream input) {
  370.             this.input = input;
  371.             this.data  = new byte[BUFFER_SIZE];
  372.             this.start = 0;
  373.             this.end   = start;
  374.         }

  376.         /** Get one input byte.
  377.          * @return input byte, or -1 if end of input has been reached
  378.          * @throws IOException if input data cannot be read
  379.          */
  380.         private int getByte() throws IOException {

  382.             if (start == end) {
  383.                 // the buffer is empty
  384.                 start = 0;
  385.                 end   = input.read(data);
  386.                 if (end == -1) {
  387.                     return -1;
  388.                 }
  389.             }

  391.             return data[start++] & 0xFF;

  393.         }

  395.     }
  396. }
Created with JaCoCo 0.8.6.202009150832