atmos/kernel/

woff2_glyf.rs

//! WOFF2 の `glyf` 変換の復元（純粋なバイト列変換）。
//!
//! 仕様は `spec/woff2_glyf_transform.md`（WOFF2 §5.1）。
//!
//! ## なぜ必要か
//! Font Awesome のアイコンが箱（☐）として描かれていた。
//! カスケード側は単体試験で正常と確定済みで、
//! **フォントの輪郭データが壊れている**ことが原因だった。
//!
//! WOFF2 は `glyf` / `loca` を変換して格納する。変換の有無の判定が
//! 仕様と逆だったうえ、**復元処理そのものが無かった**ため、
//! 変換済みバイト列がそのまま SFNT の `glyf` として書かれていた。
//!
//! ## 不変条件（W-1〜W-4）
//! - **W-1**: 復元した `glyf`/`loca` は元とバイト一致でなくてよいが、
//!   輪郭が正しく読めること
//! - **W-2**: `loca` は復元した `glyf` の実オフセットから作る
//! - **W-3**: 復元できない入力は `None`。壊れたデータを書かない
//! - **W-4**: 純粋なバイト列変換。グローバル状態を持たない

extern crate alloc;

use alloc::vec::Vec;

/// WOFF2 の 255UInt16 を読む。
///
/// 計算量: **O(1)**。
///
/// 仕様（WOFF2 §5.1）:
/// - `253` の次の 2 バイトが値そのもの
/// - `255` の次の 1 バイト + 253
/// - `254` の次の 1 バイト + 253*2
/// - それ以外はその値
pub fn read_255_u16(data: &[u8], pos: &mut usize) -> Option<u16> {
    const ONE_MORE: u8 = 255;
    const WORD_CODE: u8 = 253;
    const LOWEST: u8 = 254;
    let code = *data.get(*pos)?;
    *pos += 1;
    if code == WORD_CODE {
        let hi = *data.get(*pos)? as u16;
        let lo = *data.get(*pos + 1)? as u16;
        *pos += 2;
        Some((hi << 8) | lo)
    } else if code == ONE_MORE {
        let v = *data.get(*pos)? as u16;
        *pos += 1;
        Some(v + 253)
    } else if code == LOWEST {
        let v = *data.get(*pos)? as u16;
        *pos += 1;
        Some(v + 253 * 2)
    } else {
        Some(code as u16)
    }
}

fn read_u16(d: &[u8], p: &mut usize) -> Option<u16> {
    let v = u16::from_be_bytes([*d.get(*p)?, *d.get(*p + 1)?]);
    *p += 2;
    Some(v)
}

fn read_i16(d: &[u8], p: &mut usize) -> Option<i16> {
    read_u16(d, p).map(|v| v as i16)
}

fn read_u32(d: &[u8], p: &mut usize) -> Option<u32> {
    let v = u32::from_be_bytes([
        *d.get(*p)?,
        *d.get(*p + 1)?,
        *d.get(*p + 2)?,
        *d.get(*p + 3)?,
    ]);
    *p += 4;
    Some(v)
}

/// 三角符号化された座標差分を読む（WOFF2 §5.1 の表）。
///
/// 計算量: **O(1)**。
///
/// `flag` の下位 7 ビットが符号化の種類を表す。
/// 戻り値は `(dx, dy)`。
fn decode_triplet(flag: u8, g: &[u8], gp: &mut usize) -> Option<(i32, i32)> {
    let f = flag & 0x7F;
    if f < 84 {
        // 1 バイト: dx は 0、dy が ±
        let b0 = *g.get(*gp)? as i32;
        *gp += 1;
        let dy = ((f % 12) as i32) * 256 + b0;
        let dy = if ((f / 12) % 2) == 0 { -dy } else { dy };
        Some((0, dy))
    } else if f < 120 {
        // 1 バイト: dy は 0、dx が ±
        let b0 = *g.get(*gp)? as i32;
        *gp += 1;
        let f2 = f - 84;
        let dx = ((f2 % 12) as i32) * 256 + b0;
        let dx = if ((f2 / 12) % 2) == 0 { -dx } else { dx };
        Some((dx, 0))
    } else if f < 124 {
        // 1 バイト: dx/dy とも 4 ビットずつ
        let b0 = *g.get(*gp)? as i32;
        *gp += 1;
        let f2 = f - 120;
        let dx = 1 + ((f2 / 2) as i32) * 16 + (b0 >> 4);
        let dy = 1 + ((f2 % 2) as i32) * 16 + (b0 & 0x0F);
        // 符号は f2 の上位ビット群で決まる（仕様の表どおり 2 ビット）
        let dx = if (f2 & 0x02) == 0 { -dx } else { dx };
        let dy = if (f2 & 0x01) == 0 { -dy } else { dy };
        Some((dx, dy))
    } else {
        // 2 バイト以上
        let f2 = f - 124;
        if f2 < 4 {
            let b0 = *g.get(*gp)? as i32;
            let b1 = *g.get(*gp + 1)? as i32;
            *gp += 2;
            let dx = (b0 << 4) | (b1 >> 4);
            let dy = ((b1 & 0x0F) << 8) | (*g.get(*gp)? as i32);
            *gp += 1;
            let dx = if (f2 & 0x02) == 0 { -dx } else { dx };
            let dy = if (f2 & 0x01) == 0 { -dy } else { dy };
            Some((dx, dy))
        } else {
            let b0 = *g.get(*gp)? as i32;
            let b1 = *g.get(*gp + 1)? as i32;
            let b2 = *g.get(*gp + 2)? as i32;
            let b3 = *g.get(*gp + 3)? as i32;
            *gp += 4;
            let dx = (b0 << 8) | b1;
            let dy = (b2 << 8) | b3;
            let f3 = f2 - 4;
            let dx = if (f3 & 0x02) == 0 { -dx } else { dx };
            let dy = if (f3 & 0x01) == 0 { -dy } else { dy };
            Some((dx, dy))
        }
    }
}

