+
−package ar.com.hjg.pngj;
+
−
+
−import java.io.File;
+
−import java.io.FileInputStream;
+
−import java.io.FileNotFoundException;
+
−import java.io.InputStream;
+
−import java.util.Arrays;
+
−
+
−import ar.com.hjg.pngj.ChunkReader.ChunkReaderMode;
+
−import ar.com.hjg.pngj.chunks.ChunkHelper;
+
−
+
−/**
+
− * Consumes a stream of bytes that consist of a series of PNG-like chunks.
+
− * <p>
+
− * This has little intelligence, it's quite low-level and general (it could even be used for a MNG stream, for example).
+
− * It supports signature recognition and idat deflate
+
− */
+
−public class ChunkSeqReader implements IBytesConsumer {
+
−
+
−  protected static final int SIGNATURE_LEN = 8;
+
−  protected final boolean withSignature;
+
−
+
−  private byte[] buf0 = new byte[8]; // for signature or chunk starts
+
−  private int buf0len = 0;
+
−
+
−  private boolean signatureDone = false;
+
−  private boolean done = false; // ended, normally or not
+
−
+
−  private int chunkCount = 0;
+
−
+
−  private long bytesCount = 0;
+
−
+
−  private DeflatedChunksSet curReaderDeflatedSet; // one instance is created for each
+
−                                                  // "idat-like set". Normally one.
+
−
+
−  private ChunkReader curChunkReader;
+
−
+
−  private long idatBytes; // this is only for the IDAT (not mrerely "idat-like")
+
−
+
−  /**
+
−   * Creates a ChunkSeqReader (with signature)
+
−   */
+
−  public ChunkSeqReader() {
+
−    this(true);
+
−  }
+
−
+
−  /**
+
−   * @param withSignature If true, the stream is assumed be prepended by 8 bit signature
+
−   */
+
−  public ChunkSeqReader(boolean withSignature) {
+
−    this.withSignature = withSignature;
+
−    signatureDone = !withSignature;
+
−  }
+
−
+
−  /**
+
−   * Consumes (in general, partially) a number of bytes. A single call never involves more than one chunk.
+
−   * 
+
−   * When the signature is read, it calls checkSignature()
+
−   * 
+
−   * When the start of a chunk is detected, it calls {@link #startNewChunk(int, String, long)}
+
−   * 
+
−   * When data from a chunk is being read, it delegates to {@link ChunkReader#feedBytes(byte[], int, int)}
+
−   * 
+
−   * The caller might want to call this method more than once in succesion
+
−   * 
+
−   * This should rarely be overriden
+
−   * 
+
−   * @param buffer
+
−   * @param offset Offset in buffer
+
−   * @param len Valid bytes that can be consumed
+
−   * @return processed bytes, in the 1-len range. -1 if done. Only returns 0 if len=0.
+
−   **/
+
−  public int consume(byte[] buffer, int offset, int len) {
+
−    if (done)
+
−      return -1;
+
−    if (len == 0)
+
−      return 0; // nothing to do
+
−    if (len < 0)
+
−      throw new PngjInputException("Bad len: " + len);
+
−    int processed = 0;
+
−    if (signatureDone) {
+
−      if (curChunkReader == null || curChunkReader.isDone()) { // new chunk: read first 8 bytes
+
−        int read0 = 8 - buf0len;
+
−        if (read0 > len)
+
−          read0 = len;
+
−        System.arraycopy(buffer, offset, buf0, buf0len, read0);
+
−        buf0len += read0;
+
−        processed += read0;
+
−        bytesCount += read0;
+
−        // len -= read0;
+
−        // offset += read0;
+
−        if (buf0len == 8) { // end reading chunk length and id
+
−          chunkCount++;
+
−          int clen = PngHelperInternal.readInt4fromBytes(buf0, 0);
+
−          String cid = ChunkHelper.toString(buf0, 4, 4);
+
−          startNewChunk(clen, cid, bytesCount - 8);
+
−          buf0len = 0;
+
−        }
+
−      } else { // reading chunk, delegates to curChunkReader
+
−        int read1 = curChunkReader.feedBytes(buffer, offset, len);
+
−        processed += read1;
+
−        bytesCount += read1;
+
−      }
+
−    } else { // reading signature
+
−      int read = SIGNATURE_LEN - buf0len;
+
−      if (read > len)
+
−        read = len;
+
−      System.arraycopy(buffer, offset, buf0, buf0len, read);
+
−      buf0len += read;
+
−      if (buf0len == SIGNATURE_LEN) {
+
−        checkSignature(buf0);
+
−        buf0len = 0;
+
−        signatureDone = true;
+
−      }
+
−      processed += read;
+
−      bytesCount += read;
+
−    }
+
−    return processed;
+
−  }
+
−
+
−  /**
+
−   * Trys to feeds exactly <tt>len</tt> bytes, calling {@link #consume(byte[], int, int)} retrying if necessary.
+
−   * 
+
−   * This should only be used in callback mode
+
−   * 
+
−   * @return true if succceded
+
−   */
+
−  public boolean feedAll(byte[] buf, int off, int len) {
+
−    while (len > 0) {
+
−      int n = consume(buf, off, len);
+
−      if (n < 1)
+
−        return false;
+
−      len -= n;
+
−      off += n;
+
−    }
+
−    return true;
+
−  }
+
−
+
−  /**
+
−   * Called for all chunks when a chunk start has been read (id and length), before the chunk data itself is read. It
+
−   * creates a new ChunkReader (field accesible via {@link #getCurChunkReader()}) in the corresponding mode, and
+
−   * eventually a curReaderDeflatedSet.(field accesible via {@link #getCurReaderDeflatedSet()})
+
−   * 
+
−   * To decide the mode and options, it calls {@link #shouldCheckCrc(int, String)},
+
−   * {@link #shouldSkipContent(int, String)}, {@link #isIdatKind(String)}. Those methods should be overriden in
+
−   * preference to this; if overriden, this should be called first.
+
−   * 
+
−   * The respective {@link ChunkReader#chunkDone()} method is directed to this {@link #postProcessChunk(ChunkReader)}.
+
−   * 
+
−   * Instead of overriding this, see also {@link #createChunkReaderForNewChunk(String, int, long, boolean)}
+
−   */
+
−  protected void startNewChunk(int len, String id, long offset) {
+
−    if (id.equals(ChunkHelper.IDAT))
+
−      idatBytes += len;
+
−    boolean checkCrc = shouldCheckCrc(len, id);
+
−    boolean skip = shouldSkipContent(len, id);
+
−    boolean isIdatType = isIdatKind(id);
+
−    // PngHelperInternal.debug("start new chunk  id=" + id + " off=" + offset + " skip=" + skip + " idat=" +
+
−    // isIdatType);
+
−    // first see if we should terminate an active curReaderDeflatedSet
+
−    boolean forCurrentIdatSet = false;
+
−    if (curReaderDeflatedSet != null)
+
−      forCurrentIdatSet = curReaderDeflatedSet.ackNextChunkId(id);
+
−    if (isIdatType && !skip) { // IDAT non skipped: create a DeflatedChunkReader owned by a idatSet
+
−      if (!forCurrentIdatSet) {
+
−        if (curReaderDeflatedSet != null && !curReaderDeflatedSet.isDone())
+
−          throw new PngjInputException("new IDAT-like chunk when previous was not done");
+
−        curReaderDeflatedSet = createIdatSet(id);
+
−      }
+
−      curChunkReader = new DeflatedChunkReader(len, id, checkCrc, offset, curReaderDeflatedSet) {
+
−        @Override
+
−        protected void chunkDone() {
+
−          super.chunkDone();
+
−          postProcessChunk(this);
+
−        }
+
−      };
+
−
+
−    } else { // for non-idat chunks (or skipped idat like)
+
−      curChunkReader = createChunkReaderForNewChunk(id, len, offset, skip);
+
−      if (!checkCrc)
+
−        curChunkReader.setCrcCheck(false);
+
−    }
+
−  }
+
−
+
−  /**
+
−   * This will be called for all chunks (even skipped), except for IDAT-like non-skiped chunks
+
−   * 
+
−   * The default behaviour is to create a ChunkReader in BUFFER mode (or SKIP if skip==true) that calls
+
−   * {@link #postProcessChunk(ChunkReader)} (always) when done.
+
−   * 
+
−   * @param id Chunk id
+
−   * @param len Chunk length
+
−   * @param offset offset inside PNG stream , merely informative
+
−   * @param skip flag: is true, the content will not be buffered (nor processed)
+
−   * @return a newly created ChunkReader that will create the ChunkRaw and then discarded
+
−   */
+
−  protected ChunkReader createChunkReaderForNewChunk(String id, int len, long offset, boolean skip) {
+
−    return new ChunkReader(len, id, offset, skip ? ChunkReaderMode.SKIP : ChunkReaderMode.BUFFER) {
+
−      @Override
+
−      protected void chunkDone() {
+
−        postProcessChunk(this);
+
−      }
+
−
+
−      @Override
+
−      protected void processData(int offsetinChhunk, byte[] buf, int off, int len) {
+
−        throw new PngjExceptionInternal("should never happen");
+
−      }
+
−    };
+
−  }
+
−
+
−  /**
+
−   * This is called after a chunk is read, in all modes
+
−   * 
+
−   * This implementation only chenks the id of the first chunk, and process the IEND chunk (sets done=true)
+
−   ** 
+
−   * Further processing should be overriden (call this first!)
+
−   **/
+
−  protected void postProcessChunk(ChunkReader chunkR) { // called after chunk is read
+
−    if (chunkCount == 1) {
+
−      String cid = firstChunkId();
+
−      if (cid != null && !cid.equals(chunkR.getChunkRaw().id))
+
−        throw new PngjInputException("Bad first chunk: " + chunkR.getChunkRaw().id + " expected: "
+
−            + firstChunkId());
+
−    }
+
−    if (chunkR.getChunkRaw().id.equals(endChunkId()))
+
−      done = true;
+
−  }
+
−
+
−  /**
+
−   * DeflatedChunksSet factory. This implementation is quite dummy, it usually should be overriden.
+
−   */
+
−  protected DeflatedChunksSet createIdatSet(String id) {
+
−    return new DeflatedChunksSet(id, 1024, 1024); // sizes: arbitrary This should normally be
+
−                                                  // overriden
+
−  }
+
−
+
−  /**
+
−   * Decides if this Chunk is of "IDAT" kind (in concrete: if it is, and if it's not to be skiped, a DeflatedChunksSet
+
−   * will be created to deflate it and process+ the deflated data)
+
−   * 
+
−   * This implementation always returns always false
+
−   * 
+
−   * @param id
+
−   */
+
−  protected boolean isIdatKind(String id) {
+
−    return false;
+
−  }
+
−
+
−  /**
+
−   * Chunks can be skipped depending on id and/or length. Skipped chunks are still processed, but their data will be
+
−   * null, and CRC will never checked
+
−   * 
+
−   * @param len
+
−   * @param id
+
−   */
+
−  protected boolean shouldSkipContent(int len, String id) {
+
−    return false;
+
−  }
+
−
+
−  protected boolean shouldCheckCrc(int len, String id) {
+
−    return true;
+
−  }
+
−
+
−  /**
+
−   * Throws PngjInputException if bad signature
+
−   * 
+
−   * @param buf Signature. Should be of length 8
+
−   */
+
−  protected void checkSignature(byte[] buf) {
+
−    if (!Arrays.equals(buf, PngHelperInternal.getPngIdSignature()))
+
−      throw new PngjInputException("Bad PNG signature");
+
−  }
+
−
+
−  /**
+
−   * If false, we are still reading the signature
+
−   * 
+
−   * @return true if signature has been read (or if we don't have signature)
+
−   */
+
−  public boolean isSignatureDone() {
+
−    return signatureDone;
+
−  }
+
−
+
−  /**
+
−   * If true, we either have processe the IEND chunk, or close() has been called, or a fatal error has happened
+
−   */
+
−  public boolean isDone() {
+
−    return done;
+
−  }
+
−
+
−  /**
+
−   * total of bytes read (buffered or not)
+
−   */
+
−  public long getBytesCount() {
+
−    return bytesCount;
+
−  }
+
−
+
−  /**
+
−   * @return Chunks already read, including partial reading (currently reading)
+
−   */
+
−  public int getChunkCount() {
+
−    return chunkCount;
+
−  }
+
−
+
−  /**
+
−   * Currently reading chunk, or just ended reading
+
−   * 
+
−   * @return null only if still reading signature
+
−   */
+
−  public ChunkReader getCurChunkReader() {
+
−    return curChunkReader;
+
−  }
+
−
+
−  /**
+
−   * The latest deflated set (typically IDAT chunks) reader. Notice that there could be several idat sets (eg for APNG)
+
−   */
+
−  public DeflatedChunksSet getCurReaderDeflatedSet() {
+
−    return curReaderDeflatedSet;
+
−  }
+
−
+
−  /**
+
−   * Closes this object and release resources. For normal termination or abort. Secure and idempotent.
+
−   */
+
−  public void close() { // forced closing
+
−    if (curReaderDeflatedSet != null)
+
−      curReaderDeflatedSet.close();
+
−    done = true;
+
−  }
+
−
+
−  /**
+
−   * Returns true if we are not in middle of a chunk: we have just ended reading past chunk , or we are at the start, or
+
−   * end of signature, or we are done
+
−   */
+
−  public boolean isAtChunkBoundary() {
+
−    return bytesCount == 0 || bytesCount == 8 || done || curChunkReader == null
+
−        || curChunkReader.isDone();
+
−  }
+
−
+
−  /**
+
−   * Which should be the id of the first chunk
+
−   * 
+
−   * @return null if you don't want to check it
+
−   */
+
−  protected String firstChunkId() {
+
−    return "IHDR";
+
−  }
+
−
+
−  /**
+
−   * Helper method, reports amount of bytes inside IDAT chunks.
+
−   * 
+
−   * @return Bytes in IDAT chunks
+
−   */
+
−  public long getIdatBytes() {
+
−    return idatBytes;
+
−  }
+
−
+
−  /**
+
−   * Which should be the id of the last chunk
+
−   * 
+
−   * @return "IEND"
+
−   */
+
−  protected String endChunkId() {
+
−    return "IEND";
+
−  }
+
−
+
−  /**
+
−   * Reads all content from a file. Helper method, only for callback mode
+
−   */
+
−  public void feedFromFile(File f) {
+
−    try {
+
−      feedFromInputStream(new FileInputStream(f), true);
+
−    } catch (FileNotFoundException e) {
+
−      throw new PngjInputException(e.getMessage());
+
−    }
+
−  }
+
−
+
−  /**
+
−   * Reads all content from an input stream. Helper method, only for callback mode
+
−   * 
+
−   * @param is
+
−   * @param closeStream Closes the input stream when done (or if error)
+
−   */
+
−  public void feedFromInputStream(InputStream is, boolean closeStream) {
+
−    BufferedStreamFeeder sf = new BufferedStreamFeeder(is);
+
−    sf.setCloseStream(closeStream);
+
−    try {
+
−      sf.feedAll(this);
+
−    } finally {
+
−      close();
+
−      sf.close();
+
−    }
+
−  }
+
−
+
−  public void feedFromInputStream(InputStream is) {
+
−    feedFromInputStream(is, true);
+
−  }
+
−}