tools/hiero/Kerning.java

/*******************************************************************************
 * Copyright 2011 See AUTHORS file.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************/

package com.badlogic.gdx.tools.hiero;

import com.badlogic.gdx.utils.IntArray;
import com.badlogic.gdx.utils.IntIntMap;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;

/** Reads a TTF font file and provides access to kerning information.
 *
 * Thanks to the Apache FOP project for their inspiring work!
 *
 * @author Nathan Sweet */
class Kerning {
	private TTFInputStream input;
	private float scale;
	private int headOffset = -1;
	private int kernOffset = -1;
	private int gposOffset = -1;
	private IntIntMap kernings = new IntIntMap();

	/** @param inputStream The data for the TTF font.
	 * @param fontSize The font size to use to determine kerning pixel offsets.
	 * @throws IOException If the font could not be read. */
	public void load (InputStream inputStream, int fontSize) throws IOException {
		if (inputStream == null) throw new IllegalArgumentException("inputStream cannot be null.");
		input = new TTFInputStream(inputStream);
		inputStream.close();

		readTableDirectory();
		if (headOffset == -1) throw new IOException("HEAD table not found.");
		readHEAD(fontSize);

		// By reading the 'kern' table last, it takes precedence over the 'GPOS' table. We are more likely to interpret
		// the GPOS table incorrectly because we ignore most of it, since BMFont doesn't support its features.
		if (gposOffset != -1) {
			input.seek(gposOffset);
			readGPOS();
		}
		if (kernOffset != -1) {
			input.seek(kernOffset);
			readKERN();
		}
		input.close();
		input = null;
	}

	/** @return A map from pairs of glyph codes to their kerning in pixels. Each map key encodes two glyph codes:
	 * the high 16 bits form the first glyph code, and the low 16 bits form the second. */
	public IntIntMap getKernings () {
		return kernings;
	}

	private void storeKerningOffset (int firstGlyphCode, int secondGlyphCode, int offset) {
		// Scale the offset values using the font size.
		int value = Math.round(offset * scale);
		if (value == 0) {
			return;
		}
		int key = (firstGlyphCode << 16) | secondGlyphCode;
		kernings.put(key, value);
	}

	private void readTableDirectory () throws IOException {
		input.skip(4);
		int tableCount = input.readUnsignedShort();
		input.skip(6);

		byte[] tagBytes = new byte[4];
		for (int i = 0; i < tableCount; i++) {
			tagBytes[0] = input.readByte();
			tagBytes[1] = input.readByte();
			tagBytes[2] = input.readByte();
			tagBytes[3] = input.readByte();
			input.skip(4);
			int offset = (int) input.readUnsignedLong();
			input.skip(4);

			String tag = new String(tagBytes, "ISO-8859-1");
			if (tag.equals("head")) {
				headOffset = offset;
			} else if (tag.equals("kern")) {
				kernOffset = offset;
			} else if (tag.equals("GPOS")) {
				gposOffset = offset;
			}
		}
	}

	private void readHEAD (int fontSize) throws IOException {
		input.seek(headOffset + 2 * 4 + 2 * 4 + 2);
		int unitsPerEm = input.readUnsignedShort();
		scale = (float)fontSize / unitsPerEm;
	}

	private void readKERN () throws IOException {
		input.seek(kernOffset + 2);
		for (int subTableCount = input.readUnsignedShort(); subTableCount > 0; subTableCount--) {
			input.skip(2 * 2);
			int tupleIndex = input.readUnsignedShort();
			if (!((tupleIndex & 1) != 0) || (tupleIndex & 2) != 0 || (tupleIndex & 4) != 0) return;
			if (tupleIndex >> 8 != 0) continue;

			int kerningCount = input.readUnsignedShort();
			input.skip(3 * 2);
			while (kerningCount-- > 0) {
				int firstGlyphCode = input.readUnsignedShort();
				int secondGlyphCode = input.readUnsignedShort();
				int offset = (int) input.readShort();
				storeKerningOffset(firstGlyphCode, secondGlyphCode, offset);
			}
		}
	}

	private void readGPOS () throws IOException {
		// See https://www.microsoft.com/typography/otspec/gpos.htm for the format and semantics.
		// Useful tools are ttfdump and showttf.
		input.seek(gposOffset + 4 + 2 + 2);
		int lookupListOffset = input.readUnsignedShort();
		input.seek(gposOffset + lookupListOffset);

		int lookupListPosition = input.getPosition();
		int lookupCount = input.readUnsignedShort();
		int[] lookupOffsets = input.readUnsignedShortArray(lookupCount);

		for (int i = 0; i < lookupCount; i++) {
			int lookupPosition = lookupListPosition + lookupOffsets[i];
			input.seek(lookupPosition);
			int type = input.readUnsignedShort();
			readSubtables(type, lookupPosition);
		}
	}

