35 files changed, 1886 insertions, 977 deletions

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkCopyBehaviour.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkCopyBehaviour.java
index 43c0cb135..a2d976fac 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkCopyBehaviour.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkCopyBehaviour.java
@@ -1,8 +1,9 @@
 package jogamp.opengl.util.pngj.chunks;

 

 /**

- * Chunk copy policy to apply when copyng from a pngReader to a pngWriter http://www.w3.org/TR/PNG/#14

+ * Chunk copy policy to apply when copyng from a pngReader to a pngWriter.

  * <p>

+ * http://www.w3.org/TR/PNG/#14 <br>

  * These are masks, can be OR-ed

  **/

 public class ChunkCopyBehaviour {

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkHelper.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkHelper.java
index 26dafd4eb..4e8bf5635 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkHelper.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkHelper.java
@@ -1,134 +1,299 @@
-package jogamp.opengl.util.pngj.chunks;

-

-// see http://www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html

-// http://www.w3.org/TR/PNG/#5Chunk-naming-conventions

-// http://www.w3.org/TR/PNG/#table53

-import java.io.ByteArrayInputStream;

-import java.io.ByteArrayOutputStream;

-import java.io.IOException;

-import java.io.InputStream;

-import java.io.OutputStream;

-import java.util.Set;

-import java.util.zip.DeflaterOutputStream;

-import java.util.zip.InflaterInputStream;

-

-import jogamp.opengl.util.pngj.PngHelper;

-import jogamp.opengl.util.pngj.PngjException;

-

-

-public class ChunkHelper {

-	public static final String IHDR = "IHDR";

-	public static final String PLTE = "PLTE";

-	public static final String IDAT = "IDAT";

-	public static final String IEND = "IEND";

-	public static final byte[] b_IHDR = toBytes(IHDR);

-	public static final byte[] b_PLTE = toBytes(PLTE);

-	public static final byte[] b_IDAT = toBytes(IDAT);

-	public static final byte[] b_IEND = toBytes(IEND);

-

-	public static final String cHRM = "cHRM";

-	public static final String gAMA = "gAMA";

-	public static final String iCCP = "iCCP";

-	public static final String sBIT = "sBIT";

-	public static final String sRGB = "sRGB";

-	public static final String bKGD = "bKGD";

-	public static final String hIST = "hIST";

-	public static final String tRNS = "tRNS";

-	public static final String pHYs = "pHYs";

-	public static final String sPLT = "sPLT";

-	public static final String tIME = "tIME";

-	public static final String iTXt = "iTXt";

-	public static final String tEXt = "tEXt";

-	public static final String zTXt = "zTXt";

-

-	public static Set<String> KNOWN_CHUNKS_CRITICAL = PngHelper.asSet(IHDR, PLTE, IDAT, IEND);

-

-	public static byte[] toBytes(String x) {

-		return x.getBytes(PngHelper.charsetLatin1);

-	}

-

-	public static String toString(byte[] x) {

-		return new String(x, PngHelper.charsetLatin1);

-	}

-

-	public static boolean isCritical(String id) { // critical chunk ?

-		// first letter is uppercase

-		return (Character.isUpperCase(id.charAt(0)));

-	}

-

-	public static boolean isPublic(String id) { // public chunk?

-		// second letter is uppercase

-		return (Character.isUpperCase(id.charAt(1)));

-	}

-

-	/**

-	 * "Unknown" just means that our chunk factory (even when it has been augmented by client code) did not recognize its id

-	 */

-	public static boolean isUnknown(PngChunk c) {

-		return c instanceof PngChunkUNKNOWN;

-	}

-

-	public static boolean isSafeToCopy(String id) { // safe to copy?

-		// fourth letter is lower case

-		return (!Character.isUpperCase(id.charAt(3)));

-	}

-

-	public static int posNullByte(byte[] b) {

-		for (int i = 0; i < b.length; i++)

-			if (b[i] == 0)

-				return i;

-		return -1;

-	}

-

-	public static boolean shouldLoad(String id, ChunkLoadBehaviour behav) {

-		if (isCritical(id))

-			return true;

-		boolean kwown = PngChunk.isKnown(id);

-		switch (behav) {

-		case LOAD_CHUNK_ALWAYS:

-			return true;

-		case LOAD_CHUNK_IF_SAFE:

-			return kwown || isSafeToCopy(id);

-		case LOAD_CHUNK_KNOWN:

-			return kwown;

-		case LOAD_CHUNK_NEVER:

-			return false;

-		}

-		return false; // should not reach here

-	}

-

-	public final static byte[] compressBytes(byte[] ori, boolean compress) {

-		return compressBytes(ori, 0, ori.length, compress);

-	}

-

-	public static byte[] compressBytes(byte[] ori, int offset, int len, boolean compress) {

-		try {

-			ByteArrayInputStream inb = new ByteArrayInputStream(ori, offset, len);

-			InputStream in = compress ? inb : new InflaterInputStream(inb);

-			ByteArrayOutputStream outb = new ByteArrayOutputStream();

-			OutputStream out = compress ? new DeflaterOutputStream(outb) : outb;

-			shovelInToOut(in, out);

-			in.close();

-			out.close();

-			return outb.toByteArray();

-		} catch (Exception e) {

-			throw new PngjException(e);

-		}

-	}

-

-	/**

-	 * Shovels all data from an input stream to an output stream.

-	 */

-	private static void shovelInToOut(InputStream in, OutputStream out) throws IOException {

-		byte[] buffer = new byte[1024];

-		int len;

-		while ((len = in.read(buffer)) > 0) {

-			out.write(buffer, 0, len);

-		}

-	}

-

-	public static boolean maskMatch(int v, int mask) {

-		return (v & mask) != 0;

-	}

-

-}

+package jogamp.opengl.util.pngj.chunks;
+
+
+// see http://www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html
+// http://www.w3.org/TR/PNG/#5Chunk-naming-conventions
+// http://www.w3.org/TR/PNG/#table53
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.zip.Deflater;
+import java.util.zip.DeflaterOutputStream;
+import java.util.zip.Inflater;
+import java.util.zip.InflaterInputStream;
+
+import jogamp.opengl.util.pngj.PngHelperInternal;
+import jogamp.opengl.util.pngj.PngjException;
+
+
+public class ChunkHelper {
+	public static final String IHDR = "IHDR";
+	public static final String PLTE = "PLTE";
+	public static final String IDAT = "IDAT";
+	public static final String IEND = "IEND";
+	public static final byte[] b_IHDR = toBytes(IHDR);
+	public static final byte[] b_PLTE = toBytes(PLTE);
+	public static final byte[] b_IDAT = toBytes(IDAT);
+	public static final byte[] b_IEND = toBytes(IEND);
+
+	public static final String cHRM = "cHRM";
+	public static final String gAMA = "gAMA";
+	public static final String iCCP = "iCCP";
+	public static final String sBIT = "sBIT";
+	public static final String sRGB = "sRGB";
+	public static final String bKGD = "bKGD";
+	public static final String hIST = "hIST";
+	public static final String tRNS = "tRNS";
+	public static final String pHYs = "pHYs";
+	public static final String sPLT = "sPLT";
+	public static final String tIME = "tIME";
+	public static final String iTXt = "iTXt";
+	public static final String tEXt = "tEXt";
+	public static final String zTXt = "zTXt";
+
+	private static final ThreadLocal<Inflater> inflaterProvider = new ThreadLocal<Inflater>() {
+		@Override
+		protected Inflater initialValue() {
+			return new Inflater();
+		}
+	};
+
+	private static final ThreadLocal<Deflater> deflaterProvider = new ThreadLocal<Deflater>() {
+		@Override
+		protected Deflater initialValue() {
+			return new Deflater();
+		}
+	};
+
+	/*
+	 * static auxiliary buffer. any method that uses this should synchronize against this
+	 */
+	private static byte[] tmpbuffer = new byte[4096];
+
+	/**
+	 * Converts to bytes using Latin1 (ISO-8859-1)
+	 */
+	public static byte[] toBytes(String x) {
+		return x.getBytes(PngHelperInternal.charsetLatin1);
+	}
+
+	/**
+	 * Converts to String using Latin1 (ISO-8859-1)
+	 */
+	public static String toString(byte[] x) {
+		return new String(x, PngHelperInternal.charsetLatin1);
+	}
+
+	/**
+	 * Converts to String using Latin1 (ISO-8859-1)
+	 */
+	public static String toString(byte[] x, int offset, int len) {
+		return new String(x, offset, len, PngHelperInternal.charsetLatin1);
+	}
+
+	/**
+	 * Converts to bytes using UTF-8
+	 */
+	public static byte[] toBytesUTF8(String x) {
+		return x.getBytes(PngHelperInternal.charsetUTF8);
+	}
+
+	/**
+	 * Converts to string using UTF-8
+	 */
+	public static String toStringUTF8(byte[] x) {
+		return new String(x, PngHelperInternal.charsetUTF8);
+	}
+
+	/**
+	 * Converts to string using UTF-8
+	 */
+	public static String toStringUTF8(byte[] x, int offset, int len) {
+		return new String(x, offset, len, PngHelperInternal.charsetUTF8);
+	}
+
+	/**
+	 * critical chunk : first letter is uppercase
+	 */
+	public static boolean isCritical(String id) {
+		return (Character.isUpperCase(id.charAt(0)));
+	}
+
+	/**
+	 * public chunk: second letter is uppercase
+	 */
+	public static boolean isPublic(String id) { //
+		return (Character.isUpperCase(id.charAt(1)));
+	}
+
+	/**
+	 * Safe to copy chunk: fourth letter is lower case
+	 */
+	public static boolean isSafeToCopy(String id) {
+		return (!Character.isUpperCase(id.charAt(3)));
+	}
+
+	/**
+	 * "Unknown" just means that our chunk factory (even when it has been
+	 * augmented by client code) did not recognize its id
+	 */
+	public static boolean isUnknown(PngChunk c) {
+		return c instanceof PngChunkUNKNOWN;
+	}
+
+	/**
+	 * Finds position of null byte in array
+	 *
+	 * @param b
+	 * @return -1 if not found
+	 */
+	public static int posNullByte(byte[] b) {
+		for (int i = 0; i < b.length; i++)
+			if (b[i] == 0)
+				return i;
+		return -1;
+	}
+
+	/**
+	 * Decides if a chunk should be loaded, according to a ChunkLoadBehaviour
+	 *
+	 * @param id
+	 * @param behav
+	 * @return true/false
+	 */
+	public static boolean shouldLoad(String id, ChunkLoadBehaviour behav) {
+		if (isCritical(id))
+			return true;
+		boolean kwown = PngChunk.isKnown(id);
+		switch (behav) {
+		case LOAD_CHUNK_ALWAYS:
+			return true;
+		case LOAD_CHUNK_IF_SAFE:
+			return kwown || isSafeToCopy(id);
+		case LOAD_CHUNK_KNOWN:
+			return kwown;
+		case LOAD_CHUNK_NEVER:
+			return false;
+		}
+		return false; // should not reach here
+	}
+
+	public final static byte[] compressBytes(byte[] ori, boolean compress) {
+		return compressBytes(ori, 0, ori.length, compress);
+	}
+
+	public static byte[] compressBytes(byte[] ori, int offset, int len, boolean compress) {
+		try {
+			ByteArrayInputStream inb = new ByteArrayInputStream(ori, offset, len);
+			InputStream in = compress ? inb : new InflaterInputStream(inb, getInflater());
+			ByteArrayOutputStream outb = new ByteArrayOutputStream();
+			OutputStream out = compress ? new DeflaterOutputStream(outb) : outb;
+			shovelInToOut(in, out);
+			in.close();
+			out.close();
+			return outb.toByteArray();
+		} catch (Exception e) {
+			throw new PngjException(e);
+		}
+	}
+
+	/**
+	 * Shovels all data from an input stream to an output stream.
+	 */
+	private static void shovelInToOut(InputStream in, OutputStream out) throws IOException {
+		synchronized (tmpbuffer) {
+			int len;
+			while ((len = in.read(tmpbuffer)) > 0) {
+				out.write(tmpbuffer, 0, len);
+			}
+		}
+	}
+
+	public static boolean maskMatch(int v, int mask) {
+		return (v & mask) != 0;
+	}
+
+	/**
+	 * Returns only the chunks that "match" the predicate
+	 *
+	 * See also trimList()
+	 */
+	public static List<PngChunk> filterList(List<PngChunk> target, ChunkPredicate predicateKeep) {
+		List<PngChunk> result = new ArrayList<PngChunk>();
+		for (PngChunk element : target) {
+			if (predicateKeep.match(element)) {
+				result.add(element);
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * Remove (in place) the chunks that "match" the predicate
+	 *
+	 * See also filterList
+	 */
+	public static int trimList(List<PngChunk> target, ChunkPredicate predicateRemove) {
+		Iterator<PngChunk> it = target.iterator();
+		int cont = 0;
+		while (it.hasNext()) {
+			PngChunk c = it.next();
+			if (predicateRemove.match(c)) {
+				it.remove();
+				cont++;
+			}
+		}
+		return cont;
+	}
+
+	/**
+	 * MY adhoc criteria: two chunks are "equivalent" ("practically equal") if
+	 * they have same id and (perhaps, if multiple are allowed) if the match
+	 * also in some "internal key" (eg: key for string values, palette for sPLT,
+	 * etc)
+	 *
+	 * Notice that the use of this is optional, and that the PNG standard allows
+	 * Text chunks that have same key
+	 *
+	 * @return true if "equivalent"
+	 */
+	public static final boolean equivalent(PngChunk c1, PngChunk c2) {
+		if (c1 == c2)
+			return true;
+		if (c1 == null || c2 == null || !c1.id.equals(c2.id))
+			return false;
+		// same id
+		if (c1.getClass() != c2.getClass())
+			return false; // should not happen
+		if (!c2.allowsMultiple())
+			return true;
+		if (c1 instanceof PngChunkTextVar) {
+			return ((PngChunkTextVar) c1).getKey().equals(((PngChunkTextVar) c2).getKey());
+		}
+		if (c1 instanceof PngChunkSPLT) {
+			return ((PngChunkSPLT) c1).getPalName().equals(((PngChunkSPLT) c2).getPalName());
+		}
+		// unknown chunks that allow multiple? consider they don't match
+		return false;
+	}
+
+	public static boolean isText(PngChunk c) {
+		return c instanceof PngChunkTextVar;
+	}
+
+	/**
+	 * thread-local inflater, just reset : this should be only used for short
+	 * individual chunks compression
+	 */
+	public static Inflater getInflater() {
+		Inflater inflater = inflaterProvider.get();
+		inflater.reset();
+		return inflater;
+	}
+
+	/**
+	 * thread-local deflater, just reset : this should be only used for short
+	 * individual chunks decompression
+	 */
+	public static Deflater getDeflater() {
+		Deflater deflater = deflaterProvider.get();
+		deflater.reset();
+		return deflater;
+	}
+
+}
diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkList.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkList.java
deleted file mode 100644
index badbbd0e8..000000000
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkList.java
+++ /dev/null
@@ -1,282 +0,0 @@
-package jogamp.opengl.util.pngj.chunks;

-

-import java.io.OutputStream;

-import java.util.ArrayList;

-import java.util.Iterator;

-import java.util.LinkedHashSet;

-import java.util.List;

-import java.util.Set;

-

-import jogamp.opengl.util.pngj.ImageInfo;

-import jogamp.opengl.util.pngj.PngjException;

-

-

-/**

- * All chunks that form an image, read or to be written

- * 

- * chunks include all chunks, but IDAT is a single pseudo chunk without data

- **/

-public class ChunkList {

-	// ref: http://www.w3.org/TR/PNG/#table53

-	public static final int CHUNK_GROUP_0_IDHR = 0; // required - single

-	public static final int CHUNK_GROUP_1_AFTERIDHR = 1; // optional - multiple

-	public static final int CHUNK_GROUP_2_PLTE = 2; // optional - single

-	public static final int CHUNK_GROUP_3_AFTERPLTE = 3; // optional - multple

-	public static final int CHUNK_GROUP_4_IDAT = 4; // required (single pseudo chunk)

-	public static final int CHUNK_GROUP_5_AFTERIDAT = 5; // optional - multple

-	public static final int CHUNK_GROUP_6_END = 6; // only 1 chunk - requried

-

-	/**

-	 * All chunks, read, written (does not include IHDR, IDAT, END for written)

-	 */

-	private List<PngChunk> chunks = new ArrayList<PngChunk>();

-

-	/**

-	 * chunks not yet writen - does not include IHDR, IDAT, END, perhaps yes PLTE

-	 */

-	private Set<PngChunk> queuedChunks = new LinkedHashSet<PngChunk>();

-

-	final ImageInfo imageInfo; // only required for writing

-

-	public ChunkList(ImageInfo imfinfo) {

-		this.imageInfo = imfinfo;

-	}

-

-	/**

-	 * Adds chunk in next position. This is used when reading

-	 */

-	public void appendReadChunk(PngChunk chunk, int chunkGroup) {

-		chunk.setChunkGroup(chunkGroup);

-		chunks.add(chunk);

-	}

-

-	public List<PngChunk> getById(String id, boolean includeQueued, boolean includeProcessed) {

-		List<PngChunk> list = new ArrayList<PngChunk>();

-		if (includeQueued)

-			for (PngChunk c : queuedChunks)

-				if (c.id.equals(id))

-					list.add(c);

-		if (includeProcessed)

-			for (PngChunk c : chunks)

-				if (c.id.equals(id))

-					list.add(c);

-		return list;

-	}

-

-	/**

-	 * Remove Chunk: only from queued

-	 */

-	public boolean removeChunk(PngChunk c) {

-		return queuedChunks.remove(c);

-	}

-

-	/**

-	 * add chunk to write queue

-	 */

-	public void queueChunk(PngChunk chunk, boolean replace, boolean priority) {

-		chunk.setPriority(priority);

-		if (replace) {

-			List<PngChunk> current = getById(chunk.id, true, false);

-			for (PngChunk chunk2 : current)

-				removeChunk(chunk2);

-		}

-		queuedChunks.add(chunk);

-	}

-

-	/**

-	 * this should be called only for ancillary chunks and PLTE (groups 1 - 3 - 5)

-	 **/

-	private static boolean shouldWrite(PngChunk c, int currentGroup) {

-		if (currentGroup == CHUNK_GROUP_2_PLTE)

-			return c.id.equals(ChunkHelper.PLTE);

-		if (currentGroup % 2 == 0)

-			throw new RuntimeException("?");

-		int minChunkGroup, maxChunkGroup;

-		if (c.mustGoBeforePLTE())

-			minChunkGroup = maxChunkGroup = ChunkList.CHUNK_GROUP_1_AFTERIDHR;

-		else if (c.mustGoBeforeIDAT()) {

-			maxChunkGroup = ChunkList.CHUNK_GROUP_3_AFTERPLTE;

-			minChunkGroup = c.mustGoAfterPLTE() ? ChunkList.CHUNK_GROUP_3_AFTERPLTE : ChunkList.CHUNK_GROUP_1_AFTERIDHR;

-		} else {

-			maxChunkGroup = ChunkList.CHUNK_GROUP_5_AFTERIDAT;

-			minChunkGroup = ChunkList.CHUNK_GROUP_1_AFTERIDHR;

-		}

-

-		int preferred = maxChunkGroup;

-		if (c.isWritePriority())

-			preferred = minChunkGroup;

-		if (ChunkHelper.isUnknown(c) && c.getChunkGroup() > 0)

-			preferred = c.getChunkGroup();

-		if (currentGroup == preferred)

-			return true;

-		if (currentGroup > preferred && currentGroup <= maxChunkGroup)

-			return true;

-		return false;

-	}

-

-	public int writeChunks(OutputStream os, int currentGroup) {

-		int cont = 0;

-		Iterator<PngChunk> it = queuedChunks.iterator();

-		while (it.hasNext()) {

-			PngChunk c = it.next();

-			if (!shouldWrite(c, currentGroup))

-				continue;

-			c.write(os);

-			chunks.add(c);

-			c.setChunkGroup(currentGroup);

-			it.remove();

-			cont++;

-		}

-		return cont;

-	}

-

-	/**

-	 * returns a copy of processed (read or writen) chunks

-	 */

-	public List<PngChunk> getChunks() {

-		return new ArrayList<PngChunk>(chunks);

-	}

-

-	public List<String> getChunksUnkown() {

-		List<String> l = new ArrayList<String>();

-		for (PngChunk chunk : chunks)

-			if (ChunkHelper.isUnknown(chunk))

-				l.add(chunk.id);

-		return l;

-	}

-

-	/**

-	 * returns a copy of queued (for write) chunks

-	 */

-	public List<PngChunk> getQueuedChunks() {

-		return new ArrayList<PngChunk>(queuedChunks);

-	}

-

-	/**

-	 * behaviour:

-	 * 

-	 * a chunk already processed matches : exception a chunk queued matches and overwrite=true: replace it , return true

-	 * a chunk queued matches and overwrite=false: do nothing, return false no matching: set it, return true

-	 * 

-	 * @param c

-	 * @param overwriteIfPresent

-	 * @return true if added chunk

-	 */

-	public boolean setChunk(PngChunk c, boolean overwriteIfPresent) {

-		List<PngChunk> list = getMatching(c, false, true); // processed

-		if (!list.isEmpty())

-			throw new PngjException("chunk " + c.id + " already set ");

-		list = getMatching(c, true, false); // queued

-		if (!list.isEmpty()) {

-			if (overwriteIfPresent) {

-				for (PngChunk cx : list)

-					removeChunk(cx);

-				queueChunk(c, false, false);

-				return true;

-			}

-			return false;

-		}

-		queueChunk(c, false, false);

-		return true;

-	}

-

-	/**

-	 * returns only one chunk or null if nothing found - does not include queued

-	 * 

-	 * If innerid!=null , the chunk is assumed to be PngChunkTextVar or PngChunkSPLT, and filtered by that id

-	 * 

-	 * If more than one chunk (after filtering by inner id) is found, then an exception is thrown (failifMultiple=true)

-	 * or the last one is returned (failifMultiple=false)

-	 **/

-	public PngChunk getChunk1(String id, String innerid, boolean failIfMultiple) {

-		List<PngChunk> list = getChunks(id);

-		if (list.isEmpty())

-			return null;

-		if (innerid != null) {

-			List<PngChunk> list2 = new ArrayList<PngChunk>();

-			for (PngChunk c : list) {

-				if (c instanceof PngChunkTextVar)

-					if (((PngChunkTextVar) c).getKey().equals(innerid))

-						list2.add(c);

-				if (c instanceof PngChunkSPLT)

-					if (((PngChunkSPLT) c).getPalName().equals(innerid))

-						list2.add(c);

-			}

-			list = list2;

-		}

-		if (list.isEmpty())

-			return null;

-		if (list.size() > 1 && failIfMultiple)

-			throw new PngjException("unexpected multiple chunks id=" + id);

-		return list.get(list.size() - 1);

-	}

-

-	public PngChunk getChunk1(String id) {

-		return getChunk1(id, null, true);

-	}

-	

-	public List<PngChunk> getChunks(String id) { // not including queued

-		return getById(id, false, true);

-	}

-

-	private List<PngChunk> getMatching(PngChunk cnew, boolean includeQueued, boolean includeProcessed) {

-		List<PngChunk> list = new ArrayList<PngChunk>();

-		if (includeQueued)

-			for (PngChunk c : getQueuedChunks())

-				if (matches(cnew, c))

-					list.add(c);

-		if (includeProcessed)

-			for (PngChunk c : getChunks())

-				if (matches(cnew, c))

-					list.add(c);

-		return list;

-	}

-

-	/**

-	 * MY adhoc criteria: two chunks "match" if they have same id and (perhaps, if multiple are allowed) if the match

-	 * also in some "internal key" (eg: key for string values, palette for sPLT, etc)

-	 * 

-	 * @return true if "matches"

-	 */

-	public static boolean matches(PngChunk c2, PngChunk c1) {

-		if (c1 == null || c2 == null || !c1.id.equals(c2.id))

-			return false;

-		// same id

-		if (c1.getClass() != c2.getClass())

-			return false; // should not happen

-		if (!c2.allowsMultiple())

-			return true;

-		if (c1 instanceof PngChunkTextVar) {

-			return ((PngChunkTextVar) c1).getKey().equals(((PngChunkTextVar) c2).getKey());

-		}

-		if (c1 instanceof PngChunkSPLT) {

-			return ((PngChunkSPLT) c1).getPalName().equals(((PngChunkSPLT) c2).getPalName());

-		}

-		// unknown chunks that allow multiple? consider they don't match

-		return false;

-	}

-	

-	public String toString() {

-		return "ChunkList: processed: " + chunks.size() + " queue: " + queuedChunks.size();

-	}

-

-	/**

-	 * for debugging

-	 */

-	public String toStringFull() {

-		StringBuilder sb = new StringBuilder(toString());

-		sb.append("\n Processed:\n");

-		for (PngChunk chunk : chunks) {

-			sb.append(chunk).append(" G=" + chunk.getChunkGroup() + "\n");

-		}

-		if (!queuedChunks.isEmpty()) {

-			sb.append(" Queued:\n");

-			for (PngChunk chunk : chunks) {

-				sb.append(chunk).append("\n");

-			}

-

-		}

-		return sb.toString();

-	}

-

-}

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkLoadBehaviour.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkLoadBehaviour.java
index a3f85355c..1fa00380a 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkLoadBehaviour.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkLoadBehaviour.java
@@ -1,10 +1,28 @@
 package jogamp.opengl.util.pngj.chunks;

 

+/**

+ * Defines gral strategy about what to do with ancillary (non-critical) chunks

+ * when reading

+ */

 public enum ChunkLoadBehaviour {

-	// what to do with non critical chunks when reading?

-	LOAD_CHUNK_NEVER, /* ignore non-critical chunks */

-	LOAD_CHUNK_KNOWN, /* load chunk if 'known' */

-	LOAD_CHUNK_IF_SAFE, /* load chunk if 'known' or safe to copy */

-	LOAD_CHUNK_ALWAYS /* load chunk always */

-	;

+	/**

+	 * All non-critical chunks are skipped

+	 */

+	LOAD_CHUNK_NEVER,

+	/**

+	 * Ancillary chunks are loaded only if 'known' (registered with the

+	 * factory).

+	 */

+	LOAD_CHUNK_KNOWN,

+	/**

+	 *

+	 * Load chunk if "known" or "safe to copy".

+	 */

+	LOAD_CHUNK_IF_SAFE,

+	/**

+	 * Load all chunks. <br>

+	 * Notice that other restrictions might apply, see

+	 * PngReader.skipChunkMaxSize PngReader.skipChunkIds

+	 */

+	LOAD_CHUNK_ALWAYS;

 }

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkPredicate.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkPredicate.java
new file mode 100644
index 000000000..4695ccf44
--- /dev/null
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkPredicate.java
@@ -0,0 +1,14 @@
+package jogamp.opengl.util.pngj.chunks;
+
+/**
+ * Decides if another chunk "matches", according to some criterion
+ */
+public interface ChunkPredicate {
+	/**
+	 * The other chunk matches with this one
+	 *
+	 * @param chunk
+	 * @return true if match
+	 */
+	boolean match(PngChunk chunk);
+}
diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkRaw.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkRaw.java
index 6770d5e95..dcb1958df 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkRaw.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunkRaw.java
@@ -5,24 +5,51 @@ import java.io.InputStream;
 import java.io.OutputStream;

 import java.util.zip.CRC32;

 

-import jogamp.opengl.util.pngj.PngHelper;

+import jogamp.opengl.util.pngj.PngHelperInternal;

 import jogamp.opengl.util.pngj.PngjBadCrcException;

 import jogamp.opengl.util.pngj.PngjOutputException;

 

 

 /**

- * Wraps the raw chunk data Short lived object, to be created while serialing/deserializing Do not reuse it for

- * different chunks

- * 

- * see http://www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html

+ * Raw (physical) chunk.

+ * <p>

+ * Short lived object, to be created while serialing/deserializing Do not reuse

+ * it for different chunks. <br>

+ * See http://www.libpng.org/pub/png/spec/1.2/PNG-Structure.html

  */

 public class ChunkRaw {

+	/**

+	 * The length counts only the data field, not itself, the chunk type code,

+	 * or the CRC. Zero is a valid length. Although encoders and decoders should

+	 * treat the length as unsigned, its value must not exceed 231-1 bytes.

+	 */

 	public final int len;

-	public final byte[] idbytes = new byte[4]; // 4 bytes

-	public byte[] data = null; // crc not included

+

+	/**

+	 * A 4-byte chunk type code. uppercase and lowercase ASCII letters

+	 */

+	public final byte[] idbytes = new byte[4];

+

+	/**

+	 * The data bytes appropriate to the chunk type, if any. This field can be

+	 * of zero length. Does not include crc

+	 */

+	public byte[] data = null;

+	/**

+	 * A 4-byte CRC (Cyclic Redundancy Check) calculated on the preceding bytes

+	 * in the chunk, including the chunk type code and chunk data fields, but

+	 * not including the length field.

+	 */

 	private int crcval = 0;

 

-	// public int offset=-1; // only for read chunks - informational

+	/**

+	 * @param len

+	 *            : data len

+	 * @param idbytes

+	 *            : chunk type (deep copied)

+	 * @param alloc

+	 *            : it true, the data array will be allocced

+	 */

 	public ChunkRaw(int len, byte[] idbytes, boolean alloc) {

 		this.len = len;

 		System.arraycopy(idbytes, 0, this.idbytes, 0, 4);

@@ -30,54 +57,60 @@ public class ChunkRaw {
 			allocData();

 	}

 

-	public void writeChunk(OutputStream os) {

-		if (idbytes.length != 4)

-			throw new PngjOutputException("bad chunkid [" + ChunkHelper.toString(idbytes) + "]");

-		computeCrc();

-		PngHelper.writeInt4(os, len);

-		PngHelper.writeBytes(os, idbytes);

-		if (len > 0)

-			PngHelper.writeBytes(os, data, 0, len);

-		// System.err.println("writing chunk " + this.toString() + "crc=" + crcval);

-

-		PngHelper.writeInt4(os, crcval);

+	private void allocData() {

+		if (data == null || data.length < len)

+			data = new byte[len];

 	}

 

 	/**

-	 * called after setting data, before writing to os

+	 * this is called after setting data, before writing to os

 	 */

-	private void computeCrc() {

-		CRC32 crcengine = PngHelper.getCRC();

+	private int computeCrc() {

+		CRC32 crcengine = PngHelperInternal.getCRC();

 		crcengine.reset();

 		crcengine.update(idbytes, 0, 4);

 		if (len > 0)

 			crcengine.update(data, 0, len); //

-		crcval = (int) crcengine.getValue();

+		return (int) crcengine.getValue();

 	}

 

-	public String toString() {

-		return "chunkid=" + ChunkHelper.toString(idbytes) + " len=" + len;

+	/**

+	 * Computes the CRC and writes to the stream. If error, a

+	 * PngjOutputException is thrown

+	 */

+	public void writeChunk(OutputStream os) {

+		if (idbytes.length != 4)

+			throw new PngjOutputException("bad chunkid [" + ChunkHelper.toString(idbytes) + "]");

+		crcval = computeCrc();

+		PngHelperInternal.writeInt4(os, len);

+		PngHelperInternal.writeBytes(os, idbytes);

+		if (len > 0)

+			PngHelperInternal.writeBytes(os, data, 0, len);

+		PngHelperInternal.writeInt4(os, crcval);

 	}

 

 	/**

-	 * position before: just after chunk id. positon after: after crc Data should be already allocated. Checks CRC

-	 * Return number of byte read.

+	 * position before: just after chunk id. positon after: after crc Data

+	 * should be already allocated. Checks CRC Return number of byte read.

 	 */

-	public int readChunkData(InputStream is) {

-		PngHelper.readBytes(is, data, 0, len);

-		int crcori = PngHelper.readInt4(is);

-		computeCrc();

-		if (crcori != crcval)

-			throw new PngjBadCrcException("crc invalid for chunk " + toString() + " calc=" + crcval + " read=" + crcori);

+	public int readChunkData(InputStream is, boolean checkCrc) {

+		PngHelperInternal.readBytes(is, data, 0, len);

+		crcval = PngHelperInternal.readInt4(is);

+		if (checkCrc) {

+			int crc = computeCrc();

+			if (crc != crcval)

+				throw new PngjBadCrcException("chunk: " + this + " crc calc=" + crc + " read=" + crcval);

+		}

 		return len + 4;

 	}

 

-	public ByteArrayInputStream getAsByteStream() { // only the data

+	ByteArrayInputStream getAsByteStream() { // only the data

 		return new ByteArrayInputStream(data);

 	}

 

-	private void allocData() {

-		if (data == null || data.length < len)

-			data = new byte[len];

+	@Override

+	public String toString() {

+		return "chunkid=" + ChunkHelper.toString(idbytes) + " len=" + len;

 	}

+

 }

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunksList.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunksList.java
new file mode 100644
index 000000000..75107d761
--- /dev/null
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunksList.java
@@ -0,0 +1,181 @@
+package jogamp.opengl.util.pngj.chunks;

+

+import java.util.ArrayList;

+import java.util.HashMap;

+import java.util.List;

+

+import jogamp.opengl.util.pngj.ImageInfo;

+import jogamp.opengl.util.pngj.PngjException;

+

+/**

+ * All chunks that form an image, read or to be written.

+ * <p>

+ * chunks include all chunks, but IDAT is a single pseudo chunk without data

+ **/

+public class ChunksList {

+	// ref: http://www.w3.org/TR/PNG/#table53

+	public static final int CHUNK_GROUP_0_IDHR = 0; // required - single

+	public static final int CHUNK_GROUP_1_AFTERIDHR = 1; // optional - multiple

+	public static final int CHUNK_GROUP_2_PLTE = 2; // optional - single

+	public static final int CHUNK_GROUP_3_AFTERPLTE = 3; // optional - multple

+	public static final int CHUNK_GROUP_4_IDAT = 4; // required (single pseudo chunk)

+	public static final int CHUNK_GROUP_5_AFTERIDAT = 5; // optional - multple

+	public static final int CHUNK_GROUP_6_END = 6; // only 1 chunk - requried

+

+	/**

+	 * All chunks, read (or written)

+	 *

+	 * But IDAT is a single pseudo chunk without data

+	 */

+	protected List<PngChunk> chunks = new ArrayList<PngChunk>();

+

+	final ImageInfo imageInfo; // only required for writing

+

+	public ChunksList(ImageInfo imfinfo) {

+		this.imageInfo = imfinfo;

+	}

+

+	/**

+	 * Keys of processed (read or writen) chunks

+	 *

+	 * @return key:chunk id, val: number of occurrences

+	 */

+	public HashMap<String, Integer> getChunksKeys() {

+		HashMap<String, Integer> ck = new HashMap<String, Integer>();

+		for (PngChunk c : chunks) {

+			ck.put(c.id, ck.containsKey(c.id) ? ck.get(c.id) + 1 : 1);

+		}

+		return ck;

+	}

+

+	/**

+	 * Returns a copy of the list (but the chunks are not copied) <b> This

+	 * should not be used for general metadata handling

+	 */

+	public ArrayList<PngChunk> getChunks() {

+		return new ArrayList<PngChunk>(chunks);

+	}

+

+	protected static List<PngChunk> getXById(final List<PngChunk> list, final String id, final String innerid) {

+		if (innerid == null)

+			return ChunkHelper.filterList(list, new ChunkPredicate() {

+				@Override

+				public boolean match(PngChunk c) {

+					return c.id.equals(id);

+				}

+			});

+		else

+			return ChunkHelper.filterList(list, new ChunkPredicate() {

+				@Override

+				public boolean match(PngChunk c) {

+					if (!c.id.equals(id))

+						return false;

+					if (c instanceof PngChunkTextVar && !((PngChunkTextVar) c).getKey().equals(innerid))

+						return false;

+					if (c instanceof PngChunkSPLT && !((PngChunkSPLT) c).getPalName().equals(innerid))

+						return false;

+					return true;

+				}

+			});

+	}

+

+	/**

+	 * Adds chunk in next position. This is used onyl by the pngReader

+	 */

+	public void appendReadChunk(PngChunk chunk, int chunkGroup) {

+		chunk.setChunkGroup(chunkGroup);

+		chunks.add(chunk);

+	}

+

+	/**

+	 * All chunks with this ID

+	 *

+	 * @param id

+	 * @return List, empty if none

+	 */

+	public List<? extends PngChunk> getById(final String id) {

+		return getById(id, null);

+	}

+

+	/**

+	 * If innerid!=null and the chunk is PngChunkTextVar or PngChunkSPLT, it's

+	 * filtered by that id

+	 *

+	 * @param id

+	 * @return innerid Only used for text and SPLT chunks

+	 * @return List, empty if none

+	 */

+	public List<? extends PngChunk> getById(final String id, final String innerid) {

+		return getXById(chunks, id, innerid);

+	}

+

+	/**

+	 * Returns only one chunk

+	 *

+	 * @param id

+	 * @return First chunk found, null if not found

+	 */

+	public PngChunk getById1(final String id) {

+		return getById1(id, false);

+	}

+

+	/**

+	 * Returns only one chunk or null if nothing found - does not include queued

+	 * <p>

+	 * If more than one chunk is found, then an exception is thrown

+	 * (failifMultiple=true or chunk is single) or the last one is returned

+	 * (failifMultiple=false)

+	 **/

+	public PngChunk getById1(final String id, final boolean failIfMultiple) {

+		return getById1(id, null, failIfMultiple);

+	}

+

+	/**

+	 * Returns only one chunk or null if nothing found - does not include queued

+	 * <p>

+	 * If more than one chunk (after filtering by inner id) is found, then an

+	 * exception is thrown (failifMultiple=true or chunk is single) or the last

+	 * one is returned (failifMultiple=false)

+	 **/

+	public PngChunk getById1(final String id, final String innerid, final boolean failIfMultiple) {

+		List<? extends PngChunk> list = getById(id, innerid);

+		if (list.isEmpty())

+			return null;

+		if (list.size() > 1 && (failIfMultiple || !list.get(0).allowsMultiple()))

+			throw new PngjException("unexpected multiple chunks id=" + id);

+		return list.get(list.size() - 1);

+	}

+

+	/**

+	 * Finds all chunks "equivalent" to this one

+	 *

+	 * @param c2

+	 * @return Empty if nothing found

+	 */

+	public List<PngChunk> getEquivalent(final PngChunk c2) {

+		return ChunkHelper.filterList(chunks, new ChunkPredicate() {

+			@Override

+			public boolean match(PngChunk c) {

+				return ChunkHelper.equivalent(c, c2);

+			}

+		});

+	}

+

+	@Override

+	public String toString() {

+		return "ChunkList: read: " + chunks.size();

+	}

+

+	/**

+	 * for debugging

+	 */

+	public String toStringFull() {

+		StringBuilder sb = new StringBuilder(toString());

+		sb.append("\n Read:\n");

+		for (PngChunk chunk : chunks) {

+			sb.append(chunk).append(" G=" + chunk.getChunkGroup() + "\n");

+		}

+		return sb.toString();

+	}

+

+}

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunksListForWrite.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunksListForWrite.java
new file mode 100644
index 000000000..c502e9071
--- /dev/null
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/ChunksListForWrite.java
@@ -0,0 +1,176 @@
+package jogamp.opengl.util.pngj.chunks;
+
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+
+import jogamp.opengl.util.pngj.ImageInfo;
+import jogamp.opengl.util.pngj.PngjException;
+import jogamp.opengl.util.pngj.PngjOutputException;
+
+public class ChunksListForWrite extends ChunksList {
+
+	/**
+	 * chunks not yet writen - does not include IHDR, IDAT, END, perhaps yes
+	 * PLTE
+	 */
+	private final List<PngChunk> queuedChunks = new ArrayList<PngChunk>();
+
+	// redundant, just for eficciency
+	private HashMap<String, Integer> alreadyWrittenKeys = new HashMap<String, Integer>();
+
+	public ChunksListForWrite(ImageInfo imfinfo) {
+		super(imfinfo);
+	}
+
+	/**
+	 * Same as getById(), but looking in the queued chunks
+	 */
+	public List<? extends PngChunk> getQueuedById(final String id) {
+		return getQueuedById(id, null);
+	}
+
+	/**
+	 * Same as getById(), but looking in the queued chunks
+	 */
+	public List<? extends PngChunk> getQueuedById(final String id, final String innerid) {
+		return getXById(queuedChunks, id, innerid);
+	}
+
+	/**
+	 * Same as getById1(), but looking in the queued chunks
+	 **/
+	public PngChunk getQueuedById1(final String id, final String innerid, final boolean failIfMultiple) {
+		List<? extends PngChunk> list = getQueuedById(id, innerid);
+		if (list.isEmpty())
+			return null;
+		if (list.size() > 1 && (failIfMultiple || !list.get(0).allowsMultiple()))
+			throw new PngjException("unexpected multiple chunks id=" + id);
+		return list.get(list.size() - 1);
+	}
+
+	/**
+	 * Same as getById1(), but looking in the queued chunks
+	 **/
+	public PngChunk getQueuedById1(final String id, final boolean failIfMultiple) {
+		return getQueuedById1(id, null, failIfMultiple);
+	}
+
+	/**
+	 * Same as getById1(), but looking in the queued chunks
+	 **/
+	public PngChunk getQueuedById1(final String id) {
+		return getQueuedById1(id, false);
+	}
+
+	/**
+	 * Remove Chunk: only from queued
+	 *
+	 * WARNING: this depends on c.equals() implementation, which is
+	 * straightforward for SingleChunks. For MultipleChunks, it will normally
+	 * check for reference equality!
+	 */
+	public boolean removeChunk(PngChunk c) {
+		return queuedChunks.remove(c);
+	}
+
+	/**
+	 * Adds chunk to queue
+	 *
+	 * Does not check for duplicated or anything
+	 *
+	 * @param c
+	 */
+	public boolean queue(PngChunk c) {
+		queuedChunks.add(c);
+		return true;
+	}
+
+	/**
+	 * this should be called only for ancillary chunks and PLTE (groups 1 - 3 -
+	 * 5)
+	 **/
+	private static boolean shouldWrite(PngChunk c, int currentGroup) {
+		if (currentGroup == CHUNK_GROUP_2_PLTE)
+			return c.id.equals(ChunkHelper.PLTE);
+		if (currentGroup % 2 == 0)
+			throw new PngjOutputException("bad chunk group?");
+		int minChunkGroup, maxChunkGroup;
+		if (c.getOrderingConstraint().mustGoBeforePLTE())
+			minChunkGroup = maxChunkGroup = ChunksList.CHUNK_GROUP_1_AFTERIDHR;
+		else if (c.getOrderingConstraint().mustGoBeforeIDAT()) {
+			maxChunkGroup = ChunksList.CHUNK_GROUP_3_AFTERPLTE;
+			minChunkGroup = c.getOrderingConstraint().mustGoAfterPLTE() ? ChunksList.CHUNK_GROUP_3_AFTERPLTE
+					: ChunksList.CHUNK_GROUP_1_AFTERIDHR;
+		} else {
+			maxChunkGroup = ChunksList.CHUNK_GROUP_5_AFTERIDAT;
+			minChunkGroup = ChunksList.CHUNK_GROUP_1_AFTERIDHR;
+		}
+
+		int preferred = maxChunkGroup;
+		if (c.hasPriority())
+			preferred = minChunkGroup;
+		if (ChunkHelper.isUnknown(c) && c.getChunkGroup() > 0)
+			preferred = c.getChunkGroup();
+		if (currentGroup == preferred)
+			return true;
+		if (currentGroup > preferred && currentGroup <= maxChunkGroup)
+			return true;
+		return false;
+	}
+
+	public int writeChunks(OutputStream os, int currentGroup) {
+		int cont = 0;
+		Iterator<PngChunk> it = queuedChunks.iterator();
+		while (it.hasNext()) {
+			PngChunk c = it.next();
+			if (!shouldWrite(c, currentGroup))
+				continue;
+			if (ChunkHelper.isCritical(c.id) && !c.id.equals(ChunkHelper.PLTE))
+				throw new PngjOutputException("bad chunk queued: " + c);
+			if (alreadyWrittenKeys.containsKey(c.id) && !c.allowsMultiple())
+				throw new PngjOutputException("duplicated chunk does not allow multiple: " + c);
+			c.write(os);
+			chunks.add(c);
+			alreadyWrittenKeys.put(c.id, alreadyWrittenKeys.containsKey(c.id) ? alreadyWrittenKeys.get(c.id) + 1 : 1);
+			c.setChunkGroup(currentGroup);
+			it.remove();
+			cont++;
+		}
+		return cont;
+	}
+
+	/**
+	 * warning: this is NOT a copy, do not modify
+	 */
+	public List<PngChunk> getQueuedChunks() {
+		return queuedChunks;
+	}
+
+	@Override
+	public String toString() {
+		return "ChunkList: written: " + chunks.size() + " queue: " + queuedChunks.size();
+	}
+
+	/**
+	 * for debugging
+	 */
+	@Override
+	public String toStringFull() {
+		StringBuilder sb = new StringBuilder(toString());
+		sb.append("\n Written:\n");
+		for (PngChunk chunk : chunks) {
+			sb.append(chunk).append(" G=" + chunk.getChunkGroup() + "\n");
+		}
+		if (!queuedChunks.isEmpty()) {
+			sb.append(" Queued:\n");
+			for (PngChunk chunk : queuedChunks) {
+				sb.append(chunk).append("\n");
+			}
+
+		}
+		return sb.toString();
+	}
+}
diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunk.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunk.java
index 2df9fd1f3..6cd86eb98 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunk.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunk.java
@@ -6,26 +6,91 @@ import java.util.HashMap;
 import java.util.Map;

 

 import jogamp.opengl.util.pngj.ImageInfo;

-import jogamp.opengl.util.pngj.PngjException;

+import jogamp.opengl.util.pngj.PngjExceptionInternal;

 

-

-// see http://www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html

+/**

+ * Represents a instance of a PNG chunk.

+ * <p>

+ * See <a

+ * href="http://www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html">http://www

+ * .libpng.org/pub/png/spec/1.2/PNG-Chunks .html</a> </a>

+ * <p>

+ * Concrete classes should extend {@link PngChunkSingle} or

+ * {@link PngChunkMultiple}

+ * <p>

+ * Note that some methods/fields are type-specific (getOrderingConstraint(),

+ * allowsMultiple()),<br>

+ * some are 'almost' type-specific (id,crit,pub,safe; the exception is

+ * PngUKNOWN), <br>

+ * and the rest are instance-specific

+ */

 public abstract class PngChunk {

 

-	public final String id; // 4 letters

+	/**

+	 * Chunk-id: 4 letters

+	 */

+	public final String id;

+	/**

+	 * Autocomputed at creation time

+	 */

 	public final boolean crit, pub, safe;

-	private int lenori = -1; // merely informational, for read chunks

 

-	private boolean writePriority = false; // for queued chunks

 	protected final ImageInfo imgInfo;

 

-	private int chunkGroup = -1; // chunk group where it was read or writen

+	/**

+	 * Possible ordering constraint for a PngChunk type -only relevant for

+	 * ancillary chunks. Theoretically, there could be more general constraints,

+	 * but these cover the constraints for standard chunks.

+	 */

+	public enum ChunkOrderingConstraint {

+		/**

+		 * no ordering constraint

+		 */

+		NONE,

+		/**

+		 * Must go before PLTE (and hence, also before IDAT)

+		 */

+		BEFORE_PLTE_AND_IDAT,

+		/**

+		 * Must go after PLTE but before IDAT

+		 */

+		AFTER_PLTE_BEFORE_IDAT,

+		/**

+		 * Must before IDAT (before or after PLTE)

+		 */

+		BEFORE_IDAT,

+		/**

+		 * Does not apply

+		 */

+		NA;

+

+		public boolean mustGoBeforePLTE() {

+			return this == BEFORE_PLTE_AND_IDAT;

+		}

+

+		public boolean mustGoBeforeIDAT() {

+			return this == BEFORE_IDAT || this == BEFORE_PLTE_AND_IDAT || this == AFTER_PLTE_BEFORE_IDAT;

+		}

+

+		public boolean mustGoAfterPLTE() {

+			return this == AFTER_PLTE_BEFORE_IDAT;

+		}

+	}

+

+	private boolean priority = false; // For writing. Queued chunks with high priority will be written as soon as

+										// possible

+

+	protected int chunkGroup = -1; // chunk group where it was read or writen

+	protected int length = -1; // merely informational, for read chunks

+	protected long offset = 0; // merely informational, for read chunks

 

 	/**

-	 * This static map defines which PngChunk class correspond to which ChunkID The client can add other chunks to this

-	 * map statically, before reading

+	 * This static map defines which PngChunk class correspond to which ChunkID

+	 * <p>

+	 * The client can add other chunks to this map statically, before reading an

+	 * image, calling PngChunk.factoryRegister(id,class)

 	 */

-	public final static Map<String, Class<? extends PngChunk>> factoryMap = new HashMap<String, Class<? extends PngChunk>>();

+	private final static Map<String, Class<? extends PngChunk>> factoryMap = new HashMap<String, Class<? extends PngChunk>>();

 	static {

 		factoryMap.put(ChunkHelper.IDAT, PngChunkIDAT.class);

 		factoryMap.put(ChunkHelper.IHDR, PngChunkIHDR.class);

@@ -45,6 +110,35 @@ public abstract class PngChunk {
 		factoryMap.put(ChunkHelper.sRGB, PngChunkSRGB.class);

 		factoryMap.put(ChunkHelper.hIST, PngChunkHIST.class);

 		factoryMap.put(ChunkHelper.sPLT, PngChunkSPLT.class);

+		// extended

+		factoryMap.put(PngChunkOFFS.ID, PngChunkOFFS.class);

+		factoryMap.put(PngChunkSTER.ID, PngChunkSTER.class);

+	}

+

+	/**

+	 * Registers a chunk-id (4 letters) to be associated with a PngChunk class

+	 * <p>

+	 * This method should be called by user code that wants to add some chunks

+	 * (not implmemented in this library) to the factory, so that the PngReader

+	 * knows about it.

+	 */

+	public static void factoryRegister(String chunkId, Class<? extends PngChunk> chunkClass) {

+		factoryMap.put(chunkId, chunkClass);

+	}

+

+	/**

+	 * True if the chunk-id type is known.

+	 * <p>

+	 * A chunk is known if we recognize its class, according with

+	 * <code>factoryMap</code>

+	 * <p>

+	 * This is not necessarily the same as being "STANDARD", or being

+	 * implemented in this library

+	 * <p>

+	 * Unknown chunks will be parsed as instances of {@link PngChunkUNKNOWN}

+	 */

+	public static boolean isKnown(String id) {

+		return factoryMap.containsKey(id);

 	}

 

 	protected PngChunk(String id, ImageInfo imgInfo) {

@@ -55,29 +149,21 @@ public abstract class PngChunk {
 		this.safe = ChunkHelper.isSafeToCopy(id);

 	}

 

-	public abstract ChunkRaw createChunk();

-

-	public abstract void parseFromChunk(ChunkRaw c);

-

-	// override to make deep copy from read data to write

-	public abstract void cloneDataFromRead(PngChunk other);

-

-	@SuppressWarnings("unchecked")

-	public static <T extends PngChunk> T cloneChunk(T chunk, ImageInfo info) {

-		PngChunk cn = factoryFromId(chunk.id, info);

-		if (cn.getClass() != chunk.getClass())

-			throw new PngjException("bad class cloning chunk: " + cn.getClass() + " " + chunk.getClass());

-		cn.cloneDataFromRead(chunk);

-		return (T) cn;

-	}

-

+	/**

+	 * This factory creates the corresponding chunk and parses the raw chunk.

+	 * This is used when reading.

+	 */

 	public static PngChunk factory(ChunkRaw chunk, ImageInfo info) {

 		PngChunk c = factoryFromId(ChunkHelper.toString(chunk.idbytes), info);

-		c.lenori = chunk.len;

-		c.parseFromChunk(chunk);

+		c.length = chunk.len;

+		c.parseFromRaw(chunk);

 		return c;

 	}

 

+	/**

+	 * Creates one new blank chunk of the corresponding type, according to

+	 * factoryMap (PngChunkUNKNOWN if not known)

+	 */

 	public static PngChunk factoryFromId(String cid, ImageInfo info) {

 		PngChunk chunk = null;

 		try {

@@ -87,66 +173,112 @@ public abstract class PngChunk {
 				chunk = constr.newInstance(info);

 			}

 		} catch (Exception e) {

-			// this can happend for unkown chunks

+			// this can happen for unkown chunks

 		}

 		if (chunk == null)

 			chunk = new PngChunkUNKNOWN(cid, info);

 		return chunk;

 	}

 

-	protected ChunkRaw createEmptyChunk(int len, boolean alloc) {

+	protected final ChunkRaw createEmptyChunk(int len, boolean alloc) {

 		ChunkRaw c = new ChunkRaw(len, ChunkHelper.toBytes(id), alloc);

 		return c;

 	}

 

-	@Override

-	public String toString() {

-		return "chunk id= " + id + " (" + lenori + ") c=" + getClass().getSimpleName();

+	/**

+	 * Makes a clone (deep copy) calling {@link #cloneDataFromRead(PngChunk)}

+	 */

+	@SuppressWarnings("unchecked")

+	public static <T extends PngChunk> T cloneChunk(T chunk, ImageInfo info) {

+		PngChunk cn = factoryFromId(chunk.id, info);

+		if (cn.getClass() != chunk.getClass())

+			throw new PngjExceptionInternal("bad class cloning chunk: " + cn.getClass() + " " + chunk.getClass());

+		cn.cloneDataFromRead(chunk);

+		return (T) cn;

 	}

 

-	void setPriority(boolean highPrioriy) {

-		writePriority = highPrioriy;

+	/**

+	 * In which "chunkGroup" (see {@link ChunksList}for definition) this chunks

+	 * instance was read or written.

+	 * <p>

+	 * -1 if not read or written (eg, queued)

+	 */

+	final public int getChunkGroup() {

+		return chunkGroup;

 	}

 

-	void write(OutputStream os) {

-		ChunkRaw c = createChunk();

-		if (c == null)

-			throw new PngjException("null chunk ! creation failed for " + this);

-		c.writeChunk(os);

+	/**

+	 * @see #getChunkGroup()

+	 */

+	final public void setChunkGroup(int chunkGroup) {

+		this.chunkGroup = chunkGroup;

 	}

 

-	public boolean isWritePriority() {

-		return writePriority;

+	public boolean hasPriority() {

+		return priority;

 	}

 

-	/** must be overriden - only relevant for ancillary chunks */

-	public boolean allowsMultiple() {

-		return false; // override if allows multiple ocurrences

+	public void setPriority(boolean priority) {

+		this.priority = priority;

 	}

 

-	/** mustGoBeforeXX/After must be overriden - only relevant for ancillary chunks */

-	public boolean mustGoBeforeIDAT() {

-		return false;

+	final void write(OutputStream os) {

+		ChunkRaw c = createRawChunk();

+		if (c == null)

+			throw new PngjExceptionInternal("null chunk ! creation failed for " + this);

+		c.writeChunk(os);

 	}

 

-	public boolean mustGoBeforePLTE() {

-		return false;

+	public int getLength() {

+		return length;

 	}

 

-	public boolean mustGoAfterPLTE() {

-		return false;

-	}

+	/*

+	 * public void setLength(int length) { this.length = length; }

+	 */

 

-	static boolean isKnown(String id) {

-		return factoryMap.containsKey(id);

+	public long getOffset() {

+		return offset;

 	}

 

-	public int getChunkGroup() {

-		return chunkGroup;

+	public void setOffset(long offset) {

+		this.offset = offset;

 	}

 

-	public void setChunkGroup(int chunkGroup) {

-		this.chunkGroup = chunkGroup;

+	/**

+	 * Creates the physical chunk. This is used when writing (serialization).

+	 * Each particular chunk class implements its own logic.

+	 *

+	 * @return A newly allocated and filled raw chunk

+	 */

+	public abstract ChunkRaw createRawChunk();

+

+	/**

+	 * Parses raw chunk and fill inside data. This is used when reading

+	 * (deserialization). Each particular chunk class implements its own logic.

+	 */

+	public abstract void parseFromRaw(ChunkRaw c);

+

+	/**

+	 * Makes a copy of the chunk.

+	 * <p>

+	 * This is used when copying chunks from a reader to a writer

+	 * <p>

+	 * It should normally be a deep copy, and after the cloning

+	 * this.equals(other) should return true

+	 */

+	public abstract void cloneDataFromRead(PngChunk other);

+

+	public abstract boolean allowsMultiple(); // this is implemented in PngChunkMultiple/PngChunSingle

+

+	/**

+	 * see {@link ChunkOrderingConstraint}

+	 */

+	public abstract ChunkOrderingConstraint getOrderingConstraint();

+

+	@Override

+	public String toString() {

+		return "chunk id= " + id + " (len=" + length + " offset=" + offset + ") c=" + getClass().getSimpleName();

 	}

 

 }

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkBKGD.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkBKGD.java
index 51bbcb832..ea6235432 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkBKGD.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkBKGD.java
@@ -1,14 +1,18 @@
 package jogamp.opengl.util.pngj.chunks;

 

 import jogamp.opengl.util.pngj.ImageInfo;

-import jogamp.opengl.util.pngj.PngHelper;

+import jogamp.opengl.util.pngj.PngHelperInternal;

 import jogamp.opengl.util.pngj.PngjException;

 

-/*

+/**

+ * bKGD Chunk.

+ * <p>

+ * see http://www.w3.org/TR/PNG/#11bKGD

+ * <p>

+ * this chunk structure depends on the image type

  */

-public class PngChunkBKGD extends PngChunk {

-	// http://www.w3.org/TR/PNG/#11bKGD

-	// this chunk structure depends on the image type

+public class PngChunkBKGD extends PngChunkSingle {

+	public final static String ID = ChunkHelper.bKGD;

 	// only one of these is meaningful

 	private int gray;

 	private int red, green, blue;

@@ -19,43 +23,38 @@ public class PngChunkBKGD extends PngChunk {
 	}

 

 	@Override

-	public boolean mustGoBeforeIDAT() {

-		return true;

+	public ChunkOrderingConstraint getOrderingConstraint() {

+		return ChunkOrderingConstraint.AFTER_PLTE_BEFORE_IDAT;

 	}

 

 	@Override

-	public boolean mustGoAfterPLTE() {

-		return true;

-	}

-

-	@Override

-	public ChunkRaw createChunk() {

+	public ChunkRaw createRawChunk() {

 		ChunkRaw c = null;

 		if (imgInfo.greyscale) {

 			c = createEmptyChunk(2, true);

-			PngHelper.writeInt2tobytes(gray, c.data, 0);

+			PngHelperInternal.writeInt2tobytes(gray, c.data, 0);

 		} else if (imgInfo.indexed) {

 			c = createEmptyChunk(1, true);

 			c.data[0] = (byte) paletteIndex;

 		} else {

 			c = createEmptyChunk(6, true);

-			PngHelper.writeInt2tobytes(red, c.data, 0);

-			PngHelper.writeInt2tobytes(green, c.data, 0);

-			PngHelper.writeInt2tobytes(blue, c.data, 0);

+			PngHelperInternal.writeInt2tobytes(red, c.data, 0);

+			PngHelperInternal.writeInt2tobytes(green, c.data, 0);

+			PngHelperInternal.writeInt2tobytes(blue, c.data, 0);

 		}

 		return c;

 	}

 

 	@Override

-	public void parseFromChunk(ChunkRaw c) {

+	public void parseFromRaw(ChunkRaw c) {

 		if (imgInfo.greyscale) {

-			gray = PngHelper.readInt2fromBytes(c.data, 0);

+			gray = PngHelperInternal.readInt2fromBytes(c.data, 0);

 		} else if (imgInfo.indexed) {

 			paletteIndex = (int) (c.data[0] & 0xff);

 		} else {

-			red = PngHelper.readInt2fromBytes(c.data, 0);

-			green = PngHelper.readInt2fromBytes(c.data, 2);

-			blue = PngHelper.readInt2fromBytes(c.data, 4);

+			red = PngHelperInternal.readInt2fromBytes(c.data, 0);

+			green = PngHelperInternal.readInt2fromBytes(c.data, 2);

+			blue = PngHelperInternal.readInt2fromBytes(c.data, 4);

 		}

 	}

 

@@ -71,7 +70,7 @@ public class PngChunkBKGD extends PngChunk {
 

 	/**

 	 * Set gray value (0-255 if bitdept=8)

-	 * 

+	 *

 	 * @param gray

 	 */

 	public void setGray(int gray) {

@@ -88,7 +87,7 @@ public class PngChunkBKGD extends PngChunk {
 

 	/**

 	 * Set pallette index

-	 * 

+	 *

 	 */

 	public void setPaletteIndex(int i) {

 		if (!imgInfo.indexed)

@@ -104,7 +103,7 @@ public class PngChunkBKGD extends PngChunk {
 

 	/**

 	 * Set rgb values

-	 * 

+	 *

 	 */

 	public void setRGB(int r, int g, int b) {

 		if (imgInfo.greyscale || imgInfo.indexed)

@@ -119,4 +118,5 @@ public class PngChunkBKGD extends PngChunk {
 			throw new PngjException("only rgb or rgba images support this");

 		return new int[] { red, green, blue };

 	}

+

 }

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkCHRM.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkCHRM.java
index 4380761c7..25a4bf2d6 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkCHRM.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkCHRM.java
@@ -1,12 +1,17 @@
 package jogamp.opengl.util.pngj.chunks;

 

 import jogamp.opengl.util.pngj.ImageInfo;

-import jogamp.opengl.util.pngj.PngHelper;

+import jogamp.opengl.util.pngj.PngHelperInternal;

 import jogamp.opengl.util.pngj.PngjException;

 

-/*

+/**

+ * cHRM chunk.

+ * <p>

+ * see http://www.w3.org/TR/PNG/#11cHRM

  */

-public class PngChunkCHRM extends PngChunk {

+public class PngChunkCHRM extends PngChunkSingle {

+	public final static String ID = ChunkHelper.cHRM;

+

 	// http://www.w3.org/TR/PNG/#11cHRM

 	private double whitex, whitey;

 	private double redx, redy;

@@ -14,46 +19,41 @@ public class PngChunkCHRM extends PngChunk {
 	private double bluex, bluey;

 

 	public PngChunkCHRM(ImageInfo info) {

-		super(ChunkHelper.cHRM, info);

-	}

-

-	@Override

-	public boolean mustGoBeforeIDAT() {

-		return true;

+		super(ID, info);

 	}

 

 	@Override

-	public boolean mustGoBeforePLTE() {

-		return true;

+	public ChunkOrderingConstraint getOrderingConstraint() {

+		return ChunkOrderingConstraint.AFTER_PLTE_BEFORE_IDAT;

 	}

 

 	@Override

-	public ChunkRaw createChunk() {

+	public ChunkRaw createRawChunk() {

 		ChunkRaw c = null;

 		c = createEmptyChunk(32, true);

-		PngHelper.writeInt4tobytes(PngHelper.doubleToInt100000(whitex), c.data, 0);

-		PngHelper.writeInt4tobytes(PngHelper.doubleToInt100000(whitey), c.data, 4);

-		PngHelper.writeInt4tobytes(PngHelper.doubleToInt100000(redx), c.data, 8);

-		PngHelper.writeInt4tobytes(PngHelper.doubleToInt100000(redy), c.data, 12);

-		PngHelper.writeInt4tobytes(PngHelper.doubleToInt100000(greenx), c.data, 16);

-		PngHelper.writeInt4tobytes(PngHelper.doubleToInt100000(greeny), c.data, 20);

-		PngHelper.writeInt4tobytes(PngHelper.doubleToInt100000(bluex), c.data, 24);

-		PngHelper.writeInt4tobytes(PngHelper.doubleToInt100000(bluey), c.data, 28);

+		PngHelperInternal.writeInt4tobytes(PngHelperInternal.doubleToInt100000(whitex), c.data, 0);

+		PngHelperInternal.writeInt4tobytes(PngHelperInternal.doubleToInt100000(whitey), c.data, 4);

+		PngHelperInternal.writeInt4tobytes(PngHelperInternal.doubleToInt100000(redx), c.data, 8);

+		PngHelperInternal.writeInt4tobytes(PngHelperInternal.doubleToInt100000(redy), c.data, 12);

+		PngHelperInternal.writeInt4tobytes(PngHelperInternal.doubleToInt100000(greenx), c.data, 16);

+		PngHelperInternal.writeInt4tobytes(PngHelperInternal.doubleToInt100000(greeny), c.data, 20);

+		PngHelperInternal.writeInt4tobytes(PngHelperInternal.doubleToInt100000(bluex), c.data, 24);

+		PngHelperInternal.writeInt4tobytes(PngHelperInternal.doubleToInt100000(bluey), c.data, 28);

 		return c;

 	}

 

 	@Override

-	public void parseFromChunk(ChunkRaw c) {

+	public void parseFromRaw(ChunkRaw c) {

 		if (c.len != 32)

 			throw new PngjException("bad chunk " + c);

-		whitex = PngHelper.intToDouble100000(PngHelper.readInt4fromBytes(c.data, 0));

-		whitey = PngHelper.intToDouble100000(PngHelper.readInt4fromBytes(c.data, 4));

-		redx = PngHelper.intToDouble100000(PngHelper.readInt4fromBytes(c.data, 8));

-		redy = PngHelper.intToDouble100000(PngHelper.readInt4fromBytes(c.data, 12));

-		greenx = PngHelper.intToDouble100000(PngHelper.readInt4fromBytes(c.data, 16));

-		greeny = PngHelper.intToDouble100000(PngHelper.readInt4fromBytes(c.data, 20));

-		bluex = PngHelper.intToDouble100000(PngHelper.readInt4fromBytes(c.data, 24));

-		bluey = PngHelper.intToDouble100000(PngHelper.readInt4fromBytes(c.data, 28));

+		whitex = PngHelperInternal.intToDouble100000(PngHelperInternal.readInt4fromBytes(c.data, 0));

+		whitey = PngHelperInternal.intToDouble100000(PngHelperInternal.readInt4fromBytes(c.data, 4));

+		redx = PngHelperInternal.intToDouble100000(PngHelperInternal.readInt4fromBytes(c.data, 8));

+		redy = PngHelperInternal.intToDouble100000(PngHelperInternal.readInt4fromBytes(c.data, 12));

+		greenx = PngHelperInternal.intToDouble100000(PngHelperInternal.readInt4fromBytes(c.data, 16));

+		greeny = PngHelperInternal.intToDouble100000(PngHelperInternal.readInt4fromBytes(c.data, 20));

+		bluex = PngHelperInternal.intToDouble100000(PngHelperInternal.readInt4fromBytes(c.data, 24));

+		bluey = PngHelperInternal.intToDouble100000(PngHelperInternal.readInt4fromBytes(c.data, 28));

 	}

 

 	@Override

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkGAMA.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkGAMA.java
index 184ee9ffa..74640746e 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkGAMA.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkGAMA.java
@@ -1,42 +1,42 @@
 package jogamp.opengl.util.pngj.chunks;

 

 import jogamp.opengl.util.pngj.ImageInfo;

-import jogamp.opengl.util.pngj.PngHelper;

+import jogamp.opengl.util.pngj.PngHelperInternal;

 import jogamp.opengl.util.pngj.PngjException;

 

-/*

+/**

+ * gAMA chunk.

+ * <p>

+ * see http://www.w3.org/TR/PNG/#11gAMA

  */

-public class PngChunkGAMA extends PngChunk {

+public class PngChunkGAMA extends PngChunkSingle {

+	public final static String ID = ChunkHelper.gAMA;

+

 	// http://www.w3.org/TR/PNG/#11gAMA

 	private double gamma;

 

 	public PngChunkGAMA(ImageInfo info) {

-		super(ChunkHelper.gAMA, info);

-	}

-

-	@Override

-	public boolean mustGoBeforeIDAT() {

-		return true;

+		super(ID, info);

 	}

 

 	@Override

-	public boolean mustGoBeforePLTE() {

-		return true;

+	public ChunkOrderingConstraint getOrderingConstraint() {

+		return ChunkOrderingConstraint.BEFORE_PLTE_AND_IDAT;

 	}

 

 	@Override

-	public ChunkRaw createChunk() {

+	public ChunkRaw createRawChunk() {

 		ChunkRaw c = createEmptyChunk(4, true);

 		int g = (int) (gamma * 100000 + 0.5);

-		PngHelper.writeInt4tobytes(g, c.data, 0);

+		PngHelperInternal.writeInt4tobytes(g, c.data, 0);

 		return c;

 	}

 

 	@Override

-	public void parseFromChunk(ChunkRaw chunk) {

+	public void parseFromRaw(ChunkRaw chunk) {

 		if (chunk.len != 4)

 			throw new PngjException("bad chunk " + chunk);

-		int g = PngHelper.readInt4fromBytes(chunk.data, 0);

+		int g = PngHelperInternal.readInt4fromBytes(chunk.data, 0);

 		gamma = ((double) g) / 100000.0;

 	}

 

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkHIST.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkHIST.java
index b0f02ea37..6dc3fd9ec 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkHIST.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkHIST.java
@@ -1,50 +1,48 @@
 package jogamp.opengl.util.pngj.chunks;

 

 import jogamp.opengl.util.pngj.ImageInfo;

-import jogamp.opengl.util.pngj.PngHelper;

+import jogamp.opengl.util.pngj.PngHelperInternal;

 import jogamp.opengl.util.pngj.PngjException;

 

-/*

+/**

+ * hIST chunk.

+ * <p>

+ * see http://www.w3.org/TR/PNG/#11hIST <br>

+ * only for palette images

  */

-public class PngChunkHIST extends PngChunk {

-	// http://www.w3.org/TR/PNG/#11hIST

-	// only for palette images

+public class PngChunkHIST extends PngChunkSingle {

+	public final static String ID = ChunkHelper.hIST;

 

 	private int[] hist = new int[0]; // should have same lenght as palette

 

 	public PngChunkHIST(ImageInfo info) {

-		super(ChunkHelper.hIST, info);

+		super(ID, info);

 	}

 

 	@Override

-	public boolean mustGoBeforeIDAT() {

-		return true;

+	public ChunkOrderingConstraint getOrderingConstraint() {

+		return ChunkOrderingConstraint.AFTER_PLTE_BEFORE_IDAT;

 	}

 

 	@Override

-	public boolean mustGoAfterPLTE() {

-		return true;

-	}

-

-	@Override

-	public void parseFromChunk(ChunkRaw c) {

+	public void parseFromRaw(ChunkRaw c) {

 		if (!imgInfo.indexed)

 			throw new PngjException("only indexed images accept a HIST chunk");

 		int nentries = c.data.length / 2;

 		hist = new int[nentries];

 		for (int i = 0; i < hist.length; i++) {

-			hist[i] = PngHelper.readInt2fromBytes(c.data, i * 2);

+			hist[i] = PngHelperInternal.readInt2fromBytes(c.data, i * 2);

 		}

 	}

 

 	@Override

-	public ChunkRaw createChunk() {

+	public ChunkRaw createRawChunk() {

 		if (!imgInfo.indexed)

 			throw new PngjException("only indexed images accept a HIST chunk");

 		ChunkRaw c = null;

 		c = createEmptyChunk(hist.length * 2, true);

 		for (int i = 0; i < hist.length; i++) {

-			PngHelper.writeInt2tobytes(hist[i], c.data, i * 2);

+			PngHelperInternal.writeInt2tobytes(hist[i], c.data, i * 2);

 		}

 		return c;

 	}

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkICCP.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkICCP.java
index db1c1ba64..399577d72 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkICCP.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkICCP.java
@@ -1,31 +1,32 @@
 package jogamp.opengl.util.pngj.chunks;

 

 import jogamp.opengl.util.pngj.ImageInfo;

-import jogamp.opengl.util.pngj.PngHelper;

+import jogamp.opengl.util.pngj.PngHelperInternal;

+import jogamp.opengl.util.pngj.PngjException;

 

-/*

+/**

+ * iCCP chunk.

+ * <p>

+ * see http://www.w3.org/TR/PNG/#11iCCP

  */

-public class PngChunkICCP extends PngChunk {

+public class PngChunkICCP extends PngChunkSingle {

+	public final static String ID = ChunkHelper.iCCP;

+

 	// http://www.w3.org/TR/PNG/#11iCCP

 	private String profileName;

 	private byte[] compressedProfile; // copmression/decopmresion is done in getter/setter

 

 	public PngChunkICCP(ImageInfo info) {

-		super(ChunkHelper.iCCP, info);

-	}

-

-	@Override

-	public boolean mustGoBeforeIDAT() {

-		return true;

+		super(ID, info);

 	}

 

 	@Override

-	public boolean mustGoBeforePLTE() {

-		return true;

+	public ChunkOrderingConstraint getOrderingConstraint() {

+		return ChunkOrderingConstraint.BEFORE_PLTE_AND_IDAT;

 	}

 

 	@Override

-	public ChunkRaw createChunk() {

+	public ChunkRaw createRawChunk() {

 		ChunkRaw c = createEmptyChunk(profileName.length() + compressedProfile.length + 2, true);

 		System.arraycopy(ChunkHelper.toBytes(profileName), 0, c.data, 0, profileName.length());

 		c.data[profileName.length()] = 0;

@@ -35,12 +36,12 @@ public class PngChunkICCP extends PngChunk {
 	}

 

 	@Override

-	public void parseFromChunk(ChunkRaw chunk) {

+	public void parseFromRaw(ChunkRaw chunk) {

 		int pos0 = ChunkHelper.posNullByte(chunk.data);

-		profileName = new String(chunk.data, 0, pos0, PngHelper.charsetLatin1);

+		profileName = new String(chunk.data, 0, pos0, PngHelperInternal.charsetLatin1);

 		int comp = (chunk.data[pos0 + 1] & 0xff);

 		if (comp != 0)

-			throw new RuntimeException("bad compression for ChunkTypeICCP");

+			throw new PngjException("bad compression for ChunkTypeICCP");

 		int compdatasize = chunk.data.length - (pos0 + 2);

 		compressedProfile = new byte[compdatasize];

 		System.arraycopy(chunk.data, pos0 + 2, compressedProfile, 0, compdatasize);

@@ -64,7 +65,7 @@ public class PngChunkICCP extends PngChunk {
 	}

 

 	public void setProfileNameAndContent(String name, String profile) {

-		setProfileNameAndContent(name, profile.getBytes(PngHelper.charsetLatin1));

+		setProfileNameAndContent(name, profile.getBytes(PngHelperInternal.charsetLatin1));

 	}

 

 	public String getProfileName() {

@@ -79,7 +80,7 @@ public class PngChunkICCP extends PngChunk {
 	}

 

 	public String getProfileAsString() {

-		return new String(getProfile(), PngHelper.charsetLatin1);

+		return new String(getProfile(), PngHelperInternal.charsetLatin1);

 	}

 

 }

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkIDAT.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkIDAT.java
index a7cb95dbf..911513c0d 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkIDAT.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkIDAT.java
@@ -2,21 +2,36 @@ package jogamp.opengl.util.pngj.chunks;
 

 import jogamp.opengl.util.pngj.ImageInfo;

 

-public class PngChunkIDAT extends PngChunk {

+/**

+ * IDAT chunk.

+ * <p>

+ * see http://www.w3.org/TR/PNG/#11IDAT

+ * <p>

+ * This is dummy placeholder - we write/read this chunk (actually several) by

+ * special code.

+ */

+public class PngChunkIDAT extends PngChunkMultiple {

+	public final static String ID = ChunkHelper.IDAT;

+

 	// http://www.w3.org/TR/PNG/#11IDAT

-	// This is dummy placeholder - we write/read this chunk (actually several)

-	// by special code.

-	public PngChunkIDAT(ImageInfo i) {

-		super(ChunkHelper.IDAT, i);

+	public PngChunkIDAT(ImageInfo i, int len, long offset) {

+		super(ID, i);

+		this.length = len;

+		this.offset = offset;

+	}

+

+	@Override

+	public ChunkOrderingConstraint getOrderingConstraint() {

+		return ChunkOrderingConstraint.NA;

 	}

 

 	@Override

-	public ChunkRaw createChunk() {// does nothing

+	public ChunkRaw createRawChunk() {// does nothing

 		return null;

 	}

 

 	@Override

-	public void parseFromChunk(ChunkRaw c) { // does nothing

+	public void parseFromRaw(ChunkRaw c) { // does nothing

 	}

 

 	@Override

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkIEND.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkIEND.java
index 0d5b266da..fbec564d8 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkIEND.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkIEND.java
@@ -2,21 +2,33 @@ package jogamp.opengl.util.pngj.chunks;
 

 import jogamp.opengl.util.pngj.ImageInfo;

 

-public class PngChunkIEND extends PngChunk {

+/**

+ * IEND chunk.

+ * <p>

+ * see http://www.w3.org/TR/PNG/#11IEND

+ */

+public class PngChunkIEND extends PngChunkSingle {

+	public final static String ID = ChunkHelper.IEND;

+

 	// http://www.w3.org/TR/PNG/#11IEND

 	// this is a dummy placeholder

 	public PngChunkIEND(ImageInfo info) {

-		super(ChunkHelper.IEND, info);

+		super(ID, info);

+	}

+

+	@Override

+	public ChunkOrderingConstraint getOrderingConstraint() {

+		return ChunkOrderingConstraint.NA;

 	}

 

 	@Override

-	public ChunkRaw createChunk() {

+	public ChunkRaw createRawChunk() {

 		ChunkRaw c = new ChunkRaw(0, ChunkHelper.b_IEND, false);

 		return c;

 	}

 

 	@Override

-	public void parseFromChunk(ChunkRaw c) {

+	public void parseFromRaw(ChunkRaw c) {

 		// this is not used

 	}

 

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkIHDR.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkIHDR.java
index fcb4150ff..94bfedd38 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkIHDR.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkIHDR.java
@@ -3,14 +3,20 @@ package jogamp.opengl.util.pngj.chunks;
 import java.io.ByteArrayInputStream;

 

 import jogamp.opengl.util.pngj.ImageInfo;

-import jogamp.opengl.util.pngj.PngHelper;

+import jogamp.opengl.util.pngj.PngHelperInternal;

 import jogamp.opengl.util.pngj.PngjException;

 

 

 /**

- * this is a special chunk!

+ * IHDR chunk.

+ * <p>

+ * see http://www.w3.org/TR/PNG/#11IHDR

+ * <p>

+ * This is a special critical Chunk.

  */

-public class PngChunkIHDR extends PngChunk {

+public class PngChunkIHDR extends PngChunkSingle {

+	public final static String ID = ChunkHelper.IHDR;

+

 	private int cols;

 	private int rows;

 	private int bitspc;

@@ -22,16 +28,21 @@ public class PngChunkIHDR extends PngChunk {
 	// http://www.w3.org/TR/PNG/#11IHDR

 	//

 	public PngChunkIHDR(ImageInfo info) {

-		super(ChunkHelper.IHDR, info);

+		super(ID, info);

+	}

+

+	@Override

+	public ChunkOrderingConstraint getOrderingConstraint() {

+		return ChunkOrderingConstraint.NA;

 	}

 

 	@Override

-	public ChunkRaw createChunk() {

+	public ChunkRaw createRawChunk() {

 		ChunkRaw c = new ChunkRaw(13, ChunkHelper.b_IHDR, true);

 		int offset = 0;

-		PngHelper.writeInt4tobytes(cols, c.data, offset);

+		PngHelperInternal.writeInt4tobytes(cols, c.data, offset);

 		offset += 4;

-		PngHelper.writeInt4tobytes(rows, c.data, offset);

+		PngHelperInternal.writeInt4tobytes(rows, c.data, offset);

 		offset += 4;

 		c.data[offset++] = (byte) bitspc;

 		c.data[offset++] = (byte) colormodel;

@@ -42,18 +53,18 @@ public class PngChunkIHDR extends PngChunk {
 	}

 

 	@Override

-	public void parseFromChunk(ChunkRaw c) {

+	public void parseFromRaw(ChunkRaw c) {

 		if (c.len != 13)

 			throw new PngjException("Bad IDHR len " + c.len);

 		ByteArrayInputStream st = c.getAsByteStream();

-		cols = PngHelper.readInt4(st);

-		rows = PngHelper.readInt4(st);

+		cols = PngHelperInternal.readInt4(st);

+		rows = PngHelperInternal.readInt4(st);

 		// bit depth: number of bits per channel

-		bitspc = PngHelper.readByte(st);

-		colormodel = PngHelper.readByte(st);

-		compmeth = PngHelper.readByte(st);

-		filmeth = PngHelper.readByte(st);

-		interlaced = PngHelper.readByte(st);

+		bitspc = PngHelperInternal.readByte(st);

+		colormodel = PngHelperInternal.readByte(st);

+		compmeth = PngHelperInternal.readByte(st);

+		filmeth = PngHelperInternal.readByte(st);

+		interlaced = PngHelperInternal.readByte(st);

 	}

 

 	@Override

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkITXT.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkITXT.java
index 4e5c7c74a..ab52d7c90 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkITXT.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkITXT.java
@@ -4,14 +4,17 @@ import java.io.ByteArrayOutputStream;
 import java.io.IOException;

 

 import jogamp.opengl.util.pngj.ImageInfo;

-import jogamp.opengl.util.pngj.PngHelper;

+import jogamp.opengl.util.pngj.PngHelperInternal;

 import jogamp.opengl.util.pngj.PngjException;

 

 

 /**

- * UNTESTED!

+ * iTXt chunk.

+ * <p>

+ * see http://www.w3.org/TR/PNG/#11iTXt

  */

 public class PngChunkITXT extends PngChunkTextVar {

+	public final static String ID = ChunkHelper.iTXt;

 

 	private boolean compressed = false;

 	private String langTag = "";

@@ -19,24 +22,24 @@ public class PngChunkITXT extends PngChunkTextVar {
 

 	// http://www.w3.org/TR/PNG/#11iTXt

 	public PngChunkITXT(ImageInfo info) {

-		super(ChunkHelper.iTXt, info);

+		super(ID, info);

 	}

 

 	@Override

-	public ChunkRaw createChunk() {

-		if (val.isEmpty() || key.isEmpty())

-			return null;

+	public ChunkRaw createRawChunk() {

+		if (key.isEmpty())

+			throw new PngjException("Text chunk key must be non empty");

 		try {

 			ByteArrayOutputStream ba = new ByteArrayOutputStream();

-			ba.write(key.getBytes(PngHelper.charsetLatin1));

+			ba.write(ChunkHelper.toBytes(key));

 			ba.write(0); // separator

 			ba.write(compressed ? 1 : 0);

 			ba.write(0); // compression method (always 0)

-			ba.write(langTag.getBytes(PngHelper.charsetUTF8));

+			ba.write(ChunkHelper.toBytes(langTag));

 			ba.write(0); // separator

-			ba.write(translatedTag.getBytes(PngHelper.charsetUTF8));

+			ba.write(ChunkHelper.toBytesUTF8(translatedTag));

 			ba.write(0); // separator

-			byte[] textbytes = val.getBytes(PngHelper.charsetUTF8);

+			byte[] textbytes = ChunkHelper.toBytesUTF8(val);

 			if (compressed) {

 				textbytes = ChunkHelper.compressBytes(textbytes, true);

 			}

@@ -51,7 +54,7 @@ public class PngChunkITXT extends PngChunkTextVar {
 	}

 

 	@Override

-	public void parseFromChunk(ChunkRaw c) {

+	public void parseFromRaw(ChunkRaw c) {

 		int nullsFound = 0;

 		int[] nullsIdx = new int[3];

 		for (int i = 0; i < c.data.length; i++) {

@@ -66,20 +69,21 @@ public class PngChunkITXT extends PngChunkTextVar {
 		}

 		if (nullsFound != 3)

 			throw new PngjException("Bad formed PngChunkITXT chunk");

-		key = new String(c.data, 0, nullsIdx[0], PngHelper.charsetLatin1);

+		key = ChunkHelper.toString(c.data, 0, nullsIdx[0]);

 		int i = nullsIdx[0] + 1;

 		compressed = c.data[i] == 0 ? false : true;

 		i++;

 		if (compressed && c.data[i] != 0)

 			throw new PngjException("Bad formed PngChunkITXT chunk - bad compression method ");

-		langTag = new String(c.data, i, nullsIdx[1] - i, PngHelper.charsetLatin1);

-		translatedTag = new String(c.data, nullsIdx[1] + 1, nullsIdx[2] - nullsIdx[1] - 1, PngHelper.charsetUTF8);

+		langTag = new String(c.data, i, nullsIdx[1] - i, PngHelperInternal.charsetLatin1);

+		translatedTag = new String(c.data, nullsIdx[1] + 1, nullsIdx[2] - nullsIdx[1] - 1,

+				PngHelperInternal.charsetUTF8);

 		i = nullsIdx[2] + 1;

 		if (compressed) {

 			byte[] bytes = ChunkHelper.compressBytes(c.data, i, c.data.length - i, false);

-			val = new String(bytes, PngHelper.charsetUTF8);

+			val = ChunkHelper.toStringUTF8(bytes);

 		} else {

-			val = new String(c.data, i, c.data.length - i, PngHelper.charsetUTF8);

+			val = ChunkHelper.toStringUTF8(c.data, i, c.data.length - i);

 		}

 	}

 

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkMultiple.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkMultiple.java
new file mode 100644
index 000000000..057f6c25e
--- /dev/null
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkMultiple.java
@@ -0,0 +1,28 @@
+package jogamp.opengl.util.pngj.chunks;

+

+import jogamp.opengl.util.pngj.ImageInfo;

+

+/**

+ * PNG chunk type (abstract) that allows multiple instances in same image.

+ */

+public abstract class PngChunkMultiple extends PngChunk {

+

+	protected PngChunkMultiple(String id, ImageInfo imgInfo) {

+		super(id, imgInfo);

+	}

+

+	@Override

+	public final boolean allowsMultiple() {

+		return true;

+	}

+

+	/**

+	 * NOTE: this chunk uses the default Object's equals() hashCode()

+	 * implementation.

+	 *

+	 * This is the right thing to do, normally.

+	 *

+	 * This is important, eg see ChunkList.removeFromList()

+	 */

+

+}

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkOFFS.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkOFFS.java
new file mode 100644
index 000000000..a3bab4995
--- /dev/null
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkOFFS.java
@@ -0,0 +1,89 @@
+package jogamp.opengl.util.pngj.chunks;

+

+import jogamp.opengl.util.pngj.ImageInfo;

+import jogamp.opengl.util.pngj.PngHelperInternal;

+import jogamp.opengl.util.pngj.PngjException;

+

+/**

+ * oFFs chunk.

+ * <p>

+ * see http://www.libpng.org/pub/png/spec/register/pngext-1.3.0-pdg.html#C.oFFs

+ */

+public class PngChunkOFFS extends PngChunkSingle {

+	public final static String ID = "oFFs";

+

+	// http://www.libpng.org/pub/png/spec/register/pngext-1.3.0-pdg.html#C.oFFs

+	private long posX;

+	private long posY;

+	private int units; // 0: pixel 1:micrometer

+

+	public PngChunkOFFS(ImageInfo info) {

+		super(ID, info);

+	}

+

+	@Override

+	public ChunkOrderingConstraint getOrderingConstraint() {

+		return ChunkOrderingConstraint.BEFORE_IDAT;

+	}

+

+	@Override

+	public ChunkRaw createRawChunk() {

+		ChunkRaw c = createEmptyChunk(9, true);

+		PngHelperInternal.writeInt4tobytes((int) posX, c.data, 0);

+		PngHelperInternal.writeInt4tobytes((int) posY, c.data, 4);

+		c.data[8] = (byte) units;

+		return c;

+	}

+

+	@Override

+	public void parseFromRaw(ChunkRaw chunk) {

+		if (chunk.len != 9)

+			throw new PngjException("bad chunk length " + chunk);

+		posX = PngHelperInternal.readInt4fromBytes(chunk.data, 0);

+		if (posX < 0)

+			posX += 0x100000000L;

+		posY = PngHelperInternal.readInt4fromBytes(chunk.data, 4);

+		if (posY < 0)

+			posY += 0x100000000L;

+		units = PngHelperInternal.readInt1fromByte(chunk.data, 8);

+	}

+

+	@Override

+	public void cloneDataFromRead(PngChunk other) {

+		PngChunkOFFS otherx = (PngChunkOFFS) other;

+		this.posX = otherx.posX;

+		this.posY = otherx.posY;

+		this.units = otherx.units;

+	}

+

+	/**

+	 * 0: pixel, 1:micrometer

+	 */

+	public int getUnits() {

+		return units;

+	}

+

+	/**

+	 * 0: pixel, 1:micrometer

+	 */

+	public void setUnits(int units) {

+		this.units = units;

+	}

+

+	public long getPosX() {

+		return posX;

+	}

+

+	public void setPosX(long posX) {

+		this.posX = posX;

+	}

+

+	public long getPosY() {

+		return posY;

+	}

+

+	public void setPosY(long posY) {

+		this.posY = posY;

+	}

+

+}

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkPHYS.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkPHYS.java
index 47e2c492c..b0a1bb898 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkPHYS.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkPHYS.java
@@ -1,44 +1,50 @@
 package jogamp.opengl.util.pngj.chunks;

 

 import jogamp.opengl.util.pngj.ImageInfo;

-import jogamp.opengl.util.pngj.PngHelper;

+import jogamp.opengl.util.pngj.PngHelperInternal;

 import jogamp.opengl.util.pngj.PngjException;

+/**

+ * pHYs chunk.

+ * <p>

+ * see http://www.w3.org/TR/PNG/#11pHYs

+ */

+public class PngChunkPHYS extends PngChunkSingle {

+	public final static String ID = ChunkHelper.pHYs;

 

-public class PngChunkPHYS extends PngChunk {

 	// http://www.w3.org/TR/PNG/#11pHYs

 	private long pixelsxUnitX;

 	private long pixelsxUnitY;

 	private int units; // 0: unknown 1:metre

 

 	public PngChunkPHYS(ImageInfo info) {

-		super(ChunkHelper.pHYs, info);

+		super(ID, info);

 	}

 

 	@Override

-	public boolean mustGoBeforeIDAT() {

-		return true;

+	public ChunkOrderingConstraint getOrderingConstraint() {

+		return ChunkOrderingConstraint.BEFORE_IDAT;

 	}

 

 	@Override

-	public ChunkRaw createChunk() {

+	public ChunkRaw createRawChunk() {

 		ChunkRaw c = createEmptyChunk(9, true);

-		PngHelper.writeInt4tobytes((int) pixelsxUnitX, c.data, 0);

-		PngHelper.writeInt4tobytes((int) pixelsxUnitY, c.data, 4);

+		PngHelperInternal.writeInt4tobytes((int) pixelsxUnitX, c.data, 0);

+		PngHelperInternal.writeInt4tobytes((int) pixelsxUnitY, c.data, 4);

 		c.data[8] = (byte) units;

 		return c;

 	}

 

 	@Override

-	public void parseFromChunk(ChunkRaw chunk) {

+	public void parseFromRaw(ChunkRaw chunk) {

 		if (chunk.len != 9)

 			throw new PngjException("bad chunk length " + chunk);

-		pixelsxUnitX = PngHelper.readInt4fromBytes(chunk.data, 0);

+		pixelsxUnitX = PngHelperInternal.readInt4fromBytes(chunk.data, 0);

 		if (pixelsxUnitX < 0)

 			pixelsxUnitX += 0x100000000L;

-		pixelsxUnitY = PngHelper.readInt4fromBytes(chunk.data, 4);

+		pixelsxUnitY = PngHelperInternal.readInt4fromBytes(chunk.data, 4);

 		if (pixelsxUnitY < 0)

 			pixelsxUnitY += 0x100000000L;

-		units = PngHelper.readInt1fromByte(chunk.data, 8);

+		units = PngHelperInternal.readInt1fromByte(chunk.data, 8);

 	}

 

 	@Override

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkPLTE.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkPLTE.java
index 123080bb3..dbf5e53c0 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkPLTE.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkPLTE.java
@@ -3,10 +3,16 @@ package jogamp.opengl.util.pngj.chunks;
 import jogamp.opengl.util.pngj.ImageInfo;

 import jogamp.opengl.util.pngj.PngjException;

 

-/*

- * Palette chunk *this is critical*

+/**

+ * PLTE chunk.

+ * <p>

+ * see http://www.w3.org/TR/PNG/#11PLTE

+ * <p>

+ * Critical chunk

  */

-public class PngChunkPLTE extends PngChunk {

+public class PngChunkPLTE extends PngChunkSingle {

+	public final static String ID = ChunkHelper.PLTE;

+

 	// http://www.w3.org/TR/PNG/#11PLTE

 	private int nentries = 0;

 	/**

@@ -15,11 +21,16 @@ public class PngChunkPLTE extends PngChunk {
 	private int[] entries;

 

 	public PngChunkPLTE(ImageInfo info) {

-		super(ChunkHelper.PLTE, info);

+		super(ID, info);

+	}

+

+	@Override

+	public ChunkOrderingConstraint getOrderingConstraint() {

+		return ChunkOrderingConstraint.NA;

 	}

 

 	@Override

-	public ChunkRaw createChunk() {

+	public ChunkRaw createRawChunk() {

 		int len = 3 * nentries;

 		int[] rgb = new int[3];

 		ChunkRaw c = createEmptyChunk(len, true);

@@ -33,7 +44,7 @@ public class PngChunkPLTE extends PngChunk {
 	}

 

 	@Override

-	public void parseFromChunk(ChunkRaw chunk) {

+	public void parseFromRaw(ChunkRaw chunk) {

 		setNentries(chunk.len / 3);

 		for (int n = 0, i = 0; n < nentries; n++) {

 			setEntry(n, (int) (chunk.data[i++] & 0xff), (int) (chunk.data[i++] & 0xff), (int) (chunk.data[i++] & 0xff));

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSBIT.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSBIT.java
index 6850d260d..3a490654a 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSBIT.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSBIT.java
@@ -1,31 +1,31 @@
 package jogamp.opengl.util.pngj.chunks;

 

 import jogamp.opengl.util.pngj.ImageInfo;

-import jogamp.opengl.util.pngj.PngHelper;

+import jogamp.opengl.util.pngj.PngHelperInternal;

 import jogamp.opengl.util.pngj.PngjException;

 

-/*

+/**

+ * sBIT chunk.

+ * <p>

+ * see http://www.w3.org/TR/PNG/#11sBIT

+ * <p>

+ * this chunk structure depends on the image type

  */

-public class PngChunkSBIT extends PngChunk {

+public class PngChunkSBIT extends PngChunkSingle {

+	public final static String ID = ChunkHelper.sBIT;

 	// http://www.w3.org/TR/PNG/#11sBIT

-	// this chunk structure depends on the image type

 

 	// significant bits

 	private int graysb, alphasb;

 	private int redsb, greensb, bluesb;

 

 	public PngChunkSBIT(ImageInfo info) {

-		super(ChunkHelper.sBIT, info);

+		super(ID, info);

 	}

 

 	@Override

-	public boolean mustGoBeforeIDAT() {

-		return true;

-	}

-

-	@Override

-	public boolean mustGoBeforePLTE() {

-		return true;

+	public ChunkOrderingConstraint getOrderingConstraint() {

+		return ChunkOrderingConstraint.BEFORE_PLTE_AND_IDAT;

 	}

 

 	private int getLen() {

@@ -36,24 +36,24 @@ public class PngChunkSBIT extends PngChunk {
 	}

 

 	@Override

-	public void parseFromChunk(ChunkRaw c) {

+	public void parseFromRaw(ChunkRaw c) {

 		if (c.len != getLen())

 			throw new PngjException("bad chunk length " + c);

 		if (imgInfo.greyscale) {

-			graysb = PngHelper.readInt1fromByte(c.data, 0);

+			graysb = PngHelperInternal.readInt1fromByte(c.data, 0);

 			if (imgInfo.alpha)

-				alphasb = PngHelper.readInt1fromByte(c.data, 1);

+				alphasb = PngHelperInternal.readInt1fromByte(c.data, 1);

 		} else {

-			redsb = PngHelper.readInt1fromByte(c.data, 0);

-			greensb = PngHelper.readInt1fromByte(c.data, 1);

-			bluesb = PngHelper.readInt1fromByte(c.data, 2);

+			redsb = PngHelperInternal.readInt1fromByte(c.data, 0);

+			greensb = PngHelperInternal.readInt1fromByte(c.data, 1);

+			bluesb = PngHelperInternal.readInt1fromByte(c.data, 2);

 			if (imgInfo.alpha)

-				alphasb = PngHelper.readInt1fromByte(c.data, 3);

+				alphasb = PngHelperInternal.readInt1fromByte(c.data, 3);

 		}

 	}

 

 	@Override

-	public ChunkRaw createChunk() {

+	public ChunkRaw createRawChunk() {

 		ChunkRaw c = null;

 		c = createEmptyChunk(getLen(), true);

 		if (imgInfo.greyscale) {

@@ -106,7 +106,7 @@ public class PngChunkSBIT extends PngChunk {
 

 	/**

 	 * Set rgb values

-	 * 

+	 *

 	 */

 	public void setRGB(int r, int g, int b) {

 		if (imgInfo.greyscale || imgInfo.indexed)

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSPLT.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSPLT.java
index 953adb7d9..2ff65834d 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSPLT.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSPLT.java
@@ -4,11 +4,17 @@ import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 
 import jogamp.opengl.util.pngj.ImageInfo;
-import jogamp.opengl.util.pngj.PngHelper;
+import jogamp.opengl.util.pngj.PngHelperInternal;
 import jogamp.opengl.util.pngj.PngjException;
 
+/**
+ * sPLT chunk.
+ * <p>
+ * see http://www.w3.org/TR/PNG/#11sPLT
+ */
+public class PngChunkSPLT extends PngChunkMultiple {
+	public final static String ID = ChunkHelper.sPLT;
 
-public class PngChunkSPLT extends PngChunk {
 	// http://www.w3.org/TR/PNG/#11sPLT
 
 	private String palName;
@@ -16,35 +22,30 @@ public class PngChunkSPLT extends PngChunk {
 	private int[] palette; // 5 elements per entry
 
 	public PngChunkSPLT(ImageInfo info) {
-		super(ChunkHelper.sPLT, info);
+		super(ID, info);
 	}
 
 	@Override
-	public boolean allowsMultiple() {
-		return true; // allows multiple, but pallete name should be different
+	public ChunkOrderingConstraint getOrderingConstraint() {
+		return ChunkOrderingConstraint.BEFORE_IDAT;
 	}
 
 	@Override
-	public boolean mustGoBeforeIDAT() {
-		return true;
-	}
-
-	@Override
-	public ChunkRaw createChunk() {
+	public ChunkRaw createRawChunk() {
 		try {
 			ByteArrayOutputStream ba = new ByteArrayOutputStream();
-			ba.write(palName.getBytes(PngHelper.charsetLatin1));
+			ba.write(palName.getBytes(PngHelperInternal.charsetLatin1));
 			ba.write(0); // separator
 			ba.write((byte) sampledepth);
 			int nentries = getNentries();
 			for (int n = 0; n < nentries; n++) {
 				for (int i = 0; i < 4; i++) {
 					if (sampledepth == 8)
-						PngHelper.writeByte(ba, (byte) palette[n * 5 + i]);
+						PngHelperInternal.writeByte(ba, (byte) palette[n * 5 + i]);
 					else
-						PngHelper.writeInt2(ba, palette[n * 5 + i]);
+						PngHelperInternal.writeInt2(ba, palette[n * 5 + i]);
 				}
-				PngHelper.writeInt2(ba, palette[n * 5 + 4]);
+				PngHelperInternal.writeInt2(ba, palette[n * 5 + 4]);
 			}
 			byte[] b = ba.toByteArray();
 			ChunkRaw chunk = createEmptyChunk(b.length, false);
@@ -56,7 +57,7 @@ public class PngChunkSPLT extends PngChunk {
 	}
 
 	@Override
-	public void parseFromChunk(ChunkRaw c) {
+	public void parseFromRaw(ChunkRaw c) {
 		int t = -1;
 		for (int i = 0; i < c.data.length; i++) { // look for first zero
 			if (c.data[i] == 0) {
@@ -66,8 +67,8 @@ public class PngChunkSPLT extends PngChunk {
 		}
 		if (t <= 0 || t > c.data.length - 2)
 			throw new PngjException("bad sPLT chunk: no separator found");
-		palName = new String(c.data, 0, t, PngHelper.charsetLatin1);
-		sampledepth = PngHelper.readInt1fromByte(c.data, t + 1);
+		palName = new String(c.data, 0, t, PngHelperInternal.charsetLatin1);
+		sampledepth = PngHelperInternal.readInt1fromByte(c.data, t + 1);
 		t += 2;
 		int nentries = (c.data.length - t) / (sampledepth == 8 ? 6 : 10);
 		palette = new int[nentries * 5];
@@ -75,21 +76,21 @@ public class PngChunkSPLT extends PngChunk {
 		ne = 0;
 		for (int i = 0; i < nentries; i++) {
 			if (sampledepth == 8) {
-				r = PngHelper.readInt1fromByte(c.data, t++);
-				g = PngHelper.readInt1fromByte(c.data, t++);
-				b = PngHelper.readInt1fromByte(c.data, t++);
-				a = PngHelper.readInt1fromByte(c.data, t++);
+				r = PngHelperInternal.readInt1fromByte(c.data, t++);
+				g = PngHelperInternal.readInt1fromByte(c.data, t++);
+				b = PngHelperInternal.readInt1fromByte(c.data, t++);
+				a = PngHelperInternal.readInt1fromByte(c.data, t++);
 			} else {
-				r = PngHelper.readInt2fromBytes(c.data, t);
+				r = PngHelperInternal.readInt2fromBytes(c.data, t);
 				t += 2;
-				g = PngHelper.readInt2fromBytes(c.data, t);
+				g = PngHelperInternal.readInt2fromBytes(c.data, t);
 				t += 2;
-				b = PngHelper.readInt2fromBytes(c.data, t);
+				b = PngHelperInternal.readInt2fromBytes(c.data, t);
 				t += 2;
-				a = PngHelper.readInt2fromBytes(c.data, t);
+				a = PngHelperInternal.readInt2fromBytes(c.data, t);
 				t += 2;
 			}
-			f = PngHelper.readInt2fromBytes(c.data, t);
+			f = PngHelperInternal.readInt2fromBytes(c.data, t);
 			t += 2;
 			palette[ne++] = r;
 			palette[ne++] = g;
diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSRGB.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSRGB.java
index 774558785..e4d77d40a 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSRGB.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSRGB.java
@@ -1,12 +1,17 @@
 package jogamp.opengl.util.pngj.chunks;

 

 import jogamp.opengl.util.pngj.ImageInfo;

-import jogamp.opengl.util.pngj.PngHelper;

+import jogamp.opengl.util.pngj.PngHelperInternal;

 import jogamp.opengl.util.pngj.PngjException;

 

-/*

+/**

+ * sRGB chunk.

+ * <p>

+ * see http://www.w3.org/TR/PNG/#11sRGB

  */

-public class PngChunkSRGB extends PngChunk {

+public class PngChunkSRGB extends PngChunkSingle {

+	public final static String ID = ChunkHelper.sRGB;

+

 	// http://www.w3.org/TR/PNG/#11sRGB

 

 	public static final int RENDER_INTENT_Perceptual = 0;

@@ -17,28 +22,23 @@ public class PngChunkSRGB extends PngChunk {
 	private int intent;

 

 	public PngChunkSRGB(ImageInfo info) {

-		super(ChunkHelper.sRGB, info);

-	}

-

-	@Override

-	public boolean mustGoBeforeIDAT() {

-		return true;

+		super(ID, info);

 	}

 

 	@Override

-	public boolean mustGoBeforePLTE() {

-		return true;

+	public ChunkOrderingConstraint getOrderingConstraint() {

+		return ChunkOrderingConstraint.BEFORE_PLTE_AND_IDAT;

 	}

 

 	@Override

-	public void parseFromChunk(ChunkRaw c) {

+	public void parseFromRaw(ChunkRaw c) {

 		if (c.len != 1)

 			throw new PngjException("bad chunk length " + c);

-		intent = PngHelper.readInt1fromByte(c.data, 0);

+		intent = PngHelperInternal.readInt1fromByte(c.data, 0);

 	}

 

 	@Override

-	public ChunkRaw createChunk() {

+	public ChunkRaw createRawChunk() {

 		ChunkRaw c = null;

 		c = createEmptyChunk(1, true);

 		c.data[0] = (byte) intent;

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSTER.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSTER.java
new file mode 100644
index 000000000..4dc5edec5
--- /dev/null
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSTER.java
@@ -0,0 +1,60 @@
+package jogamp.opengl.util.pngj.chunks;

+

+import jogamp.opengl.util.pngj.ImageInfo;

+import jogamp.opengl.util.pngj.PngjException;

+

+/**

+ * sTER chunk.

+ * <p>

+ * see http://www.libpng.org/pub/png/spec/register/pngext-1.3.0-pdg.html#C.sTER

+ */

+public class PngChunkSTER extends PngChunkSingle {

+	public final static String ID = "sTER";

+

+	// http://www.libpng.org/pub/png/spec/register/pngext-1.3.0-pdg.html#C.sTER

+	private byte mode; // 0: cross-fuse layout 1: diverging-fuse layout

+

+	public PngChunkSTER(ImageInfo info) {

+		super(ID, info);

+	}

+

+	@Override

+	public ChunkOrderingConstraint getOrderingConstraint() {

+		return ChunkOrderingConstraint.BEFORE_IDAT;

+	}

+

+	@Override

+	public ChunkRaw createRawChunk() {

+		ChunkRaw c = createEmptyChunk(1, true);

+		c.data[0] = (byte) mode;

+		return c;

+	}

+

+	@Override

+	public void parseFromRaw(ChunkRaw chunk) {

+		if (chunk.len != 1)

+			throw new PngjException("bad chunk length " + chunk);

+		mode = chunk.data[0];

+	}

+

+	@Override

+	public void cloneDataFromRead(PngChunk other) {

+		PngChunkSTER otherx = (PngChunkSTER) other;

+		this.mode = otherx.mode;

+	}

+

+	/**

+	 * 0: cross-fuse layout 1: diverging-fuse layout

+	 */

+	public byte getMode() {

+		return mode;

+	}

+

+	/**

+	 * 0: cross-fuse layout 1: diverging-fuse layout

+	 */

+	public void setMode(byte mode) {

+		this.mode = mode;

+	}

+

+}

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSingle.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSingle.java
new file mode 100644
index 000000000..7df5ba021
--- /dev/null
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSingle.java
@@ -0,0 +1,45 @@
+package jogamp.opengl.util.pngj.chunks;

+

+import jogamp.opengl.util.pngj.ImageInfo;

+

+/**

+ * PNG chunk type (abstract) that does not allow multiple instances in same

+ * image.

+ */

+public abstract class PngChunkSingle extends PngChunk {

+

+	protected PngChunkSingle(String id, ImageInfo imgInfo) {

+		super(id, imgInfo);

+	}

+

+	@Override

+	public final boolean allowsMultiple() {

+		return false;

+	}

+

+	@Override

+	public int hashCode() {

+		final int prime = 31;

+		int result = 1;

+		result = prime * result + ((id == null) ? 0 : id.hashCode());

+		return result;

+	}

+

+	@Override

+	public boolean equals(Object obj) {

+		if (this == obj)

+			return true;

+		if (obj == null)

+			return false;

+		if (getClass() != obj.getClass())

+			return false;

+		PngChunkSingle other = (PngChunkSingle) obj;

+		if (id == null) {

+			if (other.id != null)

+				return false;

+		} else if (!id.equals(other.id))

+			return false;

+		return true;

+	}

+

+}

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSkipped.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSkipped.java
new file mode 100644
index 000000000..f4c77b4e1
--- /dev/null
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkSkipped.java
@@ -0,0 +1,41 @@
+package jogamp.opengl.util.pngj.chunks;

+

+import jogamp.opengl.util.pngj.ImageInfo;

+import jogamp.opengl.util.pngj.PngjException;

+

+/**

+ * Pseudo chunk type, for chunks that were skipped on reading

+ */

+public class PngChunkSkipped extends PngChunk {

+

+	public PngChunkSkipped(String id, ImageInfo info, int clen) {

+		super(id, info);

+		this.length = clen;

+	}

+

+	@Override

+	public ChunkOrderingConstraint getOrderingConstraint() {

+		return ChunkOrderingConstraint.NONE;

+	}

+

+	@Override

+	public ChunkRaw createRawChunk() {

+		throw new PngjException("Non supported for a skipped chunk");

+	}

+

+	@Override

+	public void parseFromRaw(ChunkRaw c) {

+		throw new PngjException("Non supported for a skipped chunk");

+	}

+

+	@Override

+	public void cloneDataFromRead(PngChunk other) {

+		throw new PngjException("Non supported for a skipped chunk");

+	}

+

+	@Override

+	public boolean allowsMultiple() {

+		return true;

+	}

+

+}

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkTEXT.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkTEXT.java
index c535fe34a..d97cd63c5 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkTEXT.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkTEXT.java
@@ -1,28 +1,40 @@
 package jogamp.opengl.util.pngj.chunks;

 

 import jogamp.opengl.util.pngj.ImageInfo;

-import jogamp.opengl.util.pngj.PngHelper;

+import jogamp.opengl.util.pngj.PngHelperInternal;

+import jogamp.opengl.util.pngj.PngjException;

 

+/**

+ * tEXt chunk.

+ * <p>

+ * see http://www.w3.org/TR/PNG/#11tEXt

+ */

 public class PngChunkTEXT extends PngChunkTextVar {

+	public final static String ID = ChunkHelper.tEXt;

+

 	public PngChunkTEXT(ImageInfo info) {

-		super(ChunkHelper.tEXt, info);

+		super(ID, info);

 	}

 

 	@Override

-	public ChunkRaw createChunk() {

-		if (val.isEmpty() || key.isEmpty())

-			return null;

-		byte[] b = (key + "\0" + val).getBytes(PngHelper.charsetLatin1);

+	public ChunkRaw createRawChunk() {

+		if (key.isEmpty())

+			throw new PngjException("Text chunk key must be non empty");

+		byte[] b = (key + "\0" + val).getBytes(PngHelperInternal.charsetLatin1);

 		ChunkRaw chunk = createEmptyChunk(b.length, false);

 		chunk.data = b;

 		return chunk;

 	}

 

 	@Override

-	public void parseFromChunk(ChunkRaw c) {

-		String[] k = (new String(c.data, PngHelper.charsetLatin1)).split("\0");

-		key = k[0];

-		val = k[1];

+	public void parseFromRaw(ChunkRaw c) {

+		int i;

+		for (i = 0; i < c.data.length; i++)

+			if (c.data[i] == 0)

+				break;

+		key = new String(c.data, 0, i, PngHelperInternal.charsetLatin1);

+		i++;

+		val = i < c.data.length ? new String(c.data, i, c.data.length - i, PngHelperInternal.charsetLatin1) : "";

 	}

 

 	@Override

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkTIME.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkTIME.java
index 37e617acb..8f34c78fe 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkTIME.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkTIME.java
@@ -3,22 +3,33 @@ package jogamp.opengl.util.pngj.chunks;
 import java.util.Calendar;

 

 import jogamp.opengl.util.pngj.ImageInfo;

-import jogamp.opengl.util.pngj.PngHelper;

+import jogamp.opengl.util.pngj.PngHelperInternal;

 import jogamp.opengl.util.pngj.PngjException;

 

+/**

+ * tIME chunk.

+ * <p>

+ * see http://www.w3.org/TR/PNG/#11tIME

+ */

+public class PngChunkTIME extends PngChunkSingle {

+	public final static String ID = ChunkHelper.tIME;

 

-public class PngChunkTIME extends PngChunk {

 	// http://www.w3.org/TR/PNG/#11tIME

 	private int year, mon, day, hour, min, sec;

 

 	public PngChunkTIME(ImageInfo info) {

-		super(ChunkHelper.tIME, info);

+		super(ID, info);

 	}

 

 	@Override

-	public ChunkRaw createChunk() {

+	public ChunkOrderingConstraint getOrderingConstraint() {

+		return ChunkOrderingConstraint.NONE;

+	}

+

+	@Override

+	public ChunkRaw createRawChunk() {

 		ChunkRaw c = createEmptyChunk(7, true);

-		PngHelper.writeInt2tobytes(year, c.data, 0);

+		PngHelperInternal.writeInt2tobytes(year, c.data, 0);

 		c.data[2] = (byte) mon;

 		c.data[3] = (byte) day;

 		c.data[4] = (byte) hour;

@@ -28,15 +39,15 @@ public class PngChunkTIME extends PngChunk {
 	}

 

 	@Override

-	public void parseFromChunk(ChunkRaw chunk) {

+	public void parseFromRaw(ChunkRaw chunk) {

 		if (chunk.len != 7)

 			throw new PngjException("bad chunk " + chunk);

-		year = PngHelper.readInt2fromBytes(chunk.data, 0);

-		mon = PngHelper.readInt1fromByte(chunk.data, 2);

-		day = PngHelper.readInt1fromByte(chunk.data, 3);

-		hour = PngHelper.readInt1fromByte(chunk.data, 4);

-		min = PngHelper.readInt1fromByte(chunk.data, 5);

-		sec = PngHelper.readInt1fromByte(chunk.data, 6);

+		year = PngHelperInternal.readInt2fromBytes(chunk.data, 0);

+		mon = PngHelperInternal.readInt1fromByte(chunk.data, 2);

+		day = PngHelperInternal.readInt1fromByte(chunk.data, 3);

+		hour = PngHelperInternal.readInt1fromByte(chunk.data, 4);

+		min = PngHelperInternal.readInt1fromByte(chunk.data, 5);

+		sec = PngHelperInternal.readInt1fromByte(chunk.data, 6);

 	}

 

 	@Override

@@ -69,15 +80,14 @@ public class PngChunkTIME extends PngChunk {
 		min = minx;

 		sec = secx;

 	}

+

 	public int[] getYMDHMS() {

 		return new int[] { year, mon, day, hour, min, sec };

 	}

 

 	/** format YYYY/MM/DD HH:mm:SS */

 	public String getAsString() {

-		return String.format("%04/%02d/%02d %02d:%02d:%02d", year, mon, day, hour, min, sec);

+		return String.format("%04d/%02d/%02d %02d:%02d:%02d", year, mon, day, hour, min, sec);

 	}

 

-	

-

 }

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkTRNS.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkTRNS.java
index 9365e5e8e..867e34861 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkTRNS.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkTRNS.java
@@ -1,129 +1,141 @@
-package jogamp.opengl.util.pngj.chunks;

-

-import jogamp.opengl.util.pngj.ImageInfo;

-import jogamp.opengl.util.pngj.PngHelper;

-import jogamp.opengl.util.pngj.PngjException;

-

-/*

- */

-public class PngChunkTRNS extends PngChunk {

-	// http://www.w3.org/TR/PNG/#11tRNS

-	// this chunk structure depends on the image type

-	// only one of these is meaningful

-	private int gray;

-	private int red, green, blue;

-	private int[] paletteAlpha = new int[] {};

-

-	public PngChunkTRNS(ImageInfo info) {

-		super(ChunkHelper.tRNS, info);

-	}

-

-	@Override

-	public boolean mustGoBeforeIDAT() {

-		return true;

-	}

-

-	@Override

-	public boolean mustGoAfterPLTE() {

-		return true;

-	}

-

-	@Override

-	public ChunkRaw createChunk() {

-		ChunkRaw c = null;

-		if (imgInfo.greyscale) {

-			c = createEmptyChunk(2, true);

-			PngHelper.writeInt2tobytes(gray, c.data, 0);

-		} else if (imgInfo.indexed) {

-			c = createEmptyChunk(paletteAlpha.length, true);

-			for (int n = 0; n < c.len; n++) {

-				c.data[n] = (byte) paletteAlpha[n];

-			}

-		} else {

-			c = createEmptyChunk(6, true);

-			PngHelper.writeInt2tobytes(red, c.data, 0);

-			PngHelper.writeInt2tobytes(green, c.data, 0);

-			PngHelper.writeInt2tobytes(blue, c.data, 0);

-		}

-		return c;

-	}

-

-	@Override

-	public void parseFromChunk(ChunkRaw c) {

-		if (imgInfo.greyscale) {

-			gray = PngHelper.readInt2fromBytes(c.data, 0);

-		} else if (imgInfo.indexed) {

-			int nentries = c.data.length;

-			paletteAlpha = new int[nentries];

-			for (int n = 0; n < nentries; n++) {

-				paletteAlpha[n] = (int) (c.data[n] & 0xff);

-			}

-		} else {

-			red = PngHelper.readInt2fromBytes(c.data, 0);

-			green = PngHelper.readInt2fromBytes(c.data, 2);

-			blue = PngHelper.readInt2fromBytes(c.data, 4);

-		}

-	}

-

-	@Override

-	public void cloneDataFromRead(PngChunk other) {

-		PngChunkTRNS otherx = (PngChunkTRNS) other;

-		gray = otherx.gray;

-		red = otherx.red;

-		green = otherx.red;

-		blue = otherx.red;

-		if (otherx.paletteAlpha != null) {

-			paletteAlpha = new int[otherx.paletteAlpha.length];

-			System.arraycopy(otherx.paletteAlpha, 0, paletteAlpha, 0, paletteAlpha.length);

-		}

-	}

-

-	/**

-	 * Set rgb values

-	 * 

-	 */

-	public void setRGB(int r, int g, int b) {

-		if (imgInfo.greyscale || imgInfo.indexed)

-			throw new PngjException("only rgb or rgba images support this");

-		red = r;

-		green = g;

-		blue = b;

-	}

-

-	public int[] getRGB() {

-		if (imgInfo.greyscale || imgInfo.indexed)

-			throw new PngjException("only rgb or rgba images support this");

-		return new int[] { red, green, blue };

-	}

-

-	public void setGray(int g) {

-		if (!imgInfo.greyscale)

-			throw new PngjException("only grayscale images support this");

-		gray = g;

-	}

-

-	public int getGray() {

-		if (!imgInfo.greyscale)

-			throw new PngjException("only grayscale images support this");

-		return gray;

-	}

-

-	/**

-	 * WARNING: non deep copy

-	 */

-	public void setPalletteAlpha(int[] palAlpha) {

-		if (!imgInfo.indexed)

-			throw new PngjException("only indexed images support this");

-		paletteAlpha = palAlpha;

-	}

-

-	/**

-	 * WARNING: non deep copy

-	 */

-	public int[] getPalletteAlpha() {

-		if (!imgInfo.indexed)

-			throw new PngjException("only indexed images support this");

-		return paletteAlpha;

-	}

-

-}

+package jogamp.opengl.util.pngj.chunks;
+
+import jogamp.opengl.util.pngj.ImageInfo;
+import jogamp.opengl.util.pngj.PngHelperInternal;
+import jogamp.opengl.util.pngj.PngjException;
+
+/**
+ * tRNS chunk.
+ * <p>
+ * see http://www.w3.org/TR/PNG/#11tRNS
+ * <p>
+ * this chunk structure depends on the image type
+ */
+public class PngChunkTRNS extends PngChunkSingle {
+	public final static String ID = ChunkHelper.tRNS;
+
+	// http://www.w3.org/TR/PNG/#11tRNS
+
+	// only one of these is meaningful, depending on the image type
+	private int gray;
+	private int red, green, blue;
+	private int[] paletteAlpha = new int[] {};
+
+	public PngChunkTRNS(ImageInfo info) {
+		super(ID, info);
+	}
+
+	@Override
+	public ChunkOrderingConstraint getOrderingConstraint() {
+		return ChunkOrderingConstraint.AFTER_PLTE_BEFORE_IDAT;
+	}
+
+	@Override
+	public ChunkRaw createRawChunk() {
+		ChunkRaw c = null;
+		if (imgInfo.greyscale) {
+			c = createEmptyChunk(2, true);
+			PngHelperInternal.writeInt2tobytes(gray, c.data, 0);
+		} else if (imgInfo.indexed) {
+			c = createEmptyChunk(paletteAlpha.length, true);
+			for (int n = 0; n < c.len; n++) {
+				c.data[n] = (byte) paletteAlpha[n];
+			}
+		} else {
+			c = createEmptyChunk(6, true);
+			PngHelperInternal.writeInt2tobytes(red, c.data, 0);
+			PngHelperInternal.writeInt2tobytes(green, c.data, 0);
+			PngHelperInternal.writeInt2tobytes(blue, c.data, 0);
+		}
+		return c;
+	}
+
+	@Override
+	public void parseFromRaw(ChunkRaw c) {
+		if (imgInfo.greyscale) {
+			gray = PngHelperInternal.readInt2fromBytes(c.data, 0);
+		} else if (imgInfo.indexed) {
+			int nentries = c.data.length;
+			paletteAlpha = new int[nentries];
+			for (int n = 0; n < nentries; n++) {
+				paletteAlpha[n] = (int) (c.data[n] & 0xff);
+			}
+		} else {
+			red = PngHelperInternal.readInt2fromBytes(c.data, 0);
+			green = PngHelperInternal.readInt2fromBytes(c.data, 2);
+			blue = PngHelperInternal.readInt2fromBytes(c.data, 4);
+		}
+	}
+
+	@Override
+	public void cloneDataFromRead(PngChunk other) {
+		PngChunkTRNS otherx = (PngChunkTRNS) other;
+		gray = otherx.gray;
+		red = otherx.red;
+		green = otherx.green;
+		blue = otherx.blue;
+		if (otherx.paletteAlpha != null) {
+			paletteAlpha = new int[otherx.paletteAlpha.length];
+			System.arraycopy(otherx.paletteAlpha, 0, paletteAlpha, 0, paletteAlpha.length);
+		}
+	}
+
+	/**
+	 * Set rgb values
+	 *
+	 */
+	public void setRGB(int r, int g, int b) {
+		if (imgInfo.greyscale || imgInfo.indexed)
+			throw new PngjException("only rgb or rgba images support this");
+		red = r;
+		green = g;
+		blue = b;
+	}
+
+	public int[] getRGB() {
+		if (imgInfo.greyscale || imgInfo.indexed)
+			throw new PngjException("only rgb or rgba images support this");
+		return new int[] { red, green, blue };
+	}
+
+	public void setGray(int g) {
+		if (!imgInfo.greyscale)
+			throw new PngjException("only grayscale images support this");
+		gray = g;
+	}
+
+	public int getGray() {
+		if (!imgInfo.greyscale)
+			throw new PngjException("only grayscale images support this");
+		return gray;
+	}
+
+	/**
+	 * WARNING: non deep copy
+	 */
+	public void setPalletteAlpha(int[] palAlpha) {
+		if (!imgInfo.indexed)
+			throw new PngjException("only indexed images support this");
+		paletteAlpha = palAlpha;
+	}
+
+	/**
+	 * to use when only one pallete index is set as totally transparent
+	 */
+	public void setIndexEntryAsTransparent(int palAlphaIndex) {
+		if (!imgInfo.indexed)
+			throw new PngjException("only indexed images support this");
+		paletteAlpha = new int[] { palAlphaIndex + 1 };
+		for (int i = 0; i < palAlphaIndex; i++)
+			paletteAlpha[i] = 255;
+		paletteAlpha[palAlphaIndex] = 0;
+	}
+
+	/**
+	 * WARNING: non deep copy
+	 */
+	public int[] getPalletteAlpha() {
+		return paletteAlpha;
+	}
+
+}
diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkTextVar.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkTextVar.java
index 3d92a806f..ba3ffc30c 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkTextVar.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkTextVar.java
@@ -3,11 +3,9 @@ package jogamp.opengl.util.pngj.chunks;
 import jogamp.opengl.util.pngj.ImageInfo;

 

 /**

- * superclass for three textual chunks (TEXT, ITXT, ZTXT)

- * 

- * @author Hernan J Gonzalez

+ * Superclass (abstract) for three textual chunks (TEXT, ITXT, ZTXT)

  */

-public abstract class PngChunkTextVar extends PngChunk {

+public abstract class PngChunkTextVar extends PngChunkMultiple {

 	protected String key; // key/val: only for tEXt. lazy computed

 	protected String val;

 

@@ -28,8 +26,8 @@ public abstract class PngChunkTextVar extends PngChunk {
 	}

 

 	@Override

-	public boolean allowsMultiple() {

-		return true;

+	public ChunkOrderingConstraint getOrderingConstraint() {

+		return ChunkOrderingConstraint.NONE;

 	}

 

 	public static class PngTxtInfo {

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkUNKNOWN.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkUNKNOWN.java
index 15a35935a..3803428e6 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkUNKNOWN.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkUNKNOWN.java
@@ -2,7 +2,12 @@ package jogamp.opengl.util.pngj.chunks;
 

 import jogamp.opengl.util.pngj.ImageInfo;

 

-public class PngChunkUNKNOWN extends PngChunk { // unkown, custom or not

+/**

+ * Placeholder for UNKNOWN (custom or not) chunks.

+ * <p>

+ * For PngReader, a chunk is unknown if it's not registered in the chunk factory

+ */

+public class PngChunkUNKNOWN extends PngChunkMultiple { // unkown, custom or not

 

 	private byte[] data;

 

@@ -10,25 +15,25 @@ public class PngChunkUNKNOWN extends PngChunk { // unkown, custom or not
 		super(id, info);

 	}

 

-	@Override

-	public boolean allowsMultiple() {

-		return true;

-	}

-

 	private PngChunkUNKNOWN(PngChunkUNKNOWN c, ImageInfo info) {

 		super(c.id, info);

 		System.arraycopy(c.data, 0, data, 0, c.data.length);

 	}

 

 	@Override

-	public ChunkRaw createChunk() {

+	public ChunkOrderingConstraint getOrderingConstraint() {

+		return ChunkOrderingConstraint.NONE;

+	}

+

+	@Override

+	public ChunkRaw createRawChunk() {

 		ChunkRaw p = createEmptyChunk(data.length, false);

 		p.data = this.data;

 		return p;

 	}

 

 	@Override

-	public void parseFromChunk(ChunkRaw c) {

+	public void parseFromRaw(ChunkRaw c) {

 		data = c.data;

 	}

 

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkZTXT.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkZTXT.java
index fd6c08273..64593eae4 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkZTXT.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngChunkZTXT.java
@@ -4,26 +4,32 @@ import java.io.ByteArrayOutputStream;
 import java.io.IOException;

 

 import jogamp.opengl.util.pngj.ImageInfo;

-import jogamp.opengl.util.pngj.PngHelper;

+import jogamp.opengl.util.pngj.PngHelperInternal;

 import jogamp.opengl.util.pngj.PngjException;

 

-

+/**

+ * zTXt chunk.

+ * <p>

+ * see http://www.w3.org/TR/PNG/#11zTXt

+ */

 public class PngChunkZTXT extends PngChunkTextVar {

+	public final static String ID = ChunkHelper.zTXt;

+

 	// http://www.w3.org/TR/PNG/#11zTXt

 	public PngChunkZTXT(ImageInfo info) {

-		super(ChunkHelper.zTXt, info);

+		super(ID, info);

 	}

 

 	@Override

-	public ChunkRaw createChunk() {

-		if (val.isEmpty() || key.isEmpty())

-			return null;

+	public ChunkRaw createRawChunk() {

+		if (key.isEmpty())

+			throw new PngjException("Text chunk key must be non empty");

 		try {

 			ByteArrayOutputStream ba = new ByteArrayOutputStream();

-			ba.write(key.getBytes(PngHelper.charsetLatin1));

+			ba.write(key.getBytes(PngHelperInternal.charsetLatin1));

 			ba.write(0); // separator

 			ba.write(0); // compression method: 0

-			byte[] textbytes = ChunkHelper.compressBytes(val.getBytes(PngHelper.charsetLatin1), true);

+			byte[] textbytes = ChunkHelper.compressBytes(val.getBytes(PngHelperInternal.charsetLatin1), true);

 			ba.write(textbytes);

 			byte[] b = ba.toByteArray();

 			ChunkRaw chunk = createEmptyChunk(b.length, false);

@@ -35,7 +41,7 @@ public class PngChunkZTXT extends PngChunkTextVar {
 	}

 

 	@Override

-	public void parseFromChunk(ChunkRaw c) {

+	public void parseFromRaw(ChunkRaw c) {

 		int nullsep = -1;

 		for (int i = 0; i < c.data.length; i++) { // look for first zero

 			if (c.data[i] != 0)

@@ -45,12 +51,12 @@ public class PngChunkZTXT extends PngChunkTextVar {
 		}

 		if (nullsep < 0 || nullsep > c.data.length - 2)

 			throw new PngjException("bad zTXt chunk: no separator found");

-		key = new String(c.data, 0, nullsep, PngHelper.charsetLatin1);

+		key = new String(c.data, 0, nullsep, PngHelperInternal.charsetLatin1);

 		int compmet = (int) c.data[nullsep + 1];

 		if (compmet != 0)

 			throw new PngjException("bad zTXt chunk: unknown compression method");

 		byte[] uncomp = ChunkHelper.compressBytes(c.data, nullsep + 2, c.data.length - nullsep - 2, false); // uncompress

-		val = new String(uncomp, PngHelper.charsetLatin1);

+		val = new String(uncomp, PngHelperInternal.charsetLatin1);

 	}

 

 	@Override

diff --git a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngMetadata.java b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngMetadata.java
index a82754588..139603448 100644
--- a/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngMetadata.java
+++ b/src/jogl/classes/jogamp/opengl/util/pngj/chunks/PngMetadata.java
@@ -1,68 +1,72 @@
 package jogamp.opengl.util.pngj.chunks;
 
-import jogamp.opengl.util.pngj.PngHelper;
+import java.util.ArrayList;
+import java.util.List;
+
+import jogamp.opengl.util.pngj.PngHelperInternal;
 import jogamp.opengl.util.pngj.PngjException;
 
 /**
- * We consider "image metadata" every info inside the image except for the most basic image info (IHDR chunk - ImageInfo
- * class) and the pixels values.
- * 
+ * We consider "image metadata" every info inside the image except for the most
+ * basic image info (IHDR chunk - ImageInfo class) and the pixels values.
+ * <p>
  * This includes the palette (if present) and all the ancillary chunks
- * 
- * This class provides a wrapper over the collection of chunks of a image (read or to write) and provides some high
- * level methods to access them
- * 
+ * <p>
+ * This class provides a wrapper over the collection of chunks of a image (read
+ * or to write) and provides some high level methods to access them
  */
 public class PngMetadata {
-	private final ChunkList chunkList;
+	private final ChunksList chunkList;
 	private final boolean readonly;
 
-	public PngMetadata(ChunkList chunks, boolean readonly) {
+	public PngMetadata(ChunksList chunks) {
 		this.chunkList = chunks;
-		this.readonly = readonly;
+		if (chunks instanceof ChunksListForWrite) {
+			this.readonly = false;
+		} else {
+			this.readonly = true;
+		}
 	}
 
 	/**
 	 * Queues the chunk at the writer
+	 * <p>
+	 * lazyOverwrite: if true, checks if there is a queued "equivalent" chunk
+	 * and if so, overwrites it. However if that not check for already written
+	 * chunks.
 	 */
-	public boolean setChunk(PngChunk c, boolean overwriteIfPresent) {
+	public void queueChunk(final PngChunk c, boolean lazyOverwrite) {
+		ChunksListForWrite cl = getChunkListW();
 		if (readonly)
 			throw new PngjException("cannot set chunk : readonly metadata");
-		return chunkList.setChunk(c, overwriteIfPresent);
+		if (lazyOverwrite) {
+			ChunkHelper.trimList(cl.getQueuedChunks(), new ChunkPredicate() {
+				@Override
+				public boolean match(PngChunk c2) {
+					return ChunkHelper.equivalent(c, c2);
+				}
+			});
+		}
+		cl.queue(c);
 	}
 
-	
-	/**
-	 * Returns only one chunk or null if nothing found - does not include queued chunks
-	 *
-	 * If more than one chunk (after filtering by inner id) is found, then an exception is thrown (failifMultiple=true)
-	 * or the last one is returned (failifMultiple=false)
-	 * 
-	 * @param id Chunk id
-	 * @param innerid if not null, the chunk is assumed to be PngChunkTextVar or PngChunkSPLT, and filtered by that 'internal id'
-	 * @param failIfMultiple throw exception if more that one
-	 * @return chunk (not cloned)
-	 */
-	public PngChunk getChunk1(String id, String innerid, boolean failIfMultiple) {
-		return chunkList.getChunk1(id, innerid, failIfMultiple);
+	public void queueChunk(final PngChunk c) {
+		queueChunk(c, true);
 	}
 
-	/**
-	 *  Same as  getChunk1(id,  innerid=null, failIfMultiple=true);
-	 */
-	public PngChunk getChunk1(String id) {
-		return chunkList.getChunk1(id);
+	private ChunksListForWrite getChunkListW() {
+		return (ChunksListForWrite) chunkList;
 	}
 
 	// ///// high level utility methods follow ////////////
 
 	// //////////// DPI
 
-	/** 
-	 * returns -1 if not found or dimension unknown 
-	 **/
+	/**
+	 * returns -1 if not found or dimension unknown
+	 */
 	public double[] getDpi() {
-		PngChunk c = getChunk1(ChunkHelper.pHYs, null, true);
+		PngChunk c = chunkList.getById1(ChunkHelper.pHYs, true);
 		if (c == null)
 			return new double[] { -1, -1 };
 		else
@@ -76,31 +80,71 @@ public class PngMetadata {
 	public void setDpi(double x, double y) {
 		PngChunkPHYS c = new PngChunkPHYS(chunkList.imageInfo);
 		c.setAsDpi2(x, y);
-		setChunk(c, true);
+		queueChunk(c);
 	}
 
 	// //////////// TIME
 
-	public void setTimeNow(int secsAgo) {
+	/**
+	 * Creates a time chunk with current time, less secsAgo seconds
+	 * <p>
+	 *
+	 * @return Returns the created-queued chunk, just in case you want to
+	 *         examine or modify it
+	 */
+	public PngChunkTIME setTimeNow(int secsAgo) {
 		PngChunkTIME c = new PngChunkTIME(chunkList.imageInfo);
 		c.setNow(secsAgo);
-		setChunk(c, true);
+		queueChunk(c);
+		return c;
+	}
+
+	public PngChunkTIME setTimeNow() {
+		return setTimeNow(0);
 	}
 
-	public void setTimeYMDHMS(int yearx, int monx, int dayx, int hourx, int minx, int secx) {
+	/**
+	 * Creates a time chunk with diven date-time
+	 * <p>
+	 *
+	 * @return Returns the created-queued chunk, just in case you want to
+	 *         examine or modify it
+	 */
+	public PngChunkTIME setTimeYMDHMS(int yearx, int monx, int dayx, int hourx, int minx, int secx) {
 		PngChunkTIME c = new PngChunkTIME(chunkList.imageInfo);
 		c.setYMDHMS(yearx, monx, dayx, hourx, minx, secx);
-		setChunk(c, true);
+		queueChunk(c, true);
+		return c;
+	}
+
+	/**
+	 * null if not found
+	 */
+	public PngChunkTIME getTime() {
+		return (PngChunkTIME) chunkList.getById1(ChunkHelper.tIME);
 	}
 
 	public String getTimeAsString() {
-		PngChunk c = getChunk1(ChunkHelper.tIME, null, true);
-		return c != null ? ((PngChunkTIME) c).getAsString() : "";
+		PngChunkTIME c = getTime();
+		return c == null ? "" : c.getAsString();
 	}
 
 	// //////////// TEXT
 
-	public void setText(String k, String val, boolean useLatin1, boolean compress) {
+	/**
+	 * Creates a text chunk and queue it.
+	 * <p>
+	 *
+	 * @param k
+	 *            : key (latin1)
+	 * @param val
+	 *            (arbitrary, should be latin1 if useLatin1)
+	 * @param useLatin1
+	 * @param compress
+	 * @return Returns the created-queued chunks, just in case you want to
+	 *         examine, touch it
+	 */
+	public PngChunkTextVar setText(String k, String val, boolean useLatin1, boolean compress) {
 		if (compress && !useLatin1)
 			throw new PngjException("cannot compress non latin text");
 		PngChunkTextVar c;
@@ -115,21 +159,83 @@ public class PngMetadata {
 			((PngChunkITXT) c).setLangtag(k); // we use the same orig tag (this is not quite right)
 		}
 		c.setKeyVal(k, val);
-		setChunk(c, true);
+		queueChunk(c, true);
+		return c;
 	}
 
-	public void setText(String k, String val) {
-		setText(k, val, false, val.length() > 400);
+	public PngChunkTextVar setText(String k, String val) {
+		return setText(k, val, false, false);
 	}
 
-	/** tries all text chunks - returns null if not found */
+	/**
+	 * gets all text chunks with a given key
+	 * <p>
+	 * returns null if not found
+	 * <p>
+	 * Warning: this does not check the "lang" key of iTxt
+	 */
+	@SuppressWarnings("unchecked")
+	public List<? extends PngChunkTextVar> getTxtsForKey(String k) {
+		@SuppressWarnings("rawtypes")
+		List c = new ArrayList();
+		c.addAll(chunkList.getById(ChunkHelper.tEXt, k));
+		c.addAll(chunkList.getById(ChunkHelper.zTXt, k));
+		c.addAll(chunkList.getById(ChunkHelper.iTXt, k));
+		return c;
+	}
+
+	/**
+	 * Returns empty if not found, concatenated (with newlines) if multiple! -
+	 * and trimmed
+	 * <p>
+	 * Use getTxtsForKey() if you don't want this behaviour
+	 */
 	public String getTxtForKey(String k) {
-		PngChunk c = getChunk1(ChunkHelper.tEXt, k, true);
-		if (c == null)
-			c = getChunk1(ChunkHelper.zTXt, k, true);
-		if (c == null)
-			c = getChunk1(ChunkHelper.iTXt, k, true);
-		return c != null ? ((PngChunkTextVar) c).getVal() : null;
+		List<? extends PngChunkTextVar> li = getTxtsForKey(k);
+		if (li.isEmpty())
+			return "";
+		StringBuilder t = new StringBuilder();
+		for (PngChunkTextVar c : li)
+			t.append(c.getVal()).append("\n");
+		return t.toString().trim();
+	}
+
+	/**
+	 * Returns the palette chunk, if present
+	 *
+	 * @return null if not present
+	 */
+	public PngChunkPLTE getPLTE() {
+		return (PngChunkPLTE) chunkList.getById1(PngChunkPLTE.ID);
+	}
+
+	/**
+	 * Creates a new empty palette chunk, queues it for write and return it to
+	 * the caller, who should fill its entries
+	 */
+	public PngChunkPLTE createPLTEChunk() {
+		PngChunkPLTE plte = new PngChunkPLTE(chunkList.imageInfo);
+		queueChunk(plte);
+		return plte;
+	}
+
+	/**
+	 * Returns the TRNS chunk, if present
+	 *
+	 * @return null if not present
+	 */
+	public PngChunkTRNS getTRNS() {
+		return (PngChunkTRNS) chunkList.getById1(PngChunkTRNS.ID);
+	}
+
+	/**
+	 * Creates a new empty TRNS chunk, queues it for write and return it to the
+	 * caller, who should fill its entries
+	 */
+	public PngChunkTRNS createTRNSChunk() {
+		PngChunkTRNS trns = new PngChunkTRNS(chunkList.imageInfo);
+		queueChunk(trns);
+		return trns;
 	}
 
 }