ChunkSeqReaderPng (PNGJ 2.1.1-SNAPSHOT API)

java.lang.Object
- ar.com.hjg.pngj.ChunkSeqReader
- - ar.com.hjg.pngj.ChunkSeqReaderPng

All Implemented Interfaces:

IBytesConsumer
```
public class ChunkSeqReaderPng
extends ChunkSeqReader
```
Adds to ChunkSeqReader the storing of PngChunk, with a PngFactory, and imageInfo + deinterlacer.
Most usual PNG reading should use this class, or a PngReader, which is a thin wrapper over this.

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`callbackMode`
`protected ChunksList`	`chunksList` All chunks, but some of them can have the buffer empty (IDAT and skipped)
`protected ImageInfo`	`curImageInfo`
`protected int`	`currentChunkGroup`
`protected Deinterlacer`	`deinterlacer`
`protected ImageInfo`	`imageInfo`

Fields inherited from class ar.com.hjg.pngj.ChunkSeqReader
SIGNATURE_LEN, withSignature

Constructor Summary

Constructors
Constructor and Description

ChunkSeqReaderPng(boolean callbackMode)

Constructors
Constructor and Description
`ChunkSeqReaderPng(boolean callbackMode)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addChunkToSkip(String chunkToSkip)`
`void`	`close()` Closes this object and release resources.
`int`	`consume(byte[] buf, int off, int len)` Consumes (in general, partially) a number of bytes.
`protected boolean`	`countChunkTypeAsAncillary(String id)`
`protected DeflatedChunksSet`	`createIdatSet(String id)` DeflatedChunksSet factory.
`void`	`dontSkipChunk(String chunkToSkip)`
`boolean`	`firstChunksNotYetRead()`
`long`	`getBytesChunksLoaded()`
`List<PngChunk>`	`getChunks()`
`Set<String>`	`getChunksToSkip()`
`ImageInfo`	`getCurImgInfo()`
`int`	`getCurrentChunkGroup()`
`Deinterlacer`	`getDeinterlacer()`
`IdatSet`	`getIdatSet()`
`ImageInfo`	`getImageInfo()`
`long`	`getMaxBytesMetadata()`
`long`	`getMaxTotalBytesRead()`
`long`	`getSkipChunkMaxSize()`
`boolean`	`isCallbackMode()`
`boolean`	`isCheckCrc()`
`protected boolean`	`isIdatKind(String id)` 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
`boolean`	`isInterlaced()`
`protected void`	`postProcessChunk(ChunkReader chunkR)` 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`	`processEndPng()` Things to be done after IEND processing.
`void`	`setCheckCrc(boolean checkCrc)`
`void`	`setChunkFactory(IChunkFactory chunkFactory)` sets a custom chunk factory.
`void`	`setChunkLoadBehaviour(ChunkLoadBehaviour chunkLoadBehaviour)`
`void`	`setChunksToSkip(String... chunksToSkip)`
`void`	`setIncludeNonBufferedChunks(boolean includeNonBufferedChunks)` If true, the chunks with no data (because skipped or because processed like IDAT-type) are still stored in the PngChunks list, which might be more informative.
`void`	`setMaxBytesMetadata(long maxBytesMetadata)`
`void`	`setMaxTotalBytesRead(long maxTotalBytesRead)`
`void`	`setSkipChunkMaxSize(long skipChunkMaxSize)`
`protected boolean`	`shouldCheckCrc(int len, String id)`
`boolean`	`shouldSkipContent(int len, String id)` Chunks can be skipped depending on id and/or length.
`protected void`	`startNewChunk(int len, String id, long offset)` Called for all chunks when a chunk start has been read (id and length), before the chunk data itself is read.
`void`	`updateCurImgInfo(ImageInfo iminfo)`

Methods inherited from class ar.com.hjg.pngj.ChunkSeqReader
checkSignature, createChunkReaderForNewChunk, endChunkId, feedAll, feedFromFile, feedFromInputStream, feedFromInputStream, firstChunkId, getBytesCount, getChunkCount, getCurChunkReader, getCurReaderDeflatedSet, getIdatBytes, isAtChunkBoundary, isDone, isSignatureDone

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - imageInfo
```
protected ImageInfo imageInfo
```
  - curImageInfo
```
protected ImageInfo curImageInfo
```
  - deinterlacer
```
protected Deinterlacer deinterlacer
```
  - currentChunkGroup
```
protected int currentChunkGroup
```
  - chunksList
```
protected ChunksList chunksList
```
    All chunks, but some of them can have the buffer empty (IDAT and skipped)
  - callbackMode
```
protected final boolean callbackMode
```
- Constructor Detail
  - ChunkSeqReaderPng
```
public ChunkSeqReaderPng(boolean callbackMode)
```
- Method Detail
  - shouldSkipContent
```
public boolean shouldSkipContent(int len,
                        String id)