	private void readSubtables ( int type, int lookupPosition) throws IOException {
		input.skip(2);
		int subTableCount = input.readUnsignedShort();
		int[] subTableOffsets = input.readUnsignedShortArray(subTableCount);

		for (int i = 0; i < subTableCount; i++) {
			int subTablePosition = lookupPosition + subTableOffsets[i];
			readSubtable(type, subTablePosition);
		}
	}

	private void readSubtable (int type, int subTablePosition) throws IOException {
		input.seek(subTablePosition);
		if (type == 2) {
			readPairAdjustmentSubtable(subTablePosition);
		} else if (type == 9) {
			readExtensionPositioningSubtable(subTablePosition);
		}
	}

	private void readPairAdjustmentSubtable(int subTablePosition) throws IOException {
		int type = input.readUnsignedShort();
		if (type == 1) {
			readPairPositioningAdjustmentFormat1(subTablePosition);
		} else if (type == 2) {
			readPairPositioningAdjustmentFormat2(subTablePosition);
		}
	}

	private void readExtensionPositioningSubtable (int subTablePosition) throws IOException {
		int type = input.readUnsignedShort();
		if (type == 1) {
			readExtensionPositioningFormat1(subTablePosition);
		}
	}

	private void readPairPositioningAdjustmentFormat1 (long subTablePosition) throws IOException {
		int coverageOffset = input.readUnsignedShort();
		int valueFormat1 = input.readUnsignedShort();
		int valueFormat2 = input.readUnsignedShort();
		int pairSetCount = input.readUnsignedShort();
		int[] pairSetOffsets = input.readUnsignedShortArray(pairSetCount);

		input.seek((int) (subTablePosition + coverageOffset));
		int[] coverage = readCoverageTable();

		// The two should be equal, but just in case they're not, we can still do something sensible.
		pairSetCount = Math.min(pairSetCount, coverage.length);

		for (int i = 0; i < pairSetCount; i++) {
			int firstGlyph = coverage[i];
			input.seek((int) (subTablePosition + pairSetOffsets[i]));
			int pairValueCount = input.readUnsignedShort();
			for (int j = 0; j < pairValueCount; j++) {
				int secondGlyph = input.readUnsignedShort();
				int xAdvance1 = readXAdvanceFromValueRecord(valueFormat1);
				readXAdvanceFromValueRecord(valueFormat2); // Value2
				if (xAdvance1 != 0) {
					storeKerningOffset(firstGlyph, secondGlyph, xAdvance1);
				}
			}
		}
	}

	private void readPairPositioningAdjustmentFormat2 (int subTablePosition) throws IOException {
		int coverageOffset = input.readUnsignedShort();
		int valueFormat1 = input.readUnsignedShort();
		int valueFormat2 = input.readUnsignedShort();
		int classDefOffset1 = input.readUnsignedShort();
		int classDefOffset2 = input.readUnsignedShort();
		int class1Count = input.readUnsignedShort();
		int class2Count = input.readUnsignedShort();

		int position = input.getPosition();

		input.seek((int) (subTablePosition + coverageOffset));
		int[] coverage = readCoverageTable();

		input.seek(position);
		IntArray[] glyphsByClass1 = readClassDefinition(subTablePosition + classDefOffset1, class1Count);
		IntArray[] glyphsByClass2 = readClassDefinition(subTablePosition + classDefOffset2, class2Count);
		input.seek(position);

		for (int i = 0; i < coverage.length; i++) {
			int glyph = coverage[i];
			boolean found = false;
			for (int j = 1; j < class1Count && !found; j++) {
				found = glyphsByClass1[j].contains(glyph);
			}
			if (!found) {
				glyphsByClass1[0].add(glyph);
			}
		}

		for (int i = 0; i < class1Count; i++) {
			for (int j = 0; j < class2Count; j++) {
				int xAdvance1 = readXAdvanceFromValueRecord(valueFormat1);
				readXAdvanceFromValueRecord(valueFormat2); // Value2
				if (xAdvance1 == 0) continue;
				for (int k = 0; k < glyphsByClass1[i].size; k++) {
					int glyph1 = glyphsByClass1[i].items[k];
					for (int l = 0; l < glyphsByClass2[j].size; l++) {
						int glyph2 = glyphsByClass2[j].items[l];
						storeKerningOffset(glyph1, glyph2, xAdvance1);
					}
				}
			}
		}
	}

