use crate::pdf::{Dict, Font, Object, Page};
use std::collections::{BTreeMap, BTreeSet};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Variables {
pub compress_level: u32,
pub objcompress_level: u32,
pub decimal_digits: u32,
pub gen_tounicode: bool,
pub major_version: u32,
pub minor_version: u32,
}
impl Default for Variables {
fn default() -> Self {
Variables {
compress_level: 9,
objcompress_level: 2,
decimal_digits: 3,
gen_tounicode: false,
major_version: 1,
minor_version: 7,
}
}
}
const OBJSTM_ALWAYS: u32 = 1;
const INFO_THRESHOLD: u32 = 3;
const OS_MAX_OBJS: usize = 100;
const PAGES_KIDS_MAX: usize = 10;
pub fn deflate_at(level: u32, data: &[u8]) -> Vec<u8> {
use libz_sys::{compress2, compressBound, uLong, Z_OK};
let mut size: uLong = unsafe { compressBound(data.len() as uLong) };
let mut out = vec![0u8; size as usize];
let status = unsafe {
compress2(
out.as_mut_ptr(),
&mut size,
data.as_ptr(),
data.len() as uLong,
level.min(9) as i32,
)
};
assert_eq!(status, Z_OK, "zlib could not compress into its own bound");
out.truncate(size as usize);
out
}
fn md5(parts: &[&[u8]]) -> [u8; 16] {
use md5::Digest as _;
let mut d = md5::Md5::new();
for part in parts {
d.update(part);
}
d.finalize().into()
}
pub fn subset_tag(glyphs: &BTreeSet<String>, font_name: &str) -> String {
let mut names = Vec::new();
for glyph in glyphs {
names.extend_from_slice(glyph.as_bytes());
names.push(b' ');
}
let round = 0i32.to_le_bytes();
let digest = md5(&[&names, font_name.as_bytes(), &round]);
let mut a = [0i32; 6];
a[0] = digest[..13].iter().map(|&b| i32::from(b)).sum();
for i in 1..6 {
a[i] = a[i - 1] - i32::from(digest[i - 1]) + i32::from(digest[(i + 12) % 16]);
}
a.iter().map(|&x| (b'A' + (x % 26) as u8) as char).collect()
}
pub fn trailer_id(epoch: i64, cwd: &str, file_name: &str) -> [u8; 16] {
let (days, secs) = (epoch.div_euclid(86_400), epoch.rem_euclid(86_400));
let (y, mo, d) = crate::pdf::civil(days);
let time = format!(
"{y:04}{mo:02}{d:02}T{:02}{:02}{:02}Z",
secs / 3600,
(secs / 60) % 60,
secs % 60
);
md5(&[time.as_bytes(), cwd.as_bytes(), b"/", file_name.as_bytes()])
}
#[derive(Clone, Copy, Debug)]
enum Place {
Fresh,
File(usize),
Packed { stream: u32, index: usize },
}
struct ObjStm {
number: u32,
body: Vec<u8>,
entries: Vec<(u32, usize)>,
}
pub struct Writer {
pub vars: Variables,
out: Vec<u8>,
places: Vec<Place>,
objstm: Option<ObjStm>,
pub trailer_id: Option<String>,
objstms: BTreeSet<u32>,
}
fn length_and_close(len: usize) -> String {
format!("{:<14}", format!("{len} >>"))
}
impl Writer {
pub fn new(vars: Variables) -> Writer {
let mut out = format!("%PDF-{}.{}\n", vars.major_version, vars.minor_version).into_bytes();
out.extend([
b'%', 0xcc, 0xd5, 0xc1, 0xd4, 0xc5, 0xd8, 0xd0, 0xc4, 0xc6, b'\n',
]);
Writer {
vars,
out,
places: vec![Place::Fresh],
objstm: None,
trailer_id: None,
objstms: BTreeSet::new(),
}
}
pub fn count(&self) -> u32 {
(self.places.len() - 1) as u32
}
pub fn written(&self) -> u32 {
self.places
.iter()
.skip(1)
.filter(|p| !matches!(p, Place::Fresh))
.count() as u32
}
pub fn is_objstm(&self, n: u32) -> bool {
self.objstms.contains(&n)
}
pub fn create(&mut self) -> u32 {
self.places.push(Place::Fresh);
(self.places.len() - 1) as u32
}
pub fn object(&mut self, number: u32, threshold: u32, body: &[u8]) {
if self.vars.objcompress_level >= threshold {
self.pack(number, body);
} else {
self.places[number as usize] = Place::File(self.out.len());
self.out.extend(format!("{number} 0 obj\n").as_bytes());
self.out.extend(body);
self.out.extend(b"\nendobj\n");
}
}
fn pack(&mut self, number: u32, body: &[u8]) {
if self.objstm.is_none() {
let stream = self.create();
self.objstms.insert(stream);
self.objstm = Some(ObjStm {
number: stream,
body: Vec::new(),
entries: Vec::new(),
});
}
let Some(os) = self.objstm.as_mut() else {
return;
};
let index = os.entries.len();
os.entries.push((number, os.body.len()));
os.body.extend(body);
let stream = os.number;
self.places[number as usize] = Place::Packed { stream, index };
if index + 1 == OS_MAX_OBJS {
self.flush_objstm();
} else if let Some(os) = self.objstm.as_mut() {
os.body.push(b'\n');
}
}
pub fn stream(&mut self, number: u32, keys: &str, data: &[u8], deflate: bool) {
let packed;
let (filter, data) = match deflate && self.vars.compress_level > 0 {
true => {
packed = deflate_at(self.vars.compress_level, data);
(" /Filter /FlateDecode", packed.as_slice())
}
false => ("", data),
};
self.places[number as usize] = Place::File(self.out.len());
let space = match keys.is_empty() {
true => "",
false => " ",
};
self.out.extend(
format!(
"{number} 0 obj\n<<{space}{keys}{filter} /Length {}\nstream\n",
length_and_close(data.len())
)
.as_bytes(),
);
self.out.extend(data);
self.out.extend(b"\nendstream\nendobj\n");
}
fn flush_objstm(&mut self) {
let Some(os) = self.objstm.take() else {
return;
};
let mut head = String::new();
for (i, (number, at)) in os.entries.iter().enumerate() {
head.push_str(&format!("{number} {at}"));
let end = i % 10 == 9 || i + 1 == os.entries.len();
head.push(if end { '\n' } else { ' ' });
}
let first = head.len();
let mut data = head.into_bytes();
data.extend(&os.body);
let keys = format!("/Type /ObjStm /N {} /First {first}", os.entries.len());
self.stream(os.number, &keys, &data, true);
}
pub fn finish(mut self, root: u32, info: Option<u32>, trailer: &str, id: [u8; 16]) -> Vec<u8> {
self.flush_objstm();
let xref = self.create();
let xref_offset = self.out.len();
self.places[xref as usize] = Place::File(xref_offset);
let width = match xref_offset {
o if o / 256 > 16_777_215 => 5,
o if o > 16_777_215 => 4,
o if o > 65_535 => 3,
_ => 2,
};
let mut next_free = vec![0usize; self.places.len()];
let mut last = 0usize;
for (k, place) in self.places.iter().enumerate().skip(1) {
if matches!(place, Place::Fresh) {
next_free[last] = k;
last = k;
}
}
next_free[last] = 0;
let mut rows = Vec::with_capacity(self.places.len() * (2 + width));
let put = |rows: &mut Vec<u8>, value: usize| {
for shift in (0..width).rev() {
rows.push((value >> (shift * 8)) as u8);
}
};
for (k, place) in self.places.iter().enumerate() {
match (k, place) {
(0, _) | (_, Place::Fresh) => {
rows.push(0);
put(&mut rows, next_free[k]);
rows.push(255);
}
(_, Place::File(at)) => {
rows.push(1);
put(&mut rows, *at);
rows.push(0);
}
(_, Place::Packed { stream, index }) => {
rows.push(2);
put(&mut rows, *stream as usize);
rows.push(*index as u8);
}
}
}
let size = self.places.len();
let hex: String = id.iter().map(|b| format!("{b:02X}")).collect();
let mut keys = format!(
"/Type /XRef /Index [ 0 {size} ] /Size {size} /W [ 1 {width} 1 ] /Root {root} 0 R"
);
if let Some(info) = info {
keys.push_str(&format!(" /Info {info} 0 R"));
}
if !trailer.is_empty() {
keys.push(' ');
keys.push_str(trailer);
}
match &self.trailer_id {
Some(id) => keys.push_str(&format!(" /ID {id}")),
None => keys.push_str(&format!(" /ID [ <{hex}> <{hex}> ]")),
}
self.stream(xref, &keys, &rows, true);
self.out
.extend(format!("startxref\n{xref_offset}\n%%EOF\n").as_bytes());
self.out
}
pub fn add(&mut self, object: Object) -> Object {
let number = self.create();
match object {
Object::Stream { dict, data } => {
let own_filter = dict.get("Filter").is_some();
let keys: Dict = dict
.iter()
.filter(|(k, _)| k.as_str() != "Length")
.map(|(k, v)| (k.clone(), v.clone()))
.collect();
self.stream(number, &spelled_keys(&keys), &data, !own_filter);
}
other => {
let mut body = Vec::new();
other.write_into(&mut body);
self.object(number, OBJSTM_ALWAYS, &body);
}
}
Object::Reference(number)
}
}
fn spelled_keys(dict: &Dict) -> String {
let mut body = Vec::new();
Object::Dict(dict.clone()).write_into(&mut body);
let text = String::from_utf8_lossy(&body).into_owned();
text.trim_start_matches("<<")
.trim_end_matches(">>")
.trim()
.to_string()
}
impl crate::pdf::Sink for Writer {
fn add(&mut self, object: Object) -> Object {
Writer::add(self, object)
}
}
fn divide_scaled(s: i64, m: i64, dd: u32) -> i64 {
let sign = if (s < 0) != (m < 0) { -1 } else { 1 };
let (s, m) = (s.abs(), m.abs());
if m == 0 {
return 0;
}
let (mut q, mut r) = (s / m, s % m);
for _ in 0..dd {
q = 10 * q + (10 * r) / m;
r = (10 * r) % m;
}
if 2 * r >= m {
q += 1;
}
sign * q
}
struct UsedFont<'a> {
font: &'a Font,
number: u32,
codes: BTreeSet<u8>,
}
struct PagesNode {
number: u32,
kids: Vec<u32>,
pages: usize,
}
thread_local! {
static PREPARED: std::cell::RefCell<Option<crate::backend::Prepared>> =
const { std::cell::RefCell::new(None) };
}
pub fn prepare(prepared: crate::backend::Prepared) {
PREPARED.with(|p| *p.borrow_mut() = Some(prepared));
}
pub fn take_prepared() -> Option<crate::backend::Prepared> {
PREPARED.with(|p| p.borrow_mut().take())
}
pub fn write(pages: &[Page], contents: Vec<String>, prepared: crate::backend::Prepared) -> Vec<u8> {
let mut prepared = prepared;
let vars = prepared.vars;
let mut w = prepared.writer.take().unwrap_or_else(|| Writer::new(vars));
w.vars = vars;
let pictures = crate::pdf::picture_classes(pages);
let streams: Vec<Vec<u8>> = {
use rayon::prelude::*;
let level = vars.compress_level;
let squeeze = |c: String| match level {
0 => c.into_bytes(),
_ => deflate_at(level, c.as_bytes()),
};
match pages.len() >= crate::pdf::PARALLEL_PAGES {
true => contents.into_par_iter().map(squeeze).collect(),
false => contents.into_iter().map(squeeze).collect(),
}
};
let mut fonts: Vec<UsedFont> = Vec::new();
let mut last_page = 0u32;
let mut images: Vec<Option<u32>> = Vec::new();
let mut tree: Vec<PagesNode> = Vec::new();
for ((page, classes), stream) in pages.iter().zip(&pictures).zip(streams) {
for &class in classes {
if class >= images.len() {
images.resize(class + 1, None);
}
if images[class].is_none() {
images[class] = Some(w.create());
}
}
let resources = w.create();
let page_number = match prepared.pages.get(&(tree_pages(&tree) as i64 + 1)) {
Some(&k) => k,
None => w.create(),
};
let content = w.create();
let content_at = w.out.len();
w.places[content as usize] = Place::File(content_at);
let filter = match vars.compress_level {
0 => "",
_ => " /Filter /FlateDecode",
};
w.out.extend(
format!(
"{content} 0 obj\n<<{filter} /Length {}\nstream\n",
length_and_close(stream.len())
)
.as_bytes(),
);
w.out.extend(&stream);
w.out.extend(b"\nendstream\nendobj\n");
let mut font_refs = Dict::new();
for (name, font) in &page.fonts {
let font: &Font = font;
let codes = page.used.get(name).cloned().unwrap_or_default();
let at = match fonts.iter().position(|u| crate::pdf::same(u.font, font)) {
Some(at) => at,
None => {
let number = w.create();
fonts.push(UsedFont {
font,
number,
codes: BTreeSet::new(),
});
fonts.len() - 1
}
};
fonts[at].codes.extend(codes);
font_refs.insert(name.clone(), Object::Reference(fonts[at].number));
}
if tree.last().is_none_or(|n| n.kids.len() == PAGES_KIDS_MAX) {
let number = w.create();
tree.push(PagesNode {
number,
kids: Vec::new(),
pages: 0,
});
}
let parent = {
let node = tree.last_mut().expect("a node was just made");
node.kids.push(page_number);
node.pages += 1;
node.number
};
let mut body = format!(
"<< /Type /Page /Contents {content} 0 R /Resources {resources} 0 R \
/MediaBox [ 0 0 {} {} ]",
bp_text(page.width, vars.decimal_digits),
bp_text(page.height, vars.decimal_digits)
);
for extra in [&prepared.page_attr, &prepared.lua.page_attributes] {
if !extra.is_empty() {
body.push(' ');
body.push_str(extra);
}
}
body.push_str(&format!(" /Parent {parent} 0 R >>"));
w.object(page_number, OBJSTM_ALWAYS, body.as_bytes());
let mut procset = BTreeSet::new();
let mut xobjects = Dict::new();
for ((name, image), &class) in page.images.iter().zip(classes) {
let Some(number) = images[class] else {
continue;
};
if matches!(w.places[number as usize], Place::Fresh) {
crate::pdf::write_image_as(&mut w, number, image);
}
procset.extend(image_procset(image));
xobjects.insert(name.clone(), Object::Reference(number));
}
let mut res = crate::pdf::extra_resources(page);
if !font_refs.is_empty() {
res.insert("Font".to_string(), Object::Dict(font_refs.clone()));
}
if !xobjects.is_empty() {
res.insert("XObject".to_string(), Object::Dict(xobjects));
}
if vars.major_version == 1 {
let mut set = vec![Object::name("PDF")];
if !font_refs.is_empty() {
set.push(Object::name("Text"));
}
for name in ["ImageB", "ImageC", "ImageI"] {
if procset.contains(name) {
set.push(Object::name(name));
}
}
res.insert("ProcSet".to_string(), Object::Array(set));
}
let mut body = Vec::new();
Object::Dict(res).write_into(&mut body);
let first: Vec<&str> = [&prepared.page_resources, &prepared.lua.page_resources]
.into_iter()
.filter(|s| !s.is_empty())
.map(String::as_str)
.collect();
if !first.is_empty() {
let rest = String::from_utf8_lossy(&body[2..]).into_owned();
body = format!("<< {}{rest}", first.join(" ")).into_bytes();
}
w.object(resources, OBJSTM_ALWAYS, &body);
last_page = page_number;
}
let mut dests: Vec<u32> = prepared.dests.values().copied().collect();
dests.sort_unstable();
for &d in dests.iter().rev() {
let body = format!("[ {last_page} 0 R /Fit ]");
w.object(d, OBJSTM_ALWAYS, body.as_bytes());
}
write_fonts(&mut w, &fonts);
let pages_attr = [&prepared.pages_attr, &prepared.lua.pages_attributes]
.into_iter()
.filter(|s| !s.is_empty())
.map(String::as_str)
.collect::<Vec<_>>()
.join(" ");
let root_pages = write_page_tree(&mut w, tree, &pages_attr);
let outlines = write_outlines(&mut w, &prepared);
let names = write_name_tree(&mut w, &prepared);
let catalog = w.create();
let mut body = String::from("<< /Type /Catalog");
if let Some(pages) = root_pages {
body.push_str(&format!(" /Pages {pages} 0 R"));
if let Some(o) = outlines {
body.push_str(&format!(" /Outlines {o} 0 R"));
}
if let Some(n) = names {
body.push_str(&format!(" /Names {n} 0 R"));
}
if !prepared.catalog.is_empty() {
body.push(' ');
body.push_str(&prepared.catalog);
}
}
if let Some(a) = prepared.open_action {
body.push_str(&format!(" /OpenAction {a} 0 R"));
}
if !prepared.lua.catalog.is_empty() {
body.push(' ');
body.push_str(&prepared.lua.catalog);
}
body.push_str(" >>");
w.object(catalog, OBJSTM_ALWAYS, body.as_bytes());
let info = w.create();
let date = crate::pdf::pdf_date(crate::pdf::stamp());
let given = |key: &str| prepared.info.contains(key) || prepared.lua.info.contains(key);
let mut body = String::from("<<");
for extra in [&prepared.info, &prepared.lua.info] {
if !extra.is_empty() {
body.push(' ');
body.push_str(extra);
}
}
let v = env!("CARGO_PKG_VERSION");
if !given("/Producer") {
body.push_str(&format!(" /Producer (texrs-{v})"));
}
if !given("/Creator") {
body.push_str(" /Creator (TeX)");
}
if !given("/CreationDate") {
body.push_str(&format!(" /CreationDate ({date})"));
}
if !given("/ModDate") {
body.push_str(&format!(" /ModDate ({date})"));
}
if !given("/Trapped") {
body.push_str(" /Trapped /False");
}
body.push_str(&format!(
" /PTEX.FullBanner (This is texrs, Version {v}) >>"
));
w.object(info, INFO_THRESHOLD, body.as_bytes());
let cwd = std::env::current_dir()
.map(|d| d.display().to_string())
.unwrap_or_default();
let id = trailer_id(
crate::pdf::stamp(),
&cwd,
&format!("{}.pdf", crate::lua::jobname()),
);
let trailer = [&prepared.trailer, &prepared.lua.trailer]
.into_iter()
.filter(|s| !s.is_empty())
.map(String::as_str)
.collect::<Vec<_>>()
.join(" ");
w.trailer_id = (!prepared.lua.trailer_id.is_empty()).then(|| prepared.lua.trailer_id.clone());
w.finish(catalog, Some(info), &trailer, id)
}
fn tree_pages(tree: &[PagesNode]) -> usize {
tree.iter().map(|n| n.pages).sum()
}
fn write_outlines(w: &mut Writer, p: &crate::backend::Prepared) -> Option<u32> {
if p.first_outline == 0 {
return None;
}
let mut entries = p.outlines.clone();
let find = |entries: &[crate::backend::OutlineEntry], k: u32| {
entries.iter().position(|e| e.number == k)
};
fn open(entries: &mut Vec<crate::backend::OutlineEntry>, at: usize) -> i64 {
let mut k = 0;
let mut l = entries[at].first;
let me = entries[at].number;
while l != 0 {
let Some(i) = entries.iter().position(|e| e.number == l) else {
break;
};
k += 1;
let c = open(entries, i);
if entries[i].count > 0 {
k += c;
}
entries[i].parent = me;
let r = entries[i].next;
if r == 0 {
entries[at].last = l;
}
l = r;
}
entries[at].count = match entries[at].count > 0 {
true => k,
false => -k,
};
k
}
let outlines = w.create();
let mut k = 0;
let mut l = p.first_outline;
while let Some(i) = find(&entries, l) {
k += 1;
let a = open(&mut entries, i);
if entries[i].count > 0 {
k += a;
}
entries[i].parent = outlines;
l = entries[i].next;
if l == 0 {
break;
}
}
let body = format!(
"<< /Type /Outlines /First {} 0 R /Last {} 0 R /Count {k} >>",
p.first_outline, p.last_outline
);
w.object(outlines, OBJSTM_ALWAYS, body.as_bytes());
for e in &entries {
let mut body = format!("<< /Title {} 0 R /A {} 0 R", e.title, e.action);
for (key, v) in [
("Parent", e.parent),
("Prev", e.prev),
("Next", e.next),
("First", e.first),
("Last", e.last),
] {
if v != 0 {
body.push_str(&format!(" /{key} {v} 0 R"));
}
}
if e.count != 0 {
body.push_str(&format!(" /Count {}", e.count));
}
if let Some(attr) = &e.attr {
body.push_str(&format!("\n{attr}\n"));
}
body.push_str(" >>");
w.object(e.number, OBJSTM_ALWAYS, body.as_bytes());
}
Some(outlines)
}
fn dest_order(a: &str, b: &str) -> std::cmp::Ordering {
let bytes = |s: &str| -> Vec<u8> {
let raw = s.as_bytes();
let hex = raw.len() >= 2
&& raw[0] == b'<'
&& raw[raw.len() - 1] == b'>'
&& raw.len().is_multiple_of(2)
&& raw[1..raw.len() - 1].iter().all(u8::is_ascii_hexdigit);
match hex {
true => raw[1..raw.len() - 1]
.chunks(2)
.map(|p| u8::from_str_radix(std::str::from_utf8(p).unwrap_or("0"), 16).unwrap_or(0))
.collect(),
false => raw.to_vec(),
}
};
let empty = |s: &str| s.is_empty() || s == "<>";
match (empty(a), empty(b)) {
(true, false) => return std::cmp::Ordering::Less,
(false, true) => return std::cmp::Ordering::Greater,
_ => {}
}
bytes(a).cmp(&bytes(b))
}
fn write_name_tree(w: &mut Writer, p: &crate::backend::Prepared) -> Option<u32> {
const KIDS_MAX: usize = 32;
let mut names = p.dest_names.clone();
names.sort_by(|a, b| dest_order(&a.0, &b.0));
let mut dests = 0;
if !names.is_empty() {
let mut level: Vec<(u32, String, String)> = Vec::new();
for chunk in names.chunks(KIDS_MAX) {
let l = w.create();
let pairs: String = chunk
.iter()
.map(|(n, k)| format!(" {} {k} 0 R", crate::backend::pdf_string(n)))
.collect();
let (first, last) = (chunk[0].0.clone(), chunk[chunk.len() - 1].0.clone());
let body = format!(
"<< /Names [{pairs} ] /Limits [ {} {} ] >>",
crate::backend::pdf_string(&first),
crate::backend::pdf_string(&last)
);
w.object(l, OBJSTM_ALWAYS, body.as_bytes());
level.push((l, first, last));
}
while level.len() > 1 {
let mut above = Vec::new();
for chunk in level.chunks(KIDS_MAX) {
let l = w.create();
let kids: String = chunk.iter().map(|(k, ..)| format!(" {k} 0 R")).collect();
let (first, last) = (chunk[0].1.clone(), chunk[chunk.len() - 1].2.clone());
let body = format!(
"<< /Kids [{kids} ] /Limits [ {} {} ] >>",
crate::backend::pdf_string(&first),
crate::backend::pdf_string(&last)
);
w.object(l, OBJSTM_ALWAYS, body.as_bytes());
above.push((l, first, last));
}
level = above;
}
dests = level[0].0;
}
if dests == 0 && p.names.is_empty() && p.lua.names.is_empty() {
return None;
}
let m = w.create();
let mut body = String::from("<<");
if dests != 0 {
body.push_str(&format!(" /Dests {dests} 0 R"));
}
for extra in [&p.names, &p.lua.names] {
if !extra.is_empty() {
body.push(' ');
body.push_str(extra);
}
}
body.push_str(" >>");
w.object(m, OBJSTM_ALWAYS, body.as_bytes());
Some(m)
}
fn bp_text(points: f64, decimal_digits: u32) -> String {
let scale = 10f64.powi(decimal_digits as i32);
let mut out = Vec::new();
crate::pdfpage::print_pdffloat(
&mut out,
crate::pdfpage::PdfFloat::new((points * scale).round() as i64, decimal_digits),
);
String::from_utf8_lossy(&out).into_owned()
}
fn image_procset(image: &crate::image::Image) -> Vec<&'static str> {
use crate::image::Colours;
match image.colours {
Colours::Gray => vec!["ImageB"],
Colours::Indexed => vec!["ImageC", "ImageI"],
_ => vec!["ImageC"],
}
}
fn write_page_tree(w: &mut Writer, leaves: Vec<PagesNode>, attr: &str) -> Option<u32> {
let mut level = leaves;
loop {
match level.len() {
0 => return None,
1 => {
let root = &level[0];
write_pages_node(w, root, None, attr);
return Some(root.number);
}
_ => {
let mut parents: Vec<PagesNode> = vec![PagesNode {
number: w.create(),
kids: Vec::new(),
pages: 0,
}];
for node in &level {
if parents
.last()
.is_some_and(|q| q.kids.len() == PAGES_KIDS_MAX)
{
let number = w.create();
parents.push(PagesNode {
number,
kids: Vec::new(),
pages: 0,
});
}
let q = parents.last_mut().expect("a parent exists");
q.kids.push(node.number);
q.pages += node.pages;
let parent = q.number;
write_pages_node(w, node, Some(parent), attr);
}
level = parents;
}
}
}
}
fn write_pages_node(w: &mut Writer, node: &PagesNode, parent: Option<u32>, attr: &str) {
let kids: String = node.kids.iter().map(|k| format!(" {k} 0 R")).collect();
let head = match (parent, attr.is_empty()) {
(None, true) => "/Type /Pages ".to_string(),
(None, false) => format!("/Type /Pages {attr} "),
(Some(p), _) => format!("/Type /Pages /Parent {p} 0 R "),
};
let body = format!("<< {head}/Count {} /Kids [{kids} ] >>", node.pages);
w.object(node.number, OBJSTM_ALWAYS, body.as_bytes());
}
fn write_fonts(w: &mut Writer, fonts: &[UsedFont]) {
struct Tex<'a> {
tex: &'a crate::pdf::TexFont,
number: u32,
first: u8,
last: u8,
widths: u32,
encoding: Option<(u32, Vec<Object>)>,
glyphs: BTreeSet<String>,
}
let mut tex: Vec<Tex> = Vec::new();
for used in fonts.iter().rev() {
let Font::Tex(t) = used.font else {
crate::pdf::write_font_as(w, used.number, used.font, &used.codes);
continue;
};
let codes: Vec<u8> = used
.codes
.iter()
.copied()
.filter(|&c| t.exists(c))
.collect();
let (Some(&first), Some(&last)) = (codes.first(), codes.last()) else {
continue;
};
let mut differences = Vec::new();
let mut expected = None;
let mut glyphs = BTreeSet::new();
for &code in &codes {
let Some(name) = t.glyph_for(code) else {
continue;
};
glyphs.insert(name.clone());
if t.program.encoded(code).map(|g| g.name.as_str()) == Some(name.as_str()) {
continue;
}
if expected != Some(code) {
differences.push(Object::Integer(i64::from(code)));
}
differences.push(Object::name(&name));
expected = Some(code.wrapping_add(1));
}
let encoding = (!differences.is_empty()).then(|| (w.create(), differences));
let widths = w.create();
let mut body = b"[".to_vec();
let mut j = first;
for (n, &code) in codes.iter().enumerate() {
if n > 0 {
body.push(b' ');
}
while j.wrapping_add(1) < code && j < code {
body.extend(b"0 ");
j += 1;
}
j = code;
crate::pdfpage::print_pdffloat(
&mut body,
crate::pdfpage::PdfFloat::new(t.char_width_e1(code), 1),
);
}
body.extend(b" ]");
w.object(widths, OBJSTM_ALWAYS, &body);
tex.push(Tex {
tex: t,
number: used.number,
first,
last,
widths,
encoding,
glyphs,
});
}
let mut by_file: BTreeMap<&str, (BTreeSet<String>, Vec<usize>)> = BTreeMap::new();
for (i, t) in tex.iter().enumerate() {
let entry = by_file.entry(t.tex.program_file.as_str()).or_default();
entry.0.extend(t.glyphs.iter().cloned());
entry.1.push(i);
}
let mut descriptors: BTreeMap<&str, (u32, String)> = BTreeMap::new();
for (file, (glyphs, users)) in &by_file {
let t = tex[users[0]].tex;
let number = w.create();
let tag = subset_tag(glyphs, &t.program.font_name);
let name = format!("{tag}+{}", t.program.font_name);
let cut = t.program.subset(glyphs, &tag);
let program = cut.as_ref().unwrap_or(&t.program);
let (bytes, clear, binary, trailer) = program.embeddable();
let file_number = w.create();
w.stream(
file_number,
&format!("/Length1 {clear} /Length2 {binary} /Length3 {trailer}"),
&bytes,
true,
);
let bbox = program.font_bbox;
let charset: String = glyphs.iter().map(|g| format!(" /{g}")).collect();
let body = format!(
"<< /Type /FontDescriptor /FontName /{name} /Flags 4 /FontBBox [ {} {} {} {} ] \
/Ascent {} /CapHeight {} /Descent {} /ItalicAngle {} /StemV {} /XHeight {} \
/CharSet({charset}) /FontFile {file_number} 0 R >>",
bbox[0] as i64,
bbox[1] as i64,
bbox[2] as i64,
bbox[3] as i64,
t.ascent,
t.cap_height,
t.descent,
program.italic_angle as i64,
program.stem_v.map(|v| v as i64).unwrap_or(t.stem_v),
t.x_height,
);
w.object(number, OBJSTM_ALWAYS, body.as_bytes());
descriptors.insert(file, (number, name));
}
for t in &tex {
if let Some((number, differences)) = &t.encoding {
let mut body = Vec::new();
Object::dict([
("Type", Object::name("Encoding")),
("Differences", Object::Array(differences.clone())),
])
.write_into(&mut body);
w.object(*number, OBJSTM_ALWAYS, &body);
}
}
let mut order: Vec<&Tex> = tex.iter().collect();
order.sort_by(|a, b| a.tex.tfm_name.cmp(&b.tex.tfm_name));
for t in order {
let (fd, name) = &descriptors[t.tex.program_file.as_str()];
let to_unicode = match w.vars.gen_tounicode {
true => {
let meanings: Vec<(u8, String)> = (t.first..=t.last)
.filter_map(|c| Some((c, crate::agl::unicode(&t.tex.glyph_for(c)?)?)))
.collect();
let number = w.create();
w.stream(
number,
"",
crate::agl::to_unicode(&t.tex.tfm_name, &meanings).as_bytes(),
true,
);
Some(number)
}
false => None,
};
let mut body = format!(
"<< /Type /Font /Subtype /Type1 /BaseFont /{name} /FontDescriptor {fd} 0 R \
/FirstChar {} /LastChar {} /Widths {} 0 R",
t.first, t.last, t.widths
);
if let Some((number, _)) = t.encoding {
body.push_str(&format!(" /Encoding {number} 0 R"));
}
if let Some(number) = to_unicode {
body.push_str(&format!(" /ToUnicode {number} 0 R"));
}
body.push_str(" >>");
w.object(t.number, OBJSTM_ALWAYS, body.as_bytes());
}
}
pub fn tex_metrics(tfm: &crate::tfm::Tfm) -> (i64, Vec<Option<i64>>, [i64; 5]) {
let size = (tfm.design_size * 65536.0).round() as i64;
let widths: Vec<Option<i64>> = (0..=255u8)
.map(|c| tfm.char(c).map(|m| crate::tfm::store_scaled(m.width, size)))
.collect();
let height = |c: u8| {
tfm.char(c)
.map(|m| crate::tfm::store_scaled(m.height, size))
.unwrap_or(0)
};
let depth = |c: u8| {
tfm.char(c)
.map(|m| crate::tfm::store_scaled(m.depth, size))
.unwrap_or(0)
};
let ascent = divide_scaled(height(b'h'), size, 3);
let cap_height = divide_scaled(height(b'H'), size, 3);
let descent = -divide_scaled(depth(b'y'), size, 3);
let descent = descent.min(0);
let stem_v = divide_scaled(widths[usize::from(b'.')].unwrap_or(0) / 3, size, 3);
let x_height = divide_scaled(tfm.param_at(5, size), size, 3);
(
size,
widths,
[ascent, cap_height, descent, stem_v, x_height],
)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_subset_tag_is_luatex_s() {
let glyphs: BTreeSet<String> = ["H", "d", "e", "l", "o", "one", "period", "r", "w"]
.iter()
.map(|s| s.to_string())
.collect();
assert_eq!(subset_tag(&glyphs, "CMR10"), "KJJYRX");
}
#[test]
fn the_trailer_id_is_print_id_s() {
let hex = |id: [u8; 16]| id.iter().map(|b| format!("{b:02x}")).collect::<String>();
assert_eq!(
hex(trailer_id(0, "/home/user/doc", "case.pdf")),
"2115d72ebf4ae892795eb96688973995"
);
assert_eq!(
hex(trailer_id(1_000_000_000, "/srv/build", "report.pdf")),
"477e4375682cdbae010aadd9b8ef9007"
);
}
#[test]
fn a_stream_deflates_to_luatex_s_length() {
let content = "BT\n/F1 9.96264 Tf\n1 0 0 1 91.925 710.037 Tm [(Hello)-333(w)27(orld.)]TJ\n\
1 0 0 1 303.509 55.29 Tm [(1)]TJ\nET\n";
assert_eq!(deflate_at(9, content.as_bytes()).len(), 99);
}
#[test]
fn a_stream_length_is_padded_as_luatex_leaves_it() {
assert_eq!(length_and_close(99), "99 >> ");
assert_eq!(length_and_close(10362), "10362 >> ");
}
#[test]
fn divide_scaled_is_utils_c_s() {
assert_eq!(divide_scaled(455111, 655360, 3), 694);
assert_eq!(divide_scaled(-1, 2, 0), -1);
assert_eq!(divide_scaled(1, 3, 3), 333);
}
#[test]
fn objects_are_numbered_and_placed_as_luatex_places_them() {
let mut w = Writer::new(Variables {
compress_level: 0,
..Variables::default()
});
let a = w.create();
let unused = w.create();
w.object(a, OBJSTM_ALWAYS, b"<< /A 1 >>");
assert!(matches!(w.places[3], Place::Fresh));
assert!(matches!(
w.places[a as usize],
Place::Packed {
stream: 3,
index: 0
}
));
let s = w.create();
w.stream(s, "/K 1", b"data", true);
let text = String::from_utf8_lossy(&w.out).into_owned();
assert!(
text.contains(
"4 0 obj\n<< /K 1 /Length 4 >> \nstream\ndata\nendstream\nendobj\n"
),
"{text}"
);
for _ in 1..OS_MAX_OBJS {
let n = w.create();
w.object(n, OBJSTM_ALWAYS, b"null");
}
assert!(w.objstm.is_none());
let text = String::from_utf8_lossy(&w.out).into_owned();
assert!(
text.contains("3 0 obj\n<< /Type /ObjStm /N 100 /First"),
"{text}"
);
let out = w.finish(a, None, "", [0; 16]);
let text = String::from_utf8_lossy(&out).into_owned();
assert!(text.contains("/W [ 1 2 1 ]"), "{text}");
let find = |needle: &[u8], from: usize| {
out[from..]
.windows(needle.len())
.position(|w| w == needle)
.map(|at| at + from)
};
let table = find(b"/Type /XRef", 0).expect("a table");
let rows_at = find(b"stream\n", table).expect("its rows") + 7;
let row = |k: usize| &out[rows_at + 4 * k..rows_at + 4 * k + 4];
assert_eq!(row(0), &[0, 0, unused as u8, 255]);
assert_eq!(row(unused as usize), &[0, 0, 0, 255]);
assert_eq!(row(a as usize), &[2, 0, 3, 0]);
assert_eq!(row(4)[0], 1);
}
}