open-standards/wai/wai-vector/src/bounds.rs

//! Every cap of §2.6 and every bound of §3.12 that this crate relies on, as constants,
//! with the arithmetic that makes them consistent checked at compile time.

// ---------------------------------------------------------------- WOS1 (§2.1)
pub const WOS1_HEADER: usize = 32;
pub const WOS1_GLYPH: usize = 16;
pub const WOS1_GLYPHS_MAX: u64 = 65_536;
pub const WOS1_POINTS_TOTAL_MAX: u64 = 1 << 22;
pub const WOS1_CONTOURS_TOTAL_MAX: u64 = 1 << 22;
pub const WOS1_NOTES_MAX: u64 = 1 << 20;

/// Points per glyph and per path: the no-wrap cap (§3.7).
pub const POINTS_MAX: u64 = 16_383;

/// The largest `WOS1` the header caps allow: 31,457,312 bytes, below 2^25.
pub const WOS1_LARGEST: u64 = WOS1_HEADER as u64
    + WOS1_GLYPH as u64 * WOS1_GLYPHS_MAX
    + 2 * WOS1_CONTOURS_TOTAL_MAX
    + 5 * WOS1_POINTS_TOTAL_MAX
    + WOS1_NOTES_MAX;
const _: () = assert!(WOS1_LARGEST == 31_457_312 && WOS1_LARGEST < (1 << 25));

// ---------------------------------------------------------------- WVG1 (§2.2, §2.3)
pub const WVG1_HEADER: usize = 80;
pub const PAYLOAD_MAX: u64 = 1 << 26;

pub const SIZES_MAX: u64 = 8;
pub const RATES_MAX: u64 = 4;
pub const SETS_MAX: u64 = 64;
pub const TABLES_MAX: u64 = 32;
pub const PAINTS_MAX: u64 = 4096;
pub const PATHS_MAX: u64 = 4096;
pub const ITEMS_MAX: u64 = 65_536;
pub const KEYS_MAX: u64 = 1 << 22;
pub const GLYPHS_MAX: u64 = 1 << 20;
pub const CLUSTERS_MAX: u64 = 1 << 20;
pub const PATH_CONTOURS_MAX: u64 = 1 << 20;
pub const PATH_POINTS_MAX: u64 = 1 << 22;
pub const STRINGS_MAX: u64 = 1 << 22;
pub const INLINE_MAX: u64 = 1 << 25;
pub const HELD_MAX: u64 = 1 << 26;
/// `inline_len + held_len`.
pub const SETS_BYTES_MAX: u64 = 1 << 26;

/// Record sizes, in the order of the exact-length formula.
pub const REC_SIZE: u64 = 8;
pub const REC_RATE: u64 = 8;
pub const REC_SET: u64 = 40;
pub const REC_TABLE: u64 = 68;
pub const REC_PAINT: u64 = 4;
pub const REC_TRACK: u64 = 8;
pub const REC_KEY: u64 = 12;
pub const REC_PATH: u64 = 16;
pub const REC_PATH_END: u64 = 2;
pub const REC_PATH_POINT: u64 = 5;
pub const REC_TEXT: u64 = 20;
pub const REC_ITEM: u64 = 48;
pub const REC_GLYPH: u64 = 12;
pub const REC_CLUSTER: u64 = 12;

pub const TB_MAX: u32 = 1 << 20;
pub const TICK_LIMIT: u64 = 1 << 31;
pub const SIDE_MIN: u32 = 16;
pub const SIDE_MAX: u32 = 4096;
pub const RATE_TERM_MAX: u32 = 1 << 20;
pub const RATE_MAX_FPS: u64 = 240;
pub const SET_LEN_MIN: u32 = 32;
pub const SET_LEN_MAX: u32 = 1 << 25;
pub const Q16_ONE: u32 = 65_536;
pub const TRACK_KEYS_MAX: u32 = 4096;
pub const RUN_GLYPHS_MAX: u16 = 4096;
pub const RUN_CLUSTERS_MAX: u16 = 8192;
pub const UNIT_SCALE_MAX: u32 = 1 << 24;
pub const GLYPH_POS_LIMIT: i32 = 1 << 23;
pub const TRANSLATION_MAX: i32 = 1 << 22;
pub const MATRIX_MAX: i32 = 1 << 20;
pub const OPACITY_MAX: i32 = 255;
pub const LANG_MAX: u8 = 63;
pub const STR_MAX: u32 = 4096;
pub const GROUP_DEPTH_MAX: u32 = 4;
pub const NONE: u16 = 0xFFFF;
pub const DECORATIVE: u8 = 13;

// ---------------------------------------------------------------- arithmetic (§3)
/// Every device coordinate after the interval check (§3.4(a)).
pub const DEVICE_MIN: i64 = -(1 << 22);
pub const DEVICE_MAX: i64 = (1 << 22) - 1;
/// The per-frame cost ceiling (§3.4(b)).
pub const COST_CEILING: u64 = (1 << 32) - 1;
/// A full pixel's value `v`: 512 · 256.
pub const FULL: i32 = 1 << 17;
/// The row density bound `D_r ≤ 256·p ≤ 2^22 − 256` (§3.7).
pub const DENSITY_MAX: i64 = 256 * POINTS_MAX as i64;

const _: () = assert!(DENSITY_MAX == (1 << 22) - 256);
const _: () = assert!(512 * DENSITY_MAX == (1 << 31) - (1 << 17));
// The run sum S of 4,096 terms each at most 2^17 fits u32 and i32.
const _: () = assert!((RUN_GLYPHS_MAX as u64) << 17 <= 1 << 29);
// div255's largest intermediate 257·(65025 + 128) is below 2^24.
pub const DIV255_DOMAIN_MAX: u32 = 65_025;
const _: () = assert!(257 * (DIV255_DOMAIN_MAX + 128) < 1 << 24);
// The exact length at the caps, the inline and held bytes aside, fits u64 trivially;
// the cap on it is PAYLOAD_MAX.
const _: () = assert!(REC_ITEM * ITEMS_MAX + REC_KEY * KEYS_MAX < 1 << 40);
// A fill's cost p·(2^10 + bw + bh) + bw·bh is below 2^28 (§3.4(b)).
const _: () = assert!(POINTS_MAX * (1024 + 2 * SIDE_MAX as u64) + (SIDE_MAX as u64) * (SIDE_MAX as u64) < 1 << 28);