1086 lines
26 KiB
V
1086 lines
26 KiB
V
module ttf
|
|
|
|
/**********************************************************************
|
|
*
|
|
* TrueTypeFont reader V implementation
|
|
*
|
|
* Copyright (c) 2021 Dario Deledda. All rights reserved.
|
|
* Use of this source code is governed by an MIT license
|
|
* that can be found in the LICENSE file.
|
|
*
|
|
* Note:
|
|
* - inspired by: http://stevehanov.ca/blog/?id=143
|
|
*
|
|
* TODO:
|
|
* - check for unicode > 0xFFFF if supported
|
|
* - evaluate use a buffer for the points in the glyph
|
|
**********************************************************************/
|
|
import strings
|
|
|
|
/******************************************************************************
|
|
*
|
|
* CMAP structs
|
|
*
|
|
******************************************************************************/
|
|
struct Segment {
|
|
mut:
|
|
id_range_offset u32
|
|
start_code u16
|
|
end_code u16
|
|
id_delta u16
|
|
}
|
|
|
|
struct TrueTypeCmap {
|
|
mut:
|
|
format int
|
|
cache []int = []int{len: 65536, init: -1} // for now we allocate 2^16 charcode
|
|
segments []Segment
|
|
arr []int
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* TTF_File structs
|
|
*
|
|
******************************************************************************/
|
|
pub struct TTF_File {
|
|
pub mut:
|
|
buf []byte
|
|
pos u32
|
|
length u16
|
|
scalar_type u32
|
|
search_range u16
|
|
entry_selector u16
|
|
range_shift u16
|
|
tables map[string]Offset_Table
|
|
version f32
|
|
font_revision f32
|
|
checksum_adjustment u32
|
|
magic_number u32
|
|
flags u16
|
|
units_per_em u16
|
|
created u64
|
|
modified u64
|
|
x_min f32
|
|
y_min f32
|
|
x_max f32
|
|
y_max f32
|
|
mac_style u16
|
|
lowest_rec_ppem u16
|
|
font_direction_hint i16
|
|
index_to_loc_format i16
|
|
glyph_data_format i16
|
|
font_family string
|
|
font_sub_family string
|
|
full_name string
|
|
postscript_name string
|
|
cmaps []TrueTypeCmap
|
|
ascent i16
|
|
descent i16
|
|
line_gap i16
|
|
advance_width_max u16
|
|
min_left_side_bearing i16
|
|
min_right_side_bearing i16
|
|
x_max_extent i16
|
|
caret_slope_rise i16
|
|
caret_slope_run i16
|
|
caret_offset i16
|
|
metric_data_format i16
|
|
num_of_long_hor_metrics u16
|
|
kern []Kern0Table
|
|
// cache
|
|
glyph_cache map[int]Glyph
|
|
}
|
|
|
|
pub fn (mut tf TTF_File) init() {
|
|
tf.read_offset_tables()
|
|
tf.read_head_table()
|
|
// dprintln(tf.get_info_string())
|
|
tf.read_name_table()
|
|
tf.read_cmap_table()
|
|
tf.read_hhea_table()
|
|
tf.read_kern_table()
|
|
tf.length = tf.glyph_count()
|
|
dprintln('Number of symbols: $tf.length')
|
|
dprintln('*****************************')
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* TTF_File Glyph Structs
|
|
*
|
|
******************************************************************************/
|
|
pub struct Point {
|
|
pub mut:
|
|
x int
|
|
y int
|
|
on_curve bool
|
|
}
|
|
|
|
struct Gylph_Component {
|
|
mut:
|
|
points []Point
|
|
}
|
|
|
|
// type of glyph
|
|
const (
|
|
g_type_simple = u16(1) // simple type
|
|
g_type_complex = u16(2) // compound type
|
|
)
|
|
|
|
pub struct Glyph {
|
|
pub mut:
|
|
g_type u16 = ttf.g_type_simple
|
|
contour_ends []u16
|
|
number_of_contours i16
|
|
points []Point
|
|
x_min i16
|
|
x_max i16
|
|
y_min i16
|
|
y_max i16
|
|
valid_glyph bool
|
|
components []Component
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* TTF_File metrics and glyph
|
|
*
|
|
******************************************************************************/
|
|
pub fn (mut tf TTF_File) get_horizontal_metrics(glyph_index u16) (int, int) {
|
|
assert 'hmtx' in tf.tables
|
|
old_pos := tf.pos
|
|
mut offset := tf.tables['hmtx'].offset
|
|
|
|
mut advance_width := 0
|
|
mut left_side_bearing := 0
|
|
if glyph_index < tf.num_of_long_hor_metrics {
|
|
offset += glyph_index * 4
|
|
tf.pos = offset
|
|
advance_width = tf.get_u16()
|
|
left_side_bearing = tf.get_i16()
|
|
// dprintln("Found h_metric aw: $advance_width lsb: $left_side_bearing")
|
|
} else {
|
|
// read the last entry of the hMetrics array
|
|
tf.pos = offset + (tf.num_of_long_hor_metrics - 1) * 4
|
|
advance_width = tf.get_u16()
|
|
tf.pos = offset + tf.num_of_long_hor_metrics * 4 +
|
|
2 * (glyph_index - tf.num_of_long_hor_metrics)
|
|
left_side_bearing = tf.get_fword()
|
|
}
|
|
tf.pos = old_pos
|
|
return advance_width, left_side_bearing
|
|
}
|
|
|
|
fn (mut tf TTF_File) get_glyph_offset(index u32) u32 {
|
|
// check if needed tables exists
|
|
assert 'loca' in tf.tables
|
|
assert 'glyf' in tf.tables
|
|
mut old_pos := tf.pos
|
|
|
|
table := tf.tables['loca']
|
|
mut offset := u32(0)
|
|
mut next := u32(0)
|
|
if tf.index_to_loc_format == 1 {
|
|
tf.pos = table.offset + (index << 2)
|
|
offset = tf.get_u32()
|
|
next = tf.get_u32()
|
|
} else {
|
|
tf.pos = table.offset + (index << 1)
|
|
offset = tf.get_u16() << 1
|
|
next = tf.get_u16() << 1
|
|
}
|
|
|
|
if offset == next {
|
|
// indicates glyph has no outline( eg space)
|
|
return 0
|
|
}
|
|
// dprintln("Offset for glyph index $index is $offset")
|
|
tf.pos = old_pos
|
|
return offset + tf.tables['glyf'].offset
|
|
}
|
|
|
|
fn (mut tf TTF_File) glyph_count() u16 {
|
|
assert 'maxp' in tf.tables
|
|
old_pos := tf.pos
|
|
tf.pos = tf.tables['maxp'].offset + 4
|
|
count := tf.get_u16()
|
|
tf.pos = old_pos
|
|
return count
|
|
}
|
|
|
|
pub fn (mut tf TTF_File) read_glyph_dim(index u16) (int, int, int, int) {
|
|
offset := tf.get_glyph_offset(index)
|
|
// dprintln("offset: $offset")
|
|
if offset == 0 || offset >= tf.tables['glyf'].offset + tf.tables['glyf'].length {
|
|
dprintln('No glyph found!')
|
|
return 0, 0, 0, 0
|
|
}
|
|
|
|
assert offset >= tf.tables['glyf'].offset
|
|
assert offset < tf.tables['glyf'].offset + tf.tables['glyf'].length
|
|
|
|
tf.pos = offset
|
|
// dprintln("file seek read_glyph: $tf.pos")
|
|
|
|
// number_of_contours
|
|
_ := tf.get_i16()
|
|
x_min := tf.get_fword()
|
|
y_min := tf.get_fword()
|
|
x_max := tf.get_fword()
|
|
y_max := tf.get_fword()
|
|
|
|
return x_min, x_max, y_min, y_max
|
|
}
|
|
|
|
pub fn (mut tf TTF_File) read_glyph(index u16) Glyph {
|
|
index_int := int(index) // index.str()
|
|
if index_int in tf.glyph_cache {
|
|
// dprintln("Found glyp: ${index}")
|
|
return tf.glyph_cache[index_int]
|
|
}
|
|
// dprintln("Create glyp: ${index}")
|
|
|
|
offset := tf.get_glyph_offset(index)
|
|
// dprintln("offset: $offset")
|
|
if offset == 0 || offset >= tf.tables['glyf'].offset + tf.tables['glyf'].length {
|
|
dprintln('No glyph found!')
|
|
return Glyph{}
|
|
}
|
|
|
|
assert offset >= tf.tables['glyf'].offset
|
|
assert offset < tf.tables['glyf'].offset + tf.tables['glyf'].length
|
|
|
|
tf.pos = offset
|
|
// dprintln("file seek read_glyph: $tf.pos")
|
|
|
|
/*
|
|
---- BUG TO SOLVE -----
|
|
--- Order of the data if printed in the main is shuffled!! Very Strange
|
|
mut tmp_glyph := Glyph{
|
|
number_of_contours : tf.get_i16()
|
|
x_min : tf.get_fword()
|
|
y_min : tf.get_fword()
|
|
x_max : tf.get_fword()
|
|
y_max : tf.get_fword()
|
|
}
|
|
*/
|
|
|
|
mut tmp_glyph := Glyph{}
|
|
tmp_glyph.number_of_contours = tf.get_i16()
|
|
tmp_glyph.x_min = tf.get_fword()
|
|
tmp_glyph.y_min = tf.get_fword()
|
|
tmp_glyph.x_max = tf.get_fword()
|
|
tmp_glyph.y_max = tf.get_fword()
|
|
|
|
// dprintln("file seek after read_glyph: $tf.pos")
|
|
|
|
assert tmp_glyph.number_of_contours >= -1
|
|
|
|
if tmp_glyph.number_of_contours == -1 {
|
|
// dprintln("read_compound_glyph")
|
|
tf.read_compound_glyph(mut tmp_glyph)
|
|
} else {
|
|
// dprintln("read_simple_glyph")
|
|
tf.read_simple_glyph(mut tmp_glyph)
|
|
}
|
|
|
|
tf.glyph_cache[index_int] = tmp_glyph
|
|
return tmp_glyph
|
|
}
|
|
|
|
const (
|
|
tfk_on_curve = 1
|
|
tfk_x_is_byte = 2
|
|
tfk_y_is_byte = 4
|
|
tfk_repeat = 8
|
|
tfk_x_delta = 16
|
|
tfk_y_delta = 32
|
|
)
|
|
|
|
fn (mut tf TTF_File) read_simple_glyph(mut in_glyph Glyph) {
|
|
if in_glyph.number_of_contours == 0 {
|
|
return
|
|
}
|
|
|
|
for _ in 0 .. in_glyph.number_of_contours {
|
|
in_glyph.contour_ends << tf.get_u16()
|
|
}
|
|
|
|
// skip over intructions
|
|
tf.pos = tf.get_u16() + tf.pos
|
|
|
|
mut num_points := 0
|
|
for ce in in_glyph.contour_ends {
|
|
if ce > num_points {
|
|
num_points = ce
|
|
}
|
|
}
|
|
num_points++
|
|
|
|
mut i := 0
|
|
mut flags := []byte{}
|
|
for i < num_points {
|
|
flag := tf.get_u8()
|
|
flags << flag
|
|
in_glyph.points << Point{
|
|
x: 0
|
|
y: 0
|
|
on_curve: (flag & ttf.tfk_on_curve) > 0
|
|
}
|
|
if (flag & ttf.tfk_repeat) > 0 {
|
|
mut repeat_count := tf.get_u8()
|
|
assert repeat_count > 0
|
|
i += repeat_count
|
|
for repeat_count > 0 {
|
|
flags << flag
|
|
in_glyph.points << Point{
|
|
x: 0
|
|
y: 0
|
|
on_curve: (flag & ttf.tfk_on_curve) > 0
|
|
}
|
|
repeat_count--
|
|
}
|
|
}
|
|
i++
|
|
}
|
|
|
|
// read coords x
|
|
mut value := 0
|
|
for i_x in 0 .. num_points {
|
|
flag_x := flags[i_x]
|
|
if (flag_x & ttf.tfk_x_is_byte) > 0 {
|
|
if (flag_x & ttf.tfk_x_delta) > 0 {
|
|
value += tf.get_u8()
|
|
} else {
|
|
value -= tf.get_u8()
|
|
}
|
|
} else if (~flag_x & ttf.tfk_x_delta) > 0 {
|
|
value += tf.get_i16()
|
|
} else {
|
|
// value is unchanged
|
|
}
|
|
// dprintln("$i_x x: $value")
|
|
in_glyph.points[i_x].x = value
|
|
}
|
|
|
|
// read coords y
|
|
value = 0
|
|
for i_y in 0 .. num_points {
|
|
flag_y := flags[i_y]
|
|
if (flag_y & ttf.tfk_y_is_byte) > 0 {
|
|
if (flag_y & ttf.tfk_y_delta) > 0 {
|
|
value += tf.get_u8()
|
|
} else {
|
|
value -= tf.get_u8()
|
|
}
|
|
} else if (~flag_y & ttf.tfk_y_delta) > 0 {
|
|
value += tf.get_i16()
|
|
} else {
|
|
// value is unchanged
|
|
}
|
|
// dprintln("$i_y y: $value")
|
|
in_glyph.points[i_y].y = value
|
|
}
|
|
|
|
// ok we have a valid glyph
|
|
in_glyph.valid_glyph = true
|
|
}
|
|
|
|
const (
|
|
tfkc_arg_1_and_2_are_words = 1
|
|
tfkc_args_are_xy_values = 2
|
|
tfkc_round_xy_to_grid = 4
|
|
tfkc_we_have_a_scale = 8
|
|
// reserved = 16
|
|
tfkc_more_components = 32
|
|
tfkc_we_have_an_x_and_y_scale = 64
|
|
tfkc_we_have_a_two_by_two = 128
|
|
tfkc_we_have_instructions = 256
|
|
tfkc_use_my_metrics = 512
|
|
tfkc_overlap_component = 1024
|
|
)
|
|
|
|
struct Component {
|
|
mut:
|
|
glyph_index u16
|
|
dest_point_index i16
|
|
src_point_index i16
|
|
matrix []f32 = [f32(1.0), 0, 0, 1.0, 0, 0]
|
|
}
|
|
|
|
fn (mut tf TTF_File) read_compound_glyph(mut in_glyph Glyph) {
|
|
in_glyph.g_type = ttf.g_type_complex
|
|
mut component := Component{}
|
|
mut flags := ttf.tfkc_more_components
|
|
for (flags & ttf.tfkc_more_components) > 0 {
|
|
mut arg1 := i16(0)
|
|
mut arg2 := i16(0)
|
|
|
|
flags = tf.get_u16()
|
|
|
|
component.glyph_index = tf.get_u16()
|
|
|
|
if (flags & ttf.tfkc_arg_1_and_2_are_words) > 0 {
|
|
arg1 = tf.get_i16()
|
|
arg2 = tf.get_i16()
|
|
} else {
|
|
arg1 = tf.get_u8()
|
|
arg2 = tf.get_u8()
|
|
}
|
|
|
|
if (flags & ttf.tfkc_args_are_xy_values) > 0 {
|
|
component.matrix[4] = arg1
|
|
component.matrix[5] = arg2
|
|
} else {
|
|
component.dest_point_index = arg1
|
|
component.src_point_index = arg2
|
|
}
|
|
|
|
if (flags & ttf.tfkc_we_have_a_scale) > 0 {
|
|
component.matrix[0] = tf.get_2dot14()
|
|
component.matrix[3] = component.matrix[0]
|
|
} else if (flags & ttf.tfkc_we_have_an_x_and_y_scale) > 0 {
|
|
component.matrix[0] = tf.get_2dot14()
|
|
component.matrix[3] = tf.get_2dot14()
|
|
} else if (flags & ttf.tfkc_we_have_a_two_by_two) > 0 {
|
|
component.matrix[0] = tf.get_2dot14()
|
|
component.matrix[1] = tf.get_2dot14()
|
|
component.matrix[2] = tf.get_2dot14()
|
|
component.matrix[3] = tf.get_2dot14()
|
|
}
|
|
// dprintln("Read component glyph index ${component.glyph_index}")
|
|
// dprintln("Transform: ${component.matrix}")
|
|
|
|
old_pos := tf.pos
|
|
|
|
simple_glyph := tf.read_glyph(component.glyph_index)
|
|
if simple_glyph.valid_glyph {
|
|
point_offset := in_glyph.points.len
|
|
for i in 0 .. simple_glyph.contour_ends.len {
|
|
in_glyph.contour_ends << u16(simple_glyph.contour_ends[i] + point_offset)
|
|
}
|
|
|
|
for p in simple_glyph.points {
|
|
mut x := f32(p.x)
|
|
mut y := f32(p.y)
|
|
x = component.matrix[0] * x + component.matrix[1] * y + component.matrix[4]
|
|
y = component.matrix[2] * x + component.matrix[3] * y + component.matrix[5]
|
|
in_glyph.points << Point{
|
|
x: int(x)
|
|
y: int(y)
|
|
on_curve: p.on_curve
|
|
}
|
|
}
|
|
}
|
|
tf.pos = old_pos
|
|
}
|
|
|
|
in_glyph.number_of_contours = i16(in_glyph.contour_ends.len)
|
|
|
|
if (flags & ttf.tfkc_we_have_instructions) > 0 {
|
|
tf.pos = tf.get_u16() + tf.pos
|
|
}
|
|
// ok we have a valid glyph
|
|
in_glyph.valid_glyph = true
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* TTF_File get functions
|
|
*
|
|
******************************************************************************/
|
|
fn (mut tf TTF_File) get_u8() byte {
|
|
x := tf.buf[tf.pos]
|
|
tf.pos++
|
|
return byte(x)
|
|
}
|
|
|
|
fn (mut tf TTF_File) get_i8() i8 {
|
|
return i8(tf.get_u8())
|
|
}
|
|
|
|
fn (mut tf TTF_File) get_u16() u16 {
|
|
x := u16(tf.buf[tf.pos] << u16(8)) | u16(tf.buf[tf.pos + 1])
|
|
tf.pos += 2
|
|
return x
|
|
}
|
|
|
|
fn (mut tf TTF_File) get_ufword() u16 {
|
|
return tf.get_u16()
|
|
}
|
|
|
|
fn (mut tf TTF_File) get_i16() i16 {
|
|
return i16(tf.get_u16())
|
|
}
|
|
|
|
fn (mut tf TTF_File) get_fword() i16 {
|
|
return tf.get_i16()
|
|
}
|
|
|
|
fn (mut tf TTF_File) get_u32() u32 {
|
|
x := (u32(tf.buf[tf.pos]) << u32(24)) | (u32(tf.buf[tf.pos + 1]) << u32(16)) | (u32(tf.buf[
|
|
tf.pos + 2]) << u32(8)) | u32(tf.buf[tf.pos + 3])
|
|
tf.pos += 4
|
|
return x
|
|
}
|
|
|
|
fn (mut tf TTF_File) get_i32() int {
|
|
return int(tf.get_u32())
|
|
}
|
|
|
|
fn (mut tf TTF_File) get_2dot14() f32 {
|
|
return f32(tf.get_i16()) / f32(i16(1 << 14))
|
|
}
|
|
|
|
fn (mut tf TTF_File) get_fixed() f32 {
|
|
return f32(tf.get_i32() / f32(1 << 16))
|
|
}
|
|
|
|
fn (mut tf TTF_File) get_string(length int) string {
|
|
tmp_pos := u64(tf.pos)
|
|
tf.pos += u32(length)
|
|
return unsafe { tos(byteptr(u64(tf.buf.data) + tmp_pos), length) }
|
|
}
|
|
|
|
fn (mut tf TTF_File) get_unicode_string(length int) string {
|
|
mut tmp_txt := strings.new_builder(length)
|
|
mut real_len := 0
|
|
|
|
for _ in 0 .. (length >> 1) {
|
|
c := tf.get_u16()
|
|
c_len := ((0xe5000000 >> ((c >> 3) & 0x1e)) & 3) + 1
|
|
real_len += c_len
|
|
if c_len == 1 {
|
|
tmp_txt.write_b(byte(c & 0xff))
|
|
} else {
|
|
tmp_txt.write_b(byte((c >> 8) & 0xff))
|
|
tmp_txt.write_b(byte(c & 0xff))
|
|
}
|
|
// dprintln("c: ${c:c}|${ byte(c &0xff) :c} c_len: ${c_len} str_len: ${real_len} in_len: ${length}")
|
|
}
|
|
tf.pos += u32(real_len)
|
|
res_txt := tmp_txt.str()
|
|
// dprintln("get_unicode_string: ${res_txt}")
|
|
return res_txt
|
|
}
|
|
|
|
fn (mut tf TTF_File) get_date() u64 {
|
|
// get mac time and covert it to unix timestamp
|
|
mac_time := (u64(tf.get_u32()) << 32) + u64(tf.get_u32())
|
|
utc_time := mac_time - u64(2082844800)
|
|
return utc_time
|
|
}
|
|
|
|
fn (mut tf TTF_File) calc_checksum(offset u32, length u32) u32 {
|
|
old_index := tf.pos
|
|
mut sum := u64(0)
|
|
mut nlongs := int((length + 3) >> 2)
|
|
tf.pos = offset
|
|
// dprintln("offs: $offset nlongs: $nlongs")
|
|
for nlongs > 0 {
|
|
sum = sum + u64(tf.get_u32())
|
|
nlongs--
|
|
}
|
|
tf.pos = old_index
|
|
return u32(sum & u64(0xffff_ffff))
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Offset_Table
|
|
*
|
|
******************************************************************************/
|
|
struct Offset_Table {
|
|
mut:
|
|
checksum u32
|
|
offset u32
|
|
length u32
|
|
}
|
|
|
|
fn (mut tf TTF_File) read_offset_tables() {
|
|
dprintln('*** READ TABLES OFFSET ***')
|
|
tf.pos = 0
|
|
tf.scalar_type = tf.get_u32()
|
|
num_tables := tf.get_u16()
|
|
tf.search_range = tf.get_u16()
|
|
tf.entry_selector = tf.get_u16()
|
|
tf.range_shift = tf.get_u16()
|
|
|
|
dprintln('scalar_type : [0x$tf.scalar_type.hex()]')
|
|
dprintln('num tables : [$num_tables]')
|
|
dprintln('search_range : [0x$tf.search_range.hex()]')
|
|
dprintln('entry_selector: [0x$tf.entry_selector.hex()]')
|
|
dprintln('range_shift : [0x$tf.range_shift.hex()]')
|
|
|
|
mut i := 0
|
|
for i < num_tables {
|
|
tag := tf.get_string(4)
|
|
tf.tables[tag] = {
|
|
checksum: tf.get_u32()
|
|
offset: tf.get_u32()
|
|
length: tf.get_u32()
|
|
}
|
|
dprintln('Table: [$tag]')
|
|
// dprintln("${tf.tables[tag]}")
|
|
|
|
if tag != 'head' {
|
|
assert tf.calc_checksum(tf.tables[tag].offset, tf.tables[tag].length) == tf.tables[tag].checksum
|
|
}
|
|
i++
|
|
}
|
|
dprintln('*** END READ TABLES OFFSET ***')
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Head_Table
|
|
*
|
|
******************************************************************************/
|
|
fn (mut tf TTF_File) read_head_table() {
|
|
dprintln('*** READ HEAD TABLE ***')
|
|
tf.pos = tf.tables['head'].offset
|
|
dprintln('Offset: $tf.pos')
|
|
|
|
tf.version = tf.get_fixed()
|
|
tf.font_revision = tf.get_fixed()
|
|
tf.checksum_adjustment = tf.get_u32()
|
|
tf.magic_number = tf.get_u32()
|
|
assert tf.magic_number == 0x5f0f3cf5
|
|
tf.flags = tf.get_u16()
|
|
tf.units_per_em = tf.get_u16()
|
|
tf.created = tf.get_date()
|
|
tf.modified = tf.get_date()
|
|
tf.x_min = tf.get_i16()
|
|
tf.y_min = tf.get_i16()
|
|
tf.x_max = tf.get_i16()
|
|
tf.y_max = tf.get_i16()
|
|
tf.mac_style = tf.get_u16()
|
|
tf.lowest_rec_ppem = tf.get_u16()
|
|
tf.font_direction_hint = tf.get_i16()
|
|
tf.index_to_loc_format = tf.get_i16()
|
|
tf.glyph_data_format = tf.get_i16()
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Name_Table
|
|
*
|
|
******************************************************************************/
|
|
fn (mut tf TTF_File) read_name_table() {
|
|
dprintln('*** READ NAME TABLE ***')
|
|
assert 'name' in tf.tables
|
|
table_offset := tf.tables['name'].offset
|
|
tf.pos = tf.tables['name'].offset
|
|
|
|
format := tf.get_u16() // must be 0
|
|
assert format == 0
|
|
count := tf.get_u16()
|
|
string_offset := tf.get_u16()
|
|
|
|
for _ in 0 .. count {
|
|
platform_id := tf.get_u16()
|
|
// platform_specific_id :=
|
|
tf.get_u16()
|
|
// language_id :=
|
|
tf.get_u16()
|
|
name_id := tf.get_u16()
|
|
length := tf.get_u16()
|
|
offset := tf.get_u16()
|
|
|
|
old_pos := tf.pos
|
|
tf.pos = table_offset + string_offset + offset
|
|
|
|
mut name := ''
|
|
if platform_id == 0 || platform_id == 3 {
|
|
name = tf.get_unicode_string(length)
|
|
} else {
|
|
name = tf.get_string(length)
|
|
}
|
|
// dprintln("Name [${platform_id} / ${platform_specific_id}] id:[$name_id] language:[$language_id] [$name]")
|
|
tf.pos = old_pos
|
|
|
|
match name_id {
|
|
1 { tf.font_family = name }
|
|
2 { tf.font_sub_family = name }
|
|
4 { tf.full_name = name }
|
|
6 { tf.postscript_name = name }
|
|
else {}
|
|
}
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Cmap_Table
|
|
*
|
|
******************************************************************************/
|
|
fn (mut tf TTF_File) read_cmap_table() {
|
|
dprintln('*** READ CMAP TABLE ***')
|
|
assert 'cmap' in tf.tables
|
|
table_offset := tf.tables['cmap'].offset
|
|
tf.pos = table_offset
|
|
|
|
version := tf.get_u16() // must be 0
|
|
assert version == 0
|
|
number_sub_tables := tf.get_u16()
|
|
|
|
// tables must be sorted by platform id and then platform specific
|
|
// encoding.
|
|
for _ in 0 .. number_sub_tables {
|
|
// platforms are:
|
|
// 0 - Unicode -- use specific id 6 for full coverage. 0/4 common.
|
|
// 1 - Macintosh (Discouraged)
|
|
// 2 - reserved
|
|
// 3 - Microsoft
|
|
platform_id := tf.get_u16()
|
|
platform_specific_id := tf.get_u16()
|
|
offset := tf.get_u32()
|
|
dprintln('CMap platform_id=$platform_id specific_id=$platform_specific_id offset=$offset')
|
|
if platform_id == 3 && platform_specific_id <= 1 {
|
|
tf.read_cmap(table_offset + offset)
|
|
}
|
|
}
|
|
}
|
|
|
|
fn (mut tf TTF_File) read_cmap(offset u32) {
|
|
old_pos := tf.pos
|
|
tf.pos = offset
|
|
format := tf.get_u16()
|
|
length := tf.get_u16()
|
|
language := tf.get_u16()
|
|
|
|
dprintln(' Cmap format: $format length: $length language: $language')
|
|
if format == 0 {
|
|
dprintln(' Cmap 0 Init...')
|
|
mut cmap := TrueTypeCmap{}
|
|
cmap.init_0(mut tf)
|
|
tf.cmaps << cmap
|
|
} else if format == 4 {
|
|
dprintln(' Cmap 4 Init...')
|
|
mut cmap := TrueTypeCmap{}
|
|
cmap.init_4(mut tf)
|
|
tf.cmaps << cmap
|
|
}
|
|
|
|
tf.pos = old_pos
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* CMAPS 0/4
|
|
*
|
|
******************************************************************************/
|
|
fn (mut tf TTF_File) map_code(char_code int) u16 {
|
|
mut index := 0
|
|
for i in 0 .. tf.cmaps.len {
|
|
mut cmap := tf.cmaps[i]
|
|
if cmap.format == 0 {
|
|
// dprintln("format 0")
|
|
index = cmap.map_0(char_code)
|
|
} else if cmap.format == 4 {
|
|
// dprintln("format 4")
|
|
index = cmap.map_4(char_code, mut tf)
|
|
}
|
|
}
|
|
return u16(index)
|
|
}
|
|
|
|
fn (mut tm TrueTypeCmap) init_0(mut tf TTF_File) {
|
|
tm.format = 0
|
|
for i in 0 .. 256 {
|
|
glyph_index := tf.get_u8()
|
|
dprintln(' Glyph[$i] = %glyph_index')
|
|
tm.arr << glyph_index
|
|
}
|
|
}
|
|
|
|
fn (mut tm TrueTypeCmap) map_0(char_code int) int {
|
|
if char_code >= 0 && char_code <= 255 {
|
|
// dprintln("charCode $char_code maps to ${tm.arr[char_code]}")
|
|
return tm.arr[char_code]
|
|
}
|
|
return 0
|
|
}
|
|
|
|
fn (mut tm TrueTypeCmap) init_4(mut tf TTF_File) {
|
|
tm.format = 4
|
|
|
|
// 2x segcount
|
|
seg_count := tf.get_u16() >> 1
|
|
// search_range :=
|
|
tf.get_u16()
|
|
// entry_selector :=
|
|
tf.get_u16()
|
|
// range_shift :=
|
|
tf.get_u16()
|
|
|
|
// Ending character code for each segment, last is 0xffff
|
|
for _ in 0 .. seg_count {
|
|
tm.segments << Segment{0, 0, tf.get_u16(), 0}
|
|
}
|
|
|
|
// reservePAD
|
|
tf.get_u16()
|
|
|
|
// starting character code for each segment
|
|
for i in 0 .. seg_count {
|
|
tm.segments[i].start_code = tf.get_u16()
|
|
}
|
|
|
|
// Delta for all character codes in segment
|
|
for i in 0 .. seg_count {
|
|
tm.segments[i].id_delta = tf.get_u16()
|
|
}
|
|
|
|
// offset in bytes to glyph indexArray, or 0
|
|
for i in 0 .. seg_count {
|
|
ro := u32(tf.get_u16())
|
|
if ro != 0 {
|
|
tm.segments[i].id_range_offset = tf.pos - 2 + ro
|
|
} else {
|
|
tm.segments[i].id_range_offset = 0
|
|
}
|
|
}
|
|
/*
|
|
// DEBUG LOG
|
|
for i in 0..seg_count {
|
|
seg := tm.segments[i]
|
|
dprintln(" segments[$i] = $seg.start_code $seg.end_code $seg.id_delta $seg.id_range_offset")
|
|
}
|
|
*/
|
|
}
|
|
|
|
fn (mut tm TrueTypeCmap) map_4(char_code int, mut tf TTF_File) int {
|
|
// dprintln("HERE map_4 for char [$char_code]")
|
|
old_pos := tf.pos
|
|
if tm.cache[char_code] == -1 {
|
|
// dprintln("Not found, search for it!")
|
|
mut found := false
|
|
for segment in tm.segments {
|
|
if segment.start_code <= char_code && segment.end_code >= char_code {
|
|
mut index := (segment.id_delta + char_code) & 0xffff
|
|
if segment.id_range_offset > 0 {
|
|
glyph_index_address := segment.id_range_offset +
|
|
2 * u32(char_code - segment.start_code)
|
|
tf.pos = glyph_index_address
|
|
index = tf.get_u16()
|
|
}
|
|
|
|
tm.cache[char_code] = index
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
tm.cache[char_code] = 0
|
|
}
|
|
}
|
|
tf.pos = old_pos
|
|
return tm.cache[char_code]
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Hhea table
|
|
*
|
|
******************************************************************************/
|
|
fn (mut tf TTF_File) read_hhea_table() {
|
|
dprintln('*** READ HHEA TABLE ***')
|
|
assert 'hhea' in tf.tables
|
|
table_offset := tf.tables['hhea'].offset
|
|
tf.pos = table_offset
|
|
|
|
// version :=
|
|
tf.get_fixed() // 0x00010000
|
|
|
|
tf.ascent = tf.get_fword()
|
|
tf.descent = tf.get_fword()
|
|
tf.line_gap = tf.get_fword()
|
|
tf.advance_width_max = tf.get_ufword()
|
|
tf.min_left_side_bearing = tf.get_fword()
|
|
tf.min_right_side_bearing = tf.get_fword()
|
|
tf.x_max_extent = tf.get_fword()
|
|
tf.caret_slope_rise = tf.get_i16()
|
|
tf.caret_slope_run = tf.get_i16()
|
|
tf.caret_offset = tf.get_fword()
|
|
tf.get_i16() // reserved
|
|
tf.get_i16() // reserved
|
|
tf.get_i16() // reserved
|
|
tf.get_i16() // reserved
|
|
tf.metric_data_format = tf.get_i16()
|
|
tf.num_of_long_hor_metrics = tf.get_u16()
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Kern table
|
|
*
|
|
******************************************************************************/
|
|
struct Kern0Table {
|
|
mut:
|
|
swap bool
|
|
offset u32
|
|
n_pairs int
|
|
kmap map[u32]i16
|
|
old_index int = -1
|
|
}
|
|
|
|
fn (mut kt Kern0Table) reset() {
|
|
kt.old_index = -1
|
|
}
|
|
|
|
fn (mut kt Kern0Table) get(glyph_index int) (int, int) {
|
|
mut x := 0
|
|
|
|
if kt.old_index >= 0 {
|
|
ch := ((u32(kt.old_index & 0xFFFF) << 16) | u32(glyph_index & 0xFFFF))
|
|
// dprintln("kern_get: $ch")
|
|
if ch in kt.kmap {
|
|
x = int(kt.kmap[ch])
|
|
}
|
|
}
|
|
kt.old_index = glyph_index
|
|
if kt.swap {
|
|
return 0, x
|
|
}
|
|
return x, 0
|
|
}
|
|
|
|
fn (mut tf TTF_File) create_kern_table0(vertical bool, cross bool) Kern0Table {
|
|
offset := tf.pos
|
|
n_pairs := tf.get_u16()
|
|
search_range := tf.get_u16()
|
|
entry_selector := tf.get_u16()
|
|
range_shift := tf.get_u16()
|
|
dprintln('n_pairs: $n_pairs search_range: $search_range entry_selector: $entry_selector range_shift: $range_shift')
|
|
|
|
mut kt0 := Kern0Table{
|
|
swap: (vertical && !cross) || (!vertical && cross)
|
|
offset: offset
|
|
n_pairs: n_pairs
|
|
}
|
|
|
|
for _ in 0 .. n_pairs {
|
|
left := tf.get_u16()
|
|
right := tf.get_u16()
|
|
value := tf.get_fword()
|
|
tmp_index := (u32(left) << 16) | u32(right)
|
|
kt0.kmap[tmp_index] = value
|
|
// dprintln("index: ${tmp_index.hex()} val: ${value.hex()}")
|
|
}
|
|
kt0.old_index = -1
|
|
return kt0
|
|
}
|
|
|
|
fn (mut tf TTF_File) read_kern_table() {
|
|
dprintln('*** READ KERN TABLE ***')
|
|
if !('kern' in tf.tables) {
|
|
return
|
|
}
|
|
table_offset := tf.tables['kern'].offset
|
|
tf.pos = table_offset
|
|
|
|
version := tf.get_u16() // must be 0
|
|
assert version == 0 // must be 0
|
|
n_tables := tf.get_u16()
|
|
|
|
dprintln('Kern Table version: $version Kern nTables: $n_tables')
|
|
|
|
for _ in 0 .. n_tables {
|
|
st_version := tf.get_u16() // sub table version
|
|
length := tf.get_u16()
|
|
coverage := tf.get_u16()
|
|
format := coverage >> 8
|
|
cross := coverage & 4
|
|
vertical := (coverage & 0x1) == 0
|
|
dprintln('Kerning subtable version [$st_version] format [$format] length [$length] coverage: [$coverage.hex()]')
|
|
if format == 0 {
|
|
dprintln('kern format: 0')
|
|
kern := tf.create_kern_table0(vertical, cross != 0)
|
|
tf.kern << kern
|
|
} else {
|
|
dprintln('Unknown format -- skip')
|
|
tf.pos = tf.pos + length
|
|
}
|
|
}
|
|
}
|
|
|
|
fn (mut tf TTF_File) reset_kern() {
|
|
for i in 0 .. tf.kern.len {
|
|
tf.kern[i].reset()
|
|
}
|
|
}
|
|
|
|
fn (mut tf TTF_File) next_kern(glyph_index int) (int, int) {
|
|
mut x := 0
|
|
mut y := 0
|
|
for i in 0 .. tf.kern.len {
|
|
tmp_x, tmp_y := tf.kern[i].get(glyph_index)
|
|
x = x + tmp_x
|
|
y = y + tmp_y
|
|
}
|
|
return x, y
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* TTF_File Utility
|
|
*
|
|
******************************************************************************/
|
|
pub fn (tf TTF_File) get_info_string() string {
|
|
txt := '----- Font Info -----
|
|
font_family : $tf.font_family
|
|
font_sub_family : $tf.font_sub_family
|
|
full_name : $tf.full_name
|
|
postscript_name : $tf.postscript_name
|
|
version : $tf.version
|
|
font_revision : $tf.font_revision
|
|
magic_number : $tf.magic_number.hex()
|
|
flags : $tf.flags.hex()
|
|
created unixTS : $tf.created
|
|
modified unixTS : $tf.modified
|
|
box : [x_min:$tf.x_min, y_min:$tf.y_min, x_Max:$tf.x_max, y_Max:$tf.y_max]
|
|
mac_style : $tf.mac_style
|
|
-----------------------
|
|
'
|
|
return txt
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* TTF_File test
|
|
*
|
|
******************************************************************************/
|
|
fn tst() {
|
|
mut tf := TTF_File{}
|
|
|
|
tf.buf = [
|
|
byte(0xFF), /* 8 bit */
|
|
0xF1,
|
|
0xF2, /* 16 bit */
|
|
0x81,
|
|
0x23,
|
|
0x45,
|
|
0x67, /* 32 bit */
|
|
0x12,
|
|
0x34,
|
|
0x12,
|
|
0x34, /* get_2dot14 16 bit */
|
|
0x12,
|
|
0x34,
|
|
0x12,
|
|
0x34 /* get_fixed 32 bit int */,
|
|
]
|
|
assert tf.get_u8().hex() == 'ff'
|
|
assert tf.get_u16().hex() == 'f1f2'
|
|
assert tf.get_u32().hex() == '81234567'
|
|
|
|
dprintln('buf len: $tf.buf.len')
|
|
// dprintln( tf.get_u8().hex() )
|
|
// dprintln( tf.get_u16().hex() )
|
|
// dprintln( tf.get_u32().hex() )
|
|
// dprintln( tf.get_2dot14() )
|
|
// dprintln( tf.get_fixed() )
|
|
}
|