daniel/MontaukOS
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: PDF viewer

Browse Source
This commit is contained in:
Daniel Hammer
2026-03-06 08:00:57 +01:00
parent ead7d296f7
commit b148f0605a
12 changed files with 3127 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files
programs/src/pdfviewer/pdf_page.cpp
+629
View File
@@ -0,0 +1,629 @@
/*
* pdf_page.cpp
* PDF content stream parsing and text extraction
* Copyright (c) 2026 Daniel Hammer
*/
#include "pdfviewer.h"
// ============================================================================
// Content Stream Tokenizer
// ============================================================================
enum TokType {
TOK_EOF, TOK_INT, TOK_REAL, TOK_STRING, TOK_HEX_STRING,
TOK_NAME, TOK_ARRAY_START, TOK_ARRAY_END, TOK_OPERATOR
};
struct Token {
TokType type;
float num;
char str[MAX_TEXT_LEN];
int str_len;
};
static int next_token(const uint8_t* d, int len, int p, Token* tok) {
// Skip whitespace
while (p < len && (d[p] == ' ' || d[p] == '\t' || d[p] == '\n' || d[p] == '\r'))
p++;
// Skip comments
while (p < len && d[p] == '%') {
while (p < len && d[p] != '\n' && d[p] != '\r') p++;
while (p < len && (d[p] == ' ' || d[p] == '\t' || d[p] == '\n' || d[p] == '\r'))
p++;
}
if (p >= len) { tok->type = TOK_EOF; return p; }
// Literal string
if (d[p] == '(') {
p++;
int depth = 1;
tok->type = TOK_STRING;
tok->str_len = 0;
while (p < len && depth > 0) {
if (d[p] == '\\' && p + 1 < len) {
p++;
char c;
switch (d[p]) {
case 'n': c = '\n'; break;
case 'r': c = '\r'; break;
case 't': c = '\t'; break;
case 'b': c = '\b'; break;
case 'f': c = '\f'; break;
case '(': c = '('; break;
case ')': c = ')'; break;
case '\\': c = '\\'; break;
default:
// Octal escape
if (d[p] >= '0' && d[p] <= '7') {
int val = d[p] - '0';
if (p + 1 < len && d[p + 1] >= '0' && d[p + 1] <= '7') {
p++; val = val * 8 + (d[p] - '0');
if (p + 1 < len && d[p + 1] >= '0' && d[p + 1] <= '7') {
p++; val = val * 8 + (d[p] - '0');
}
}
c = (char)val;
} else {
c = (char)d[p];
}
break;
}
if (tok->str_len < MAX_TEXT_LEN - 1)
tok->str[tok->str_len++] = c;
p++;
} else if (d[p] == '(') {
depth++;
if (tok->str_len < MAX_TEXT_LEN - 1)
tok->str[tok->str_len++] = '(';
p++;
} else if (d[p] == ')') {
depth--;
if (depth > 0 && tok->str_len < MAX_TEXT_LEN - 1)
tok->str[tok->str_len++] = ')';
p++;
} else {
if (tok->str_len < MAX_TEXT_LEN - 1)
tok->str[tok->str_len++] = (char)d[p];
p++;
}
}
tok->str[tok->str_len] = '\0';
return p;
}
// Hex string
if (d[p] == '<' && (p + 1 >= len || d[p + 1] != '<')) {
p++;
tok->type = TOK_HEX_STRING;
tok->str_len = 0;
int nibble = -1;
while (p < len && d[p] != '>') {
int val = -1;
if (d[p] >= '0' && d[p] <= '9') val = d[p] - '0';
else if (d[p] >= 'a' && d[p] <= 'f') val = d[p] - 'a' + 10;
else if (d[p] >= 'A' && d[p] <= 'F') val = d[p] - 'A' + 10;
p++;
if (val < 0) continue;
if (nibble < 0) {
nibble = val;
} else {
if (tok->str_len < MAX_TEXT_LEN - 1)
tok->str[tok->str_len++] = (char)((nibble << 4) | val);
nibble = -1;
}
}
if (nibble >= 0 && tok->str_len < MAX_TEXT_LEN - 1)
tok->str[tok->str_len++] = (char)(nibble << 4);
tok->str[tok->str_len] = '\0';
if (p < len) p++; // skip '>'
return p;
}
// Array start/end
if (d[p] == '[') { tok->type = TOK_ARRAY_START; return p + 1; }
if (d[p] == ']') { tok->type = TOK_ARRAY_END; return p + 1; }
// Name
if (d[p] == '/') {
p++;
tok->type = TOK_NAME;
tok->str_len = 0;
while (p < len && d[p] != ' ' && d[p] != '\t' && d[p] != '\n' &&
d[p] != '\r' && d[p] != '/' && d[p] != '<' && d[p] != '>' &&
d[p] != '[' && d[p] != ']' && d[p] != '(' && d[p] != ')') {
if (tok->str_len < MAX_TEXT_LEN - 1)
tok->str[tok->str_len++] = (char)d[p];
p++;
}
tok->str[tok->str_len] = '\0';
return p;
}
// Number or operator
if ((d[p] >= '0' && d[p] <= '9') || d[p] == '-' || d[p] == '+' || d[p] == '.') {
// Try to parse as number
float val;
int np = parse_real_at(d, len, p, &val);
if (np > p) {
tok->type = TOK_REAL;
tok->num = val;
return np;
}
}
// Operator (keyword)
tok->type = TOK_OPERATOR;
tok->str_len = 0;
while (p < len && d[p] != ' ' && d[p] != '\t' && d[p] != '\n' &&
d[p] != '\r' && d[p] != '/' && d[p] != '<' && d[p] != '>' &&
d[p] != '[' && d[p] != ']' && d[p] != '(' && d[p] != ')') {
if (tok->str_len < MAX_TEXT_LEN - 1)
tok->str[tok->str_len++] = (char)d[p];
p++;
}
tok->str[tok->str_len] = '\0';
return p;
}
// ============================================================================
// Text State and Item Output
// ============================================================================
struct TextState {
float tm[6]; // text matrix [a b c d e f]
float lm[6]; // text line matrix
float tl; // text leading (TL)
float font_size;
char font_name[32];
uint8_t font_flags;
uint16_t* tounicode; // current font's glyph->Unicode table (may be nullptr)
TrueTypeFont* embedded_font; // embedded font from PDF, or nullptr
};
// Apply ToUnicode mapping to raw glyph bytes, producing a UTF-8-ish output.
// For BMP codepoints (which is all we handle), just output as Latin-1 where possible.
static int apply_tounicode(const char* raw, int raw_len, char* out, int out_max,
const uint16_t* tounicode) {
int oi = 0;
for (int i = 0; i < raw_len && oi < out_max - 1; i++) {
uint8_t glyph = (uint8_t)raw[i];
uint16_t cp = tounicode ? tounicode[glyph] : (uint16_t)glyph;
if (cp == 0) cp = glyph; // fallback to raw byte
if (cp < 128) {
out[oi++] = (char)cp;
} else if (cp < 0x800) {
// 2-byte UTF-8 - but our font renderer likely only handles Latin-1
// For now, output as Latin-1 if <= 255, otherwise skip
if (cp <= 255) {
out[oi++] = (char)cp;
} else {
out[oi++] = '?';
}
} else {
out[oi++] = '?';
}
}
out[oi] = '\0';
return oi;
}
static void add_text_item(PdfPage* page, float x, float y, float size,
const char* text, int text_len, uint8_t flags,
const uint16_t* tounicode, TrueTypeFont* embedded_font) {
if (text_len <= 0) return;
// Apply ToUnicode mapping if available (only when not using embedded font,
// since embedded subset fonts need the raw character codes for cmap lookup)
char mapped[MAX_TEXT_LEN];
if (tounicode && !embedded_font) {
text_len = apply_tounicode(text, text_len, mapped, MAX_TEXT_LEN, tounicode);
text = mapped;
}
if (text_len <= 0) return;
// Grow items array if needed
if (page->item_count >= page->item_cap) {
int new_cap = page->item_cap ? page->item_cap * 2 : 64;
TextItem* new_items = (TextItem*)montauk::malloc(new_cap * sizeof(TextItem));
if (!new_items) return;
if (page->items) {
montauk::memcpy(new_items, page->items, page->item_count * sizeof(TextItem));
montauk::mfree(page->items);
}
page->items = new_items;
page->item_cap = new_cap;
}
TextItem* item = &page->items[page->item_count++];
item->x = x;
item->y = y;
item->font_size = size;
item->flags = flags;
item->font = embedded_font;
int copy = text_len < MAX_TEXT_LEN - 1 ? text_len : MAX_TEXT_LEN - 1;
montauk::memcpy(item->text, text, copy);
item->text[copy] = '\0';
}
static void matrix_multiply(float* result, const float* a, const float* b) {
// Multiply two 3x3 matrices represented as [a b c d e f]
// where the matrix is: [a b 0]
// [c d 0]
// [e f 1]
result[0] = a[0] * b[0] + a[1] * b[2];
result[1] = a[0] * b[1] + a[1] * b[3];
result[2] = a[2] * b[0] + a[3] * b[2];
result[3] = a[2] * b[1] + a[3] * b[3];
result[4] = a[4] * b[0] + a[5] * b[2] + b[4];
result[5] = a[4] * b[1] + a[5] * b[3] + b[5];
}
// ============================================================================
// Operand Stack
// ============================================================================
struct Operand {
float num;
char str[MAX_TEXT_LEN];
int str_len;
bool is_name;
bool is_string;
};
// ============================================================================
// Content Stream Parser
// ============================================================================
static FontInfo* lookup_font(FontMap* fonts, const char* name) {
for (int i = 0; i < fonts->count; i++) {
if (str_len(fonts->fonts[i].name) == str_len(name)) {
bool match = true;
for (int j = 0; name[j]; j++) {
if (fonts->fonts[i].name[j] != name[j]) { match = false; break; }
}
if (match) return &fonts->fonts[i];
}
}
return nullptr;
}
void parse_page(int page_idx, int page_obj_num) {
PdfPage* page = &g_doc.pages[page_idx];
// Build font map for this page
FontMap* fonts = (FontMap*)montauk::malloc(sizeof(FontMap));
if (!fonts) return;
build_font_map(page_obj_num, fonts);
// Get content stream(s)
int start, end;
if (find_obj_content(page_obj_num, &start, &end) < 0) {
for (int fi = 0; fi < fonts->count; fi++)
if (fonts->fonts[fi].tounicode) montauk::mfree(fonts->fonts[fi].tounicode);
montauk::mfree(fonts);
return;
}
const uint8_t* d = g_doc.data;
int len = g_doc.data_len;
int contents_pos = dict_lookup(d, len, start, "Contents");
if (contents_pos < 0) {
for (int fi = 0; fi < fonts->count; fi++)
if (fonts->fonts[fi].tounicode) montauk::mfree(fonts->fonts[fi].tounicode);
montauk::mfree(fonts);
return;
}
// Collect content stream object numbers
int content_objs[32];
int content_count = 0;
int cp = skip_ws(d, len, contents_pos);
if (cp < len && d[cp] == '[') {
// Array of references
cp++;
while (cp < len && d[cp] != ']' && content_count < 32) {
cp = skip_ws(d, len, cp);
if (cp >= len || d[cp] == ']') break;
int ref_num;
int rp = parse_ref_at(d, len, cp, &ref_num);
if (rp > 0) {
content_objs[content_count++] = ref_num;
cp = rp;
} else {
cp++;
}
}
} else {
// Single reference
int ref_num;
if (parse_ref_at(d, len, cp, &ref_num) > 0) {
content_objs[content_count++] = ref_num;
}
}
// Concatenate and parse all content streams
for (int ci = 0; ci < content_count; ci++) {
int stream_len;
uint8_t* stream_data = get_stream_data(content_objs[ci], &stream_len);
if (!stream_data) continue;
// Parse the content stream
Operand* ops = (Operand*)montauk::malloc(MAX_OPERANDS * sizeof(Operand));
if (!ops) { montauk::mfree(stream_data); continue; }
int op_count = 0;
TextState ts;
ts.tm[0] = 1; ts.tm[1] = 0; ts.tm[2] = 0; ts.tm[3] = 1; ts.tm[4] = 0; ts.tm[5] = 0;
ts.lm[0] = 1; ts.lm[1] = 0; ts.lm[2] = 0; ts.lm[3] = 1; ts.lm[4] = 0; ts.lm[5] = 0;
ts.tl = 0;
ts.font_size = 12;
ts.font_name[0] = '\0';
ts.font_flags = 0;
ts.tounicode = nullptr;
ts.embedded_font = nullptr;
bool in_text = false;
Token tok;
int pos = 0;
while (pos < stream_len) {
pos = next_token(stream_data, stream_len, pos, &tok);
if (tok.type == TOK_EOF) break;
// Accumulate operands
if (tok.type == TOK_REAL || tok.type == TOK_INT) {
if (op_count < MAX_OPERANDS) {
ops[op_count].num = tok.num;
ops[op_count].is_name = false;
ops[op_count].is_string = false;
ops[op_count].str_len = 0;
op_count++;
}
continue;
}
if (tok.type == TOK_NAME) {
if (op_count < MAX_OPERANDS) {
ops[op_count].is_name = true;
ops[op_count].is_string = false;
str_cpy(ops[op_count].str, tok.str, MAX_TEXT_LEN);
ops[op_count].str_len = tok.str_len;
op_count++;
}
continue;
}
if (tok.type == TOK_STRING || tok.type == TOK_HEX_STRING) {
if (op_count < MAX_OPERANDS) {
ops[op_count].is_name = false;
ops[op_count].is_string = true;
montauk::memcpy(ops[op_count].str, tok.str, tok.str_len);
ops[op_count].str[tok.str_len] = '\0';
ops[op_count].str_len = tok.str_len;
ops[op_count].num = 0;
op_count++;
}
continue;
}
if (tok.type == TOK_ARRAY_START) {
// Special handling for TJ arrays
// Collect items until ']'
// Build concatenated string from string elements
char tj_buf[MAX_TEXT_LEN];
int tj_len = 0;
while (pos < stream_len) {
Token atk;
int next_pos = next_token(stream_data, stream_len, pos, &atk);
if (atk.type == TOK_EOF) break;
if (atk.type == TOK_ARRAY_END) { pos = next_pos; break; }
if ((atk.type == TOK_STRING || atk.type == TOK_HEX_STRING) &&
tj_len + atk.str_len < MAX_TEXT_LEN - 1) {
montauk::memcpy(tj_buf + tj_len, atk.str, atk.str_len);
tj_len += atk.str_len;
}
// Number entries in TJ arrays are kerning values - skip them
pos = next_pos;
}
tj_buf[tj_len] = '\0';
if (tj_len > 0 && op_count < MAX_OPERANDS) {
ops[op_count].is_name = false;
ops[op_count].is_string = true;
montauk::memcpy(ops[op_count].str, tj_buf, tj_len + 1);
ops[op_count].str_len = tj_len;
ops[op_count].num = 0;
op_count++;
}
continue;
}
// Process operator
if (tok.type != TOK_OPERATOR) { op_count = 0; continue; }
const char* op = tok.str;
// BT - begin text
if (op[0] == 'B' && op[1] == 'T' && op[2] == '\0') {
in_text = true;
ts.tm[0] = 1; ts.tm[1] = 0; ts.tm[2] = 0; ts.tm[3] = 1;
ts.tm[4] = 0; ts.tm[5] = 0;
ts.lm[0] = 1; ts.lm[1] = 0; ts.lm[2] = 0; ts.lm[3] = 1;
ts.lm[4] = 0; ts.lm[5] = 0;
}
// ET - end text
else if (op[0] == 'E' && op[1] == 'T' && op[2] == '\0') {
in_text = false;
}
// Tf - set font
else if (op[0] == 'T' && op[1] == 'f' && op[2] == '\0' && in_text) {
if (op_count >= 2 && ops[0].is_name) {
str_cpy(ts.font_name, ops[0].str, 32);
ts.font_size = ops[1].num;
FontInfo* fi = lookup_font(fonts, ts.font_name);
ts.font_flags = fi ? fi->flags : 0;
ts.tounicode = fi ? fi->tounicode : nullptr;
ts.embedded_font = fi ? fi->embedded_font : nullptr;
}
}
// TL - set text leading
else if (op[0] == 'T' && op[1] == 'L' && op[2] == '\0' && in_text) {
if (op_count >= 1) ts.tl = ops[0].num;
}
// Td - move text position
else if (op[0] == 'T' && op[1] == 'd' && op[2] == '\0' && in_text) {
if (op_count >= 2) {
float tx = ops[0].num;
float ty = ops[1].num;
float translate[6] = {1, 0, 0, 1, tx, ty};
float result[6];
matrix_multiply(result, translate, ts.lm);
for (int i = 0; i < 6; i++) { ts.tm[i] = result[i]; ts.lm[i] = result[i]; }
}
}
// TD - move text position and set leading
else if (op[0] == 'T' && op[1] == 'D' && op[2] == '\0' && in_text) {
if (op_count >= 2) {
ts.tl = -ops[1].num;
float tx = ops[0].num;
float ty = ops[1].num;
float translate[6] = {1, 0, 0, 1, tx, ty};
float result[6];
matrix_multiply(result, translate, ts.lm);
for (int i = 0; i < 6; i++) { ts.tm[i] = result[i]; ts.lm[i] = result[i]; }
}
}
// Tm - set text matrix
else if (op[0] == 'T' && op[1] == 'm' && op[2] == '\0' && in_text) {
if (op_count >= 6) {
for (int i = 0; i < 6; i++) {
ts.tm[i] = ops[i].num;
ts.lm[i] = ops[i].num;
}
}
}
// T* - move to start of next line
else if (op[0] == 'T' && op[1] == '*' && op[2] == '\0' && in_text) {
float translate[6] = {1, 0, 0, 1, 0, -ts.tl};
float result[6];
matrix_multiply(result, translate, ts.lm);
for (int i = 0; i < 6; i++) { ts.tm[i] = result[i]; ts.lm[i] = result[i]; }
}
// Tj - show string
else if (op[0] == 'T' && op[1] == 'j' && op[2] == '\0' && in_text) {
if (op_count >= 1 && ops[0].is_string && ops[0].str_len > 0) {
float eff_size = ts.font_size;
// Scale by text matrix
float sy = ts.tm[3];
if (sy < 0) sy = -sy;
if (sy > 0.01f) eff_size *= sy;
add_text_item(page, ts.tm[4], ts.tm[5], eff_size,
ops[0].str, ops[0].str_len, ts.font_flags, ts.tounicode, ts.embedded_font);
// Advance text position using font metrics when available
TrueTypeFont* adv_font = ts.embedded_font;
if (!adv_font) {
adv_font = g_font;
if ((ts.font_flags & 1) && g_font_bold) adv_font = g_font_bold;
if ((ts.font_flags & 4) && g_font_mono) adv_font = g_font_mono;
}
float advance;
if (adv_font) {
int msz = (int)(ts.font_size + 0.5f);
if (msz < 4) msz = 4;
if (msz > 120) msz = 120;
advance = (float)adv_font->measure_text(ops[0].str, msz);
} else {
advance = ops[0].str_len * ts.font_size * 0.5f;
}
ts.tm[4] += advance * ts.tm[0];
ts.tm[5] += advance * ts.tm[1];
}
}
// TJ - show string (array already concatenated)
else if (op[0] == 'T' && op[1] == 'J' && op[2] == '\0' && in_text) {
if (op_count >= 1 && ops[op_count - 1].is_string && ops[op_count - 1].str_len > 0) {
Operand* sop = &ops[op_count - 1];
float eff_size = ts.font_size;
float sy = ts.tm[3];
if (sy < 0) sy = -sy;
if (sy > 0.01f) eff_size *= sy;
add_text_item(page, ts.tm[4], ts.tm[5], eff_size,
sop->str, sop->str_len, ts.font_flags, ts.tounicode, ts.embedded_font);
TrueTypeFont* adv_font = ts.embedded_font;
if (!adv_font) {
adv_font = g_font;
if ((ts.font_flags & 1) && g_font_bold) adv_font = g_font_bold;
if ((ts.font_flags & 4) && g_font_mono) adv_font = g_font_mono;
}
float advance;
if (adv_font) {
int msz = (int)(ts.font_size + 0.5f);
if (msz < 4) msz = 4;
if (msz > 120) msz = 120;
advance = (float)adv_font->measure_text(sop->str, msz);
} else {
advance = sop->str_len * ts.font_size * 0.5f;
}
ts.tm[4] += advance * ts.tm[0];
ts.tm[5] += advance * ts.tm[1];
}
}
// ' (single quote) - move to next line and show string
else if (op[0] == '\'' && op[1] == '\0' && in_text) {
// T*
float translate[6] = {1, 0, 0, 1, 0, -ts.tl};
float result[6];
matrix_multiply(result, translate, ts.lm);
for (int i = 0; i < 6; i++) { ts.tm[i] = result[i]; ts.lm[i] = result[i]; }
// Tj
if (op_count >= 1 && ops[0].is_string && ops[0].str_len > 0) {
float eff_size = ts.font_size;
float sy = ts.tm[3];
if (sy < 0) sy = -sy;
if (sy > 0.01f) eff_size *= sy;
add_text_item(page, ts.tm[4], ts.tm[5], eff_size,
ops[0].str, ops[0].str_len, ts.font_flags, ts.tounicode, ts.embedded_font);
}
}
// " (double quote) - set aw, ac, move to next line, show string
else if (op[0] == '"' && op[1] == '\0' && in_text) {
// T*
float translate[6] = {1, 0, 0, 1, 0, -ts.tl};
float result[6];
matrix_multiply(result, translate, ts.lm);
for (int i = 0; i < 6; i++) { ts.tm[i] = result[i]; ts.lm[i] = result[i]; }
// Show string (third operand)
if (op_count >= 3 && ops[2].is_string && ops[2].str_len > 0) {
float eff_size = ts.font_size;
float sy = ts.tm[3];
if (sy < 0) sy = -sy;
if (sy > 0.01f) eff_size *= sy;
add_text_item(page, ts.tm[4], ts.tm[5], eff_size,
ops[2].str, ops[2].str_len, ts.font_flags, ts.tounicode, ts.embedded_font);
}
}
op_count = 0; // reset operand stack after operator
}
montauk::mfree(ops);
montauk::mfree(stream_data);
}
for (int fi = 0; fi < fonts->count; fi++)
if (fonts->fonts[fi].tounicode) montauk::mfree(fonts->fonts[fi].tounicode);
montauk::mfree(fonts);
}