	private void readExtensionPositioningFormat1 (int subTablePosition) throws IOException {
		int lookupType = input.readUnsignedShort();
		int lookupPosition = subTablePosition + (int) input.readUnsignedLong();
		readSubtable(lookupType, lookupPosition);
	}

	private IntArray[] readClassDefinition (int position, int classCount) throws IOException {
		input.seek(position);

		IntArray[] glyphsByClass = new IntArray[classCount];
		for (int i = 0; i < classCount; i++) {
			glyphsByClass[i] = new IntArray();
		}

		int classFormat = input.readUnsignedShort();
		if (classFormat == 1) {
			readClassDefinitionFormat1(glyphsByClass);
		} else if (classFormat == 2) {
			readClassDefinitionFormat2(glyphsByClass);
		} else {
			throw new IOException("Unknown class definition table type " + classFormat);
		}
		return glyphsByClass;
	}

	private void readClassDefinitionFormat1 (IntArray[] glyphsByClass) throws IOException {
		int startGlyph = input.readUnsignedShort();
		int glyphCount = input.readUnsignedShort();
		int[] classValueArray = input.readUnsignedShortArray(glyphCount);
		for (int i = 0; i < glyphCount; i++) {
			int glyph = startGlyph + i;
			int glyphClass = classValueArray[i];
			if (glyphClass < glyphsByClass.length) {
				glyphsByClass[glyphClass].add(glyph);
			}
		}
	}

	private void readClassDefinitionFormat2 (IntArray[] glyphsByClass) throws IOException {
		int classRangeCount = input.readUnsignedShort();
		for (int i = 0; i < classRangeCount; i++) {
			int start = input.readUnsignedShort();
			int end = input.readUnsignedShort();
			int glyphClass = input.readUnsignedShort();
			if (glyphClass < glyphsByClass.length) {
				for (int glyph = start; glyph <= end; glyph++) {
					glyphsByClass[glyphClass].add(glyph);
				}
			}
		}
	}

	private int[] readCoverageTable () throws IOException {
		int format = input.readUnsignedShort();
		if (format == 1) {
			int glyphCount = input.readUnsignedShort();
			int[] glyphArray = input.readUnsignedShortArray(glyphCount);
			return glyphArray;
		} else if (format == 2) {
			int rangeCount = input.readUnsignedShort();
			IntArray glyphArray = new IntArray();
			for (int i = 0; i < rangeCount; i++) {
				int start = input.readUnsignedShort();
				int end = input.readUnsignedShort();
				input.skip(2);
				for (int glyph = start; glyph <= end; glyph++) {
					glyphArray.add(glyph);
				}
			}
			return glyphArray.shrink();
		}
		throw new IOException("Unknown coverage table format " + format);
	}

	private int readXAdvanceFromValueRecord (int valueFormat) throws IOException {
		int xAdvance = 0;
		for (int mask = 1; mask <= 0x8000 && mask <= valueFormat; mask <<= 1) {
			if ((valueFormat & mask) != 0) {
				int value = (int) input.readShort();
				if (mask == 0x0004) {
					xAdvance = value;
				}
			}
		}
		return xAdvance;
	}

	private static class TTFInputStream extends ByteArrayInputStream {
		public TTFInputStream (InputStream input) throws IOException {
			super(readAllBytes(input));
		}

		private static byte[] readAllBytes(InputStream input) throws IOException {
			ByteArrayOutputStream out = new ByteArrayOutputStream();
			int numRead;
			byte[] buffer = new byte[16384];
			while ((numRead = input.read(buffer, 0, buffer.length)) != -1) {
				out.write(buffer, 0, numRead);
			}
			return out.toByteArray();
		}

		public int getPosition () {
			return pos;
		}

		public void seek (int position) {
			pos = position;
		}

		public int readUnsignedByte () throws IOException {
			int b = read();
			if (b == -1) throw new EOFException("Unexpected end of file.");
			return b;
		}

		public byte readByte () throws IOException {
			return (byte) readUnsignedByte();
		}

		public int readUnsignedShort () throws IOException {
			return (readUnsignedByte() << 8) + readUnsignedByte();
		}

		public short readShort () throws IOException {
			return (short)readUnsignedShort();
		}

		public long readUnsignedLong () throws IOException {
			long value = readUnsignedByte();
			value = (value << 8) + readUnsignedByte();
			value = (value << 8) + readUnsignedByte();
			value = (value << 8) + readUnsignedByte();
			return value;
		}

		public int[] readUnsignedShortArray (int count) throws IOException {
			int[] shorts = new int[count];
			for (int i = 0; i < count; i++) {
				shorts[i] = readUnsignedShort();
			}
			return shorts;
		}
	}
}