```
    Description copied from class: ChunkSeqReader
    
    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
    
    Overrides:
    
    shouldSkipContent in class ChunkSeqReader
  - getBytesChunksLoaded
```
public long getBytesChunksLoaded()
```
  - getCurrentChunkGroup
```
public int getCurrentChunkGroup()
```
  - setChunksToSkip
```
public void setChunksToSkip(String... chunksToSkip)
```
  - addChunkToSkip
```
public void addChunkToSkip(String chunkToSkip)
```
  - dontSkipChunk
```
public void dontSkipChunk(String chunkToSkip)
```
  - firstChunksNotYetRead
```
public boolean firstChunksNotYetRead()
```
  - postProcessChunk
```
protected void postProcessChunk(ChunkReader chunkR)
```
    Description copied from class: ChunkSeqReader
    
    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!)
    
    Overrides:
    
    postProcessChunk in class ChunkSeqReader
  - countChunkTypeAsAncillary
```
protected boolean countChunkTypeAsAncillary(String id)
```
  - createIdatSet
```
protected DeflatedChunksSet createIdatSet(String id)
```
    Description copied from class: ChunkSeqReader
    
    DeflatedChunksSet factory. This implementation is quite dummy, it usually should be overriden.
    
    Overrides:
    
    createIdatSet in class ChunkSeqReader
  - getIdatSet
```
public IdatSet getIdatSet()
```
  - isIdatKind
```
protected boolean isIdatKind(String id)
```
    Description copied from class: ChunkSeqReader
    
    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
    
    Overrides:
    
    isIdatKind in class ChunkSeqReader
  - consume
```
public int consume(byte[] buf,
          int off,
          int len)
```
    Description copied from class: ChunkSeqReader
    
    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 ChunkSeqReader.startNewChunk(int, String, long) When data from a chunk is being read, it delegates to ChunkReader.feedBytes(byte[], int, int) The caller might want to call this method more than once in succesion This should rarely be overriden
    
    Specified by:
    
    consume in interface IBytesConsumer
    
    Overrides:
    
    consume in class ChunkSeqReader
    
    off - Offset in buffer
    len - Valid bytes that can be consumed
    
    Returns:
    processed bytes, in the 1-len range. -1 if done. Only returns 0 if len=0.
  - setChunkFactory
```
public void setChunkFactory(IChunkFactory chunkFactory)
```
    sets a custom chunk factory. This is typically called with a custom class extends ChunkFactory, to adds custom chunks to the default well-know ones
    
    Parameters:
    chunkFactory -
  - processEndPng
```
protected void processEndPng()
```
    Things to be done after IEND processing. This is not called if prematurely closed.
  - getImageInfo
```
public ImageInfo getImageInfo()
```
  - isInterlaced
```
public boolean isInterlaced()
```
  - getDeinterlacer
```
public Deinterlacer getDeinterlacer()
```
  - startNewChunk
```
protected void startNewChunk(int len,
                 String id,
                 long offset)
