Task 493: .OTF File Format
Task 493: .OTF File Format
File Format Specifications for .OTF
The .OTF file format is part of the OpenType specification, which is an extension of the SFNT (scalable font) format. It supports both TrueType and Compact Font Format (CFF) outlines. The format is binary, big-endian, and starts with a table directory that lists all font tables. Official specifications are detailed in the OpenType specification published by Microsoft.
List of Properties Intrinsic to the File Format
Based on the OpenType specification, the core properties are derived from the Offset Table (also called the Table Directory) at the start of the file. These include the header fields and the table records. Note that .OTF files are identified by the sfntVersion magic number (0x00010000 for TrueType-based or 0x4F54544F for CFF-based), and the format does not include external file system metadata like creation dates—these are OS-dependent. The intrinsic properties (binary structure) are:
- sfntVersion (uint32, offset 0): The version identifier. Must be 0x00010000 (integer 65536, for TrueType outlines) or 0x4F54544F ('OTTO', for CFF/CFF2 outlines).
- numTables (uint16, offset 4): The number of tables in the font.
- searchRange (uint16, offset 6): Calculated as the largest power of two less than or equal to numTables, multiplied by 16. Used for binary search optimization.
- entrySelector (uint16, offset 8): Calculated as the log base 2 of the largest power of two less than or equal to numTables.
- rangeShift (uint16, offset 10): Calculated as (numTables * 16) - searchRange.
- Table Records (array of structures starting at offset 12, each 16 bytes, repeated numTables times):
- tableTag (Tag/4 bytes, offset 0 in record): A 4-character ASCII tag identifying the table (e.g., 'cmap', 'head').
- checksum (uint32, offset 4 in record): The checksum of the table's data.
- offset (uint32, offset 8 in record): The byte offset from the start of the file to the table's data.
- length (uint32, offset 12 in record): The length of the table's data in bytes.
Required tables for a valid .OTF include 'cmap', 'head', 'hhea', 'hmtx', 'maxp', 'name', 'OS/2', 'post', and outline-specific ones like 'glyf'/'loca' (TrueType) or 'CFF '/'CFF2' (CFF). Tables are padded to 4-byte boundaries, but padding is not part of the length.
Two Direct Download Links for .OTF Files
- https://filesamples.com/samples/font/otf/Lato-Regular.otf
- https://filesamples.com/samples/font/otf/OpenSans-Regular.otf
Ghost Blog Embedded HTML JavaScript for Drag-and-Drop .OTF Property Dump
Below is a self-contained HTML page with embedded JavaScript that can be embedded in a Ghost blog post (or any HTML-supporting platform). It creates a drop zone where users can drag and drop a .OTF file. The script reads the file as an ArrayBuffer, parses the header and table directory using DataView, and dumps the properties to the screen in a  element.
Drag and drop a .OTF file here
Python Class for .OTF Handling
Below is a Python class that can open a .OTF file, decode/read the properties, print them to console, and write the parsed data back to a new file (preserving the original binary content for simplicity, as full table editing is beyond scope).
import struct
import os
class OTFHandler:
def __init__(self, file_path):
self.file_path = file_path
self.data = None
self.sfnt_version = None
self.num_tables = None
self.search_range = None
self.entry_selector = None
self.range_shift = None
self.table_records = [] # list of dicts: {'tag': str, 'checksum': int, 'offset': int, 'length': int}
def read(self):
with open(self.file_path, 'rb') as f:
self.data = f.read()
if len(self.data) < 12:
raise ValueError("Invalid OTF file: too short")
# Unpack header
self.sfnt_version, self.num_tables, self.search_range, self.entry_selector, self.range_shift = struct.unpack('>IHHHH', self.data[:12])
offset = 12
for _ in range(self.num_tables):
if offset + 16 > len(self.data):
raise ValueError("Invalid OTF file: incomplete table record")
tag_bytes = self.data[offset:offset+4]
tag = tag_bytes.decode('ascii', errors='ignore')
checksum, table_offset, length = struct.unpack('>III', self.data[offset+4:offset+16])
self.table_records.append({'tag': tag, 'checksum': checksum, 'offset': table_offset, 'length': length})
offset += 16
def print_properties(self):
print("OTF Properties:")
print(f"sfntVersion: 0x{self.sfnt_version:08X}")
print(f"numTables: {self.num_tables}")
print(f"searchRange: {self.search_range}")
print(f"entrySelector: {self.entry_selector}")
print(f"rangeShift: {self.range_shift}")
print("\nTable Records:")
for i, record in enumerate(self.table_records, 1):
print(f"- Table {i}:")
print(f" tableTag: '{record['tag']}'")
print(f" checksum: 0x{record['checksum']:08X}")
print(f" offset: {record['offset']}")
print(f" length: {record['length']}")
def write(self, output_path):
if not self.data:
raise ValueError("No data to write; call read() first")
with open(output_path, 'wb') as f:
f.write(self.data) # Writes original data; extend for modifications
# Example usage:
# handler = OTFHandler('example.otf')
# handler.read()
# handler.print_properties()
# handler.write('output.otf')
Java Class for .OTF Handling
Below is a Java class that can open a .OTF file, decode/read the properties, print them to console, and write the parsed data back to a new file (preserving original binary).
import java.io.*;
import java.nio.*;
import java.nio.channels.FileChannel;
import java.nio.file.*;
public class OTFHandler {
private Path filePath;
private ByteBuffer buffer;
private int sfntVersion;
private short numTables;
private short searchRange;
private short entrySelector;
private short rangeShift;
private TableRecord[] tableRecords;
static class TableRecord {
String tag;
int checksum;
int offset;
int length;
}
public OTFHandler(String filePath) {
this.filePath = Paths.get(filePath);
}
public void read() throws IOException {
try (FileChannel channel = FileChannel.open(filePath, StandardOpenOption.READ)) {
buffer = ByteBuffer.allocate((int) channel.size());
channel.read(buffer);
buffer.flip(); // Prepare for reading
buffer.order(ByteOrder.BIG_ENDIAN);
}
if (buffer.limit() < 12) {
throw new IOException("Invalid OTF file: too short");
}
sfntVersion = buffer.getInt(0);
numTables = buffer.getShort(4);
searchRange = buffer.getShort(6);
entrySelector = buffer.getShort(8);
rangeShift = buffer.getShort(10);
tableRecords = new TableRecord[numTables];
int pos = 12;
for (int i = 0; i < numTables; i++) {
if (pos + 16 > buffer.limit()) {
throw new IOException("Invalid OTF file: incomplete table record");
}
byte[] tagBytes = new byte[4];
buffer.position(pos);
buffer.get(tagBytes);
String tag = new String(tagBytes);
int checksum = buffer.getInt(pos + 4);
int offset = buffer.getInt(pos + 8);
int length = buffer.getInt(pos + 12);
TableRecord record = new TableRecord();
record.tag = tag;
record.checksum = checksum;
record.offset = offset;
record.length = length;
tableRecords[i] = record;
pos += 16;
}
}
public void printProperties() {
System.out.println("OTF Properties:");
System.out.printf("sfntVersion: 0x%08X%n", sfntVersion);
System.out.printf("numTables: %d%n", numTables);
System.out.printf("searchRange: %d%n", searchRange);
System.out.printf("entrySelector: %d%n", entrySelector);
System.out.printf("rangeShift: %d%n", rangeShift);
System.out.println("\nTable Records:");
for (int i = 0; i < tableRecords.length; i++) {
TableRecord record = tableRecords[i];
System.out.printf("- Table %d:%n", i + 1);
System.out.printf(" tableTag: '%s'%n", record.tag);
System.out.printf(" checksum: 0x%08X%n", record.checksum);
System.out.printf(" offset: %d%n", record.offset);
System.out.printf(" length: %d%n", record.length);
}
}
public void write(String outputPath) throws IOException {
if (buffer == null) {
throw new IOException("No data to write; call read() first");
}
buffer.position(0); // Reset to start
try (FileChannel outChannel = FileChannel.open(Paths.get(outputPath), StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
outChannel.write(buffer);
}
}
// Example usage:
// public static void main(String[] args) throws IOException {
// OTFHandler handler = new OTFHandler("example.otf");
// handler.read();
// handler.printProperties();
// handler.write("output.otf");
// }
}
JavaScript Class for .OTF Handling
Below is a JavaScript class (Node.js compatible) that can open a .OTF file using fs, decode/read the properties, print them to console, and write the data back to a new file.
const fs = require('fs');
class OTFHandler {
constructor(filePath) {
this.filePath = filePath;
this.buffer = null;
this.sfntVersion = null;
this.numTables = null;
this.searchRange = null;
this.entrySelector = null;
this.rangeShift = null;
this.tableRecords = []; // array of {tag: string, checksum: number, offset: number, length: number}
}
read() {
this.buffer = fs.readFileSync(this.filePath);
if (this.buffer.length < 12) {
throw new Error('Invalid OTF file: too short');
}
const dataView = new DataView(this.buffer.buffer);
this.sfntVersion = dataView.getUint32(0, false); // big-endian
this.numTables = dataView.getUint16(4, false);
this.searchRange = dataView.getUint16(6, false);
this.entrySelector = dataView.getUint16(8, false);
this.rangeShift = dataView.getUint16(10, false);
let offset = 12;
for (let i = 0; i < this.numTables; i++) {
if (offset + 16 > this.buffer.length) {
throw new Error('Invalid OTF file: incomplete table record');
}
const tag = String.fromCharCode(
dataView.getUint8(offset),
dataView.getUint8(offset + 1),
dataView.getUint8(offset + 2),
dataView.getUint8(offset + 3)
);
const checksum = dataView.getUint32(offset + 4, false);
const tableOffset = dataView.getUint32(offset + 8, false);
const length = dataView.getUint32(offset + 12, false);
this.tableRecords.push({ tag, checksum, offset: tableOffset, length });
offset += 16;
}
}
printProperties() {
console.log('OTF Properties:');
console.log(`sfntVersion: 0x${this.sfntVersion.toString(16).padStart(8, '0')}`);
console.log(`numTables: ${this.numTables}`);
console.log(`searchRange: ${this.searchRange}`);
console.log(`entrySelector: ${this.entrySelector}`);
console.log(`rangeShift: ${this.rangeShift}`);
console.log('\nTable Records:');
this.tableRecords.forEach((record, i) => {
console.log(`- Table ${i + 1}:`);
console.log(` tableTag: '${record.tag}'`);
console.log(` checksum: 0x${record.checksum.toString(16).padStart(8, '0')}`);
console.log(` offset: ${record.offset}`);
console.log(` length: ${record.length}`);
});
}
write(outputPath) {
if (!this.buffer) {
throw new Error('No data to write; call read() first');
}
fs.writeFileSync(outputPath, this.buffer);
}
}
// Example usage:
// const handler = new OTFHandler('example.otf');
// handler.read();
// handler.printProperties();
// handler.write('output.otf');
C++ Class for .OTF Handling
Below is a C++ class that can open a .OTF file, decode/read the properties, print them to console, and write the data back to a new file.
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <iomanip>
#include <cstdint>
class OTFHandler {
private:
std::string filePath;
std::vector<char> data;
uint32_t sfntVersion;
uint16_t numTables;
uint16_t searchRange;
uint16_t entrySelector;
uint16_t rangeShift;
struct TableRecord {
std::string tag;
uint32_t checksum;
uint32_t offset;
uint32_t length;
};
std::vector<TableRecord> tableRecords;
uint32_t readUint32(size_t pos) const {
return (static_cast<uint32_t>(data[pos]) << 24) |
(static_cast<uint32_t>(data[pos + 1]) << 16) |
(static_cast<uint32_t>(data[pos + 2]) << 8) |
static_cast<uint32_t>(data[pos + 3]);
}
uint16_t readUint16(size_t pos) const {
return (static_cast<uint16_t>(data[pos]) << 8) |
static_cast<uint16_t>(data[pos + 1]);
}
public:
OTFHandler(const std::string& filePath) : filePath(filePath) {}
void read() {
std::ifstream file(filePath, std::ios::binary | std::ios::ate);
if (!file) {
throw std::runtime_error("Cannot open file");
}
std::streamsize size = file.tellg();
file.seekg(0, std::ios::beg);
data.resize(size);
if (!file.read(data.data(), size)) {
throw std::runtime_error("Error reading file");
}
if (data.size() < 12) {
throw std::runtime_error("Invalid OTF file: too short");
}
sfntVersion = readUint32(0);
numTables = readUint16(4);
searchRange = readUint16(6);
entrySelector = readUint16(8);
rangeShift = readUint16(10);
size_t offset = 12;
tableRecords.reserve(numTables);
for (uint16_t i = 0; i < numTables; ++i) {
if (offset + 16 > data.size()) {
throw std::runtime_error("Invalid OTF file: incomplete table record");
}
std::string tag(data.begin() + offset, data.begin() + offset + 4);
uint32_t checksum = readUint32(offset + 4);
uint32_t tableOffset = readUint32(offset + 8);
uint32_t length = readUint32(offset + 12);
tableRecords.push_back({tag, checksum, tableOffset, length});
offset += 16;
}
}
void printProperties() const {
std::cout << "OTF Properties:" << std::endl;
std::cout << "sfntVersion: 0x" << std::hex << std::setw(8) << std::setfill('0') << sfntVersion << std::dec << std::endl;
std::cout << "numTables: " << numTables << std::endl;
std::cout << "searchRange: " << searchRange << std::endl;
std::cout << "entrySelector: " << entrySelector << std::endl;
std::cout << "rangeShift: " << rangeShift << std::endl;
std::cout << "\nTable Records:" << std::endl;
for (size_t i = 0; i < tableRecords.size(); ++i) {
const auto& record = tableRecords[i];
std::cout << "- Table " << (i + 1) << ":" << std::endl;
std::cout << " tableTag: '" << record.tag << "'" << std::endl;
std::cout << " checksum: 0x" << std::hex << std::setw(8) << std::setfill('0') << record.checksum << std::dec << std::endl;
std::cout << " offset: " << record.offset << std::endl;
std::cout << " length: " << record.length << std::endl;
}
}
void write(const std::string& outputPath) const {
if (data.empty()) {
throw std::runtime_error("No data to write; call read() first");
}
std::ofstream outFile(outputPath, std::ios::binary);
if (!outFile) {
throw std::runtime_error("Cannot open output file");
}
outFile.write(data.data(), data.size());
}
};
// Example usage:
// int main() {
// try {
// OTFHandler handler("example.otf");
// handler.read();
// handler.printProperties();
// handler.write("output.otf");
// } catch (const std::exception& e) {
// std::cerr << e.what() << std::endl;
// }
// return 0;
// }