/// 変換された `glyf` ストリームから `(glyf, loca, index_format)` を復元する。
///
/// 計算量: **O(総点数)**。
///
/// 復元できない入力（ストリーム長の不一致など）は `None`（W-3）。
pub fn reconstruct_glyf(data: &[u8]) -> Option<(Vec<u8>, Vec<u8>, u16)> {
    let mut p = 0usize;
    let _version = read_u32(data, &mut p)?;
    let num_glyphs = read_u16(data, &mut p)? as usize;
    let index_format = read_u16(data, &mut p)?;

    let n_contour_size = read_u32(data, &mut p)? as usize;
    let n_points_size = read_u32(data, &mut p)? as usize;
    let flag_size = read_u32(data, &mut p)? as usize;
    let glyph_size = read_u32(data, &mut p)? as usize;
    let composite_size = read_u32(data, &mut p)? as usize;
    let bbox_size = read_u32(data, &mut p)? as usize;
    let instruction_size = read_u32(data, &mut p)? as usize;

    let take = |start: usize, len: usize| -> Option<&[u8]> { data.get(start..start + len) };
    let s0 = p;
    let n_contour = take(s0, n_contour_size)?;
    let s1 = s0 + n_contour_size;
    let n_points = take(s1, n_points_size)?;
    let s2 = s1 + n_points_size;
    let flags_s = take(s2, flag_size)?;
    let s3 = s2 + flag_size;
    let glyph_s = take(s3, glyph_size)?;
    let s4 = s3 + glyph_size;
    let composite_s = take(s4, composite_size)?;
    let s5 = s4 + composite_size;
    let bbox_s = take(s5, bbox_size)?;
    let s6 = s5 + bbox_size;
    let instr_s = take(s6, instruction_size)?;

    // bbox ビットマップ（立っているグリフだけ明示的な bbox を持つ）
    let bitmap_len = num_glyphs.div_ceil(8);
    let bbox_bitmap = bbox_s.get(..bitmap_len)?;
    let mut bbox_p = bitmap_len;

    let mut glyf: Vec<u8> = Vec::new();
    let mut offsets: Vec<u32> = Vec::with_capacity(num_glyphs + 1);
    offsets.push(0);

    let mut ncp = 0usize; // nContourStream
    let mut npp = 0usize; // nPointsStream
    let mut fp = 0usize; // flagStream
    let mut gp = 0usize; // glyphStream
    let mut cp = 0usize; // compositeStream
    let mut ip = 0usize; // instructionStream

    for gid in 0..num_glyphs {
        let n_contours = read_i16(n_contour, &mut ncp)?;

        if n_contours == 0 {
            // 空グリフ。データ長 0。
            offsets.push(glyf.len() as u32);
            continue;
        }

        let has_bbox = (bbox_bitmap.get(gid / 8)? >> (7 - (gid % 8))) & 1 == 1;

        if n_contours < 0 {
            // 複合グリフ: compositeStream から丸ごとコピーする。
            // 複合グリフのデータは無変換なので、終端を自前で走査する。
            let start = cp;
            loop {
                let flags = read_u16(composite_s, &mut cp)?;
                let _glyph_index = read_u16(composite_s, &mut cp)?;
                // ARG_1_AND_2_ARE_WORDS
                if flags & 0x0001 != 0 {
                    cp += 4;
                } else {
                    cp += 2;
                }
                // WE_HAVE_A_SCALE / X_AND_Y_SCALE / TWO_BY_TWO
                if flags & 0x0008 != 0 {
                    cp += 2;
                } else if flags & 0x0040 != 0 {
                    cp += 4;
                } else if flags & 0x0080 != 0 {
                    cp += 8;
                }
                if cp > composite_s.len() {
                    return None;
                }
                // MORE_COMPONENTS
                if flags & 0x0020 == 0 {
                    break;
                }
            }
            let body = composite_s.get(start..cp)?;

            // 複合グリフは bbox が必須。
            if !has_bbox {
                return None;
            }
            let bb = bbox_s.get(bbox_p..bbox_p + 8)?;
            bbox_p += 8;

            glyf.extend_from_slice(&n_contours.to_be_bytes());
            glyf.extend_from_slice(bb);
            glyf.extend_from_slice(body);
            while glyf.len() % 4 != 0 {
                glyf.push(0);
            }
            offsets.push(glyf.len() as u32);
            continue;
        }

        // 単純グリフ
        let n_contours = n_contours as usize;
        let mut end_pts: Vec<u16> = Vec::with_capacity(n_contours);
        let mut total_points = 0usize;
        for _ in 0..n_contours {
            let np = read_255_u16(n_points, &mut npp)? as usize;
            total_points += np;
            if total_points == 0 || total_points > u16::MAX as usize + 1 {
                return None;
            }
            end_pts.push((total_points - 1) as u16);
        }

        // 座標の復元
        let mut xs: Vec<i32> = Vec::with_capacity(total_points);
        let mut ys: Vec<i32> = Vec::with_capacity(total_points);
        let mut on_curve: Vec<bool> = Vec::with_capacity(total_points);
        let mut x = 0i32;
        let mut y = 0i32;
        for _ in 0..total_points {
            let flag = *flags_s.get(fp)?;
            fp += 1;
            on_curve.push(flag & 0x80 == 0);
            let (dx, dy) = decode_triplet(flag, glyph_s, &mut gp)?;
            x += dx;
            y += dy;
            xs.push(x);
            ys.push(y);
        }

        // 命令列
        let instr_len = read_255_u16(glyph_s, &mut gp)? as usize;
        let instr = instr_s.get(ip..ip + instr_len)?;
        ip += instr_len;

        // bbox（無ければ座標から計算する）
        let (x_min, y_min, x_max, y_max) = if has_bbox {
            let bb = bbox_s.get(bbox_p..bbox_p + 8)?;
            bbox_p += 8;
            (
                i16::from_be_bytes([bb[0], bb[1]]),
                i16::from_be_bytes([bb[2], bb[3]]),
                i16::from_be_bytes([bb[4], bb[5]]),
                i16::from_be_bytes([bb[6], bb[7]]),
            )
        } else {
            let xmin = xs.iter().copied().min().unwrap_or(0);
            let ymin = ys.iter().copied().min().unwrap_or(0);
            let xmax = xs.iter().copied().max().unwrap_or(0);
            let ymax = ys.iter().copied().max().unwrap_or(0);
            (xmin as i16, ymin as i16, xmax as i16, ymax as i16)
        };

        // 標準の glyf グリフを組み立てる
        glyf.extend_from_slice(&(n_contours as i16).to_be_bytes());
        glyf.extend_from_slice(&x_min.to_be_bytes());
        glyf.extend_from_slice(&y_min.to_be_bytes());
        glyf.extend_from_slice(&x_max.to_be_bytes());
        glyf.extend_from_slice(&y_max.to_be_bytes());
        for e in &end_pts {
            glyf.extend_from_slice(&e.to_be_bytes());
        }
        glyf.extend_from_slice(&(instr_len as u16).to_be_bytes());
        glyf.extend_from_slice(instr);

        // フラグと座標は圧縮せず素直に書く（repeat を使わない）。
        // サイズは増えるが `ttf_parser` は問題なく読める（W-1）。
        for (i, &oc) in on_curve.iter().enumerate() {
            let _ = i;
            glyf.push(if oc { 0x01 } else { 0x00 });
        }
        let mut prev = 0i32;
        for &v in &xs {
            let d = v - prev;
            prev = v;
            glyf.extend_from_slice(&(d as i16).to_be_bytes());
        }
        let mut prev = 0i32;
        for &v in &ys {
            let d = v - prev;
            prev = v;
            glyf.extend_from_slice(&(d as i16).to_be_bytes());
        }

        while glyf.len() % 4 != 0 {
            glyf.push(0);
        }
        offsets.push(glyf.len() as u32);
    }

    // loca を組み立てる（W-2）
    let mut loca: Vec<u8> = Vec::new();
    if index_format == 0 {
        for &o in &offsets {
            if o % 2 != 0 || o / 2 > u16::MAX as u32 {
                // short 形式で表せない → long へ切り替える方が安全だが、
                // ここでは復元不能として扱う（W-3）。
                return None;
            }
            loca.extend_from_slice(&((o / 2) as u16).to_be_bytes());
        }
    } else {
        for &o in &offsets {
            loca.extend_from_slice(&o.to_be_bytes());
        }
    }

    Some((glyf, loca, index_format))
}