```
    Description copied from class: ChunkSeqReader
    
    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 ChunkSeqReader.getCurChunkReader()) in the corresponding mode, and eventually a curReaderDeflatedSet.(field accesible via ChunkSeqReader.getCurReaderDeflatedSet()) To decide the mode and options, it calls ChunkSeqReader.shouldCheckCrc(int, String), ChunkSeqReader.shouldSkipContent(int, String), ChunkSeqReader.isIdatKind(String). Those methods should be overriden in preference to this; if overriden, this should be called first. The respective ChunkReader.chunkDone() method is directed to this ChunkSeqReader.postProcessChunk(ChunkReader). Instead of overriding this, see also ChunkSeqReader.createChunkReaderForNewChunk(String, int, long, boolean)
    
    Overrides:
    
    startNewChunk in class ChunkSeqReader
  - close
```
public void close()
```
    Description copied from class: ChunkSeqReader
    
    Closes this object and release resources. For normal termination or abort. Secure and idempotent.
    
    Overrides:
    
    close in class ChunkSeqReader
  - getChunks
```
public List<PngChunk> getChunks()
```
  - setMaxTotalBytesRead
```
public void setMaxTotalBytesRead(long maxTotalBytesRead)
```
  - getSkipChunkMaxSize
```
public long getSkipChunkMaxSize()
```
  - setSkipChunkMaxSize
```
public void setSkipChunkMaxSize(long skipChunkMaxSize)
```
  - getMaxBytesMetadata
```
public long getMaxBytesMetadata()
```
  - setMaxBytesMetadata
```
public void setMaxBytesMetadata(long maxBytesMetadata)
```
  - getMaxTotalBytesRead
```
public long getMaxTotalBytesRead()
```
  - shouldCheckCrc
```
protected boolean shouldCheckCrc(int len,
                     String id)
```
    Overrides:
    
    shouldCheckCrc in class ChunkSeqReader
  - isCheckCrc
```
public boolean isCheckCrc()
```
  - setCheckCrc
```
public void setCheckCrc(boolean checkCrc)
```
  - isCallbackMode
```
public boolean isCallbackMode()
```
  - getChunksToSkip
```
public Set<String> getChunksToSkip()
```
  - setChunkLoadBehaviour
```
public void setChunkLoadBehaviour(ChunkLoadBehaviour chunkLoadBehaviour)
```
  - getCurImgInfo
```
public ImageInfo getCurImgInfo()
```
  - updateCurImgInfo
```
public void updateCurImgInfo(ImageInfo iminfo)
```
  - setIncludeNonBufferedChunks
```
public void setIncludeNonBufferedChunks(boolean includeNonBufferedChunks)
```
    If true, the chunks with no data (because skipped or because processed like IDAT-type) are still stored in the PngChunks list, which might be more informative. Setting this to false saves a few bytes Default: false
    
    Parameters:
    includeNonBufferedChunks -

Class ChunkSeqReaderPng

Field Summary

Fields inherited from class ar.com.hjg.pngj.ChunkSeqReader

Constructor Summary

Method Summary

Methods inherited from class ar.com.hjg.pngj.ChunkSeqReader

Methods inherited from class java.lang.Object

Field Detail

imageInfo

curImageInfo

deinterlacer

currentChunkGroup

chunksList

callbackMode

Constructor Detail

ChunkSeqReaderPng

Method Detail

shouldSkipContent

getBytesChunksLoaded

getCurrentChunkGroup

setChunksToSkip

addChunkToSkip

dontSkipChunk

firstChunksNotYetRead

postProcessChunk

countChunkTypeAsAncillary

createIdatSet

getIdatSet

isIdatKind

consume

setChunkFactory

processEndPng

getImageInfo

isInterlaced

getDeinterlacer

startNewChunk

close

getChunks

setMaxTotalBytesRead

getSkipChunkMaxSize

setSkipChunkMaxSize

getMaxBytesMetadata

setMaxBytesMetadata

getMaxTotalBytesRead

shouldCheckCrc

isCheckCrc

setCheckCrc

isCallbackMode

getChunksToSkip

setChunkLoadBehaviour

getCurImgInfo

updateCurImgInfo

setIncludeNonBufferedChunks