rpdfium_parser/

linearized_header.rs

// Derived from PDFium's cpdf_linearized_header.cpp
// Original: Copyright 2014 The PDFium Authors
// Licensed under BSD-3-Clause / Apache-2.0
// See pdfium-upstream/LICENSE for the original license.

//! Linearization detection.
//!
//! A linearized PDF has its first indirect object contain a `/Linearized` key
//! in its dictionary. This module detects this marker and extracts the
//! linearization parameters.

use rpdfium_core::{Name, ParsingMode};

use crate::header::parse_header;
use crate::object::Object;
use crate::object_parser::parse_indirect_object;

/// Information extracted from a linearization dictionary.
#[derive(Debug, Clone)]
pub struct LinearizedInfo {
    /// Total file length in bytes (`/L`).
    pub file_length: u64,
    /// Primary page number (`/P`), typically 0.
    pub primary_page: u32,
    /// Total page count (`/N`).
    pub page_count: u32,
    /// Byte offset of the first page's data (`/O`).
    pub first_page_offset: u64,
    /// Byte offset of the hint stream (`/H` array, first element).
    pub hint_stream_offset: Option<u64>,
    /// Length of the hint stream in bytes (`/H` array, second element).
    pub hint_stream_length: Option<u32>,
}

/// Detect whether a PDF is linearized by checking the first indirect object.
///
/// Returns `Some(LinearizedInfo)` if the file is linearized, `None` otherwise.
pub fn detect_linearized(source: &[u8], mode: ParsingMode) -> Option<LinearizedInfo> {
    // Parse the header to find where objects start
    let (_version, header_end) = parse_header(source, mode).ok()?;

    // Skip any binary comment line (common: % followed by 4+ high bytes)
    let mut pos = header_end as usize;
    while pos < source.len()
        && (source[pos] == b'%'
            || source[pos] == b'\r'
            || source[pos] == b'\n'
            || source[pos] > 127)
    {
        // Skip the comment line
        if source[pos] == b'%' {
            while pos < source.len() && source[pos] != b'\r' && source[pos] != b'\n' {
                pos += 1;
            }
        }
        while pos < source.len() && (source[pos] == b'\r' || source[pos] == b'\n') {
            pos += 1;
        }
    }

    // Try to parse the first indirect object
    let (_id, obj) = parse_indirect_object(source, pos as u64, mode).ok()?;

    // Check if the dictionary contains /Linearized
    let dict = obj.as_dict()?;
    let _linearized = dict.get(&Name::from("Linearized"))?;

    // Extract linearization parameters
    let file_length = match dict.get(&Name::from_bytes(b"L".to_vec())) {
        Some(Object::Integer(n)) if *n > 0 => *n as u64,
        _ => return None,
    };

    let page_count = match dict.get(&Name::n()) {
        Some(Object::Integer(n)) if *n > 0 => *n as u32,
        _ => return None,
    };

    let primary_page = match dict.get(&Name::from_bytes(b"P".to_vec())) {
        Some(Object::Integer(n)) if *n >= 0 => *n as u32,
        _ => 0, // Default to 0 if not present
    };

    let first_page_offset = match dict.get(&Name::from_bytes(b"O".to_vec())) {
        Some(Object::Integer(n)) if *n > 0 => *n as u64,
        _ => return None,
    };

    // Parse /H array: [offset, length] or [offset, length, shared_offset, shared_length]
    let (hint_stream_offset, hint_stream_length) = match dict.get(&Name::h()) {
        Some(Object::Array(arr)) if arr.len() >= 2 => {
            let offset = arr[0].as_i64().filter(|&n| n > 0).map(|n| n as u64);
            let length = arr[1].as_i64().filter(|&n| n > 0).map(|n| n as u32);
            (offset, length)
        }
        _ => (None, None),
    };

    Some(LinearizedInfo {
        file_length,
        primary_page,
        page_count,
        first_page_offset,
        hint_stream_offset,
        hint_stream_length,
    })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn detect_non_linearized() {
        let mut pdf = Vec::new();
        pdf.extend_from_slice(b"%PDF-1.4\n");
        let obj_offset = pdf.len();
        pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog >>\nendobj\n");
        let xref_offset = pdf.len();
        pdf.extend_from_slice(b"xref\n0 2\n");
        pdf.extend_from_slice(b"0000000000 65535 f \r\n");
        pdf.extend_from_slice(format!("{:010} 00000 n \r\n", obj_offset).as_bytes());
        pdf.extend_from_slice(b"trailer\n<< /Size 2 /Root 1 0 R >>\n");
        pdf.extend_from_slice(format!("startxref\n{}\n%%EOF", xref_offset).as_bytes());

        let result = detect_linearized(&pdf, ParsingMode::Lenient);
        assert!(result.is_none());
    }

    #[test]
    fn detect_linearized_pdf() {
        let mut pdf = Vec::new();
        pdf.extend_from_slice(b"%PDF-1.4\n");
        pdf.extend_from_slice(
            b"1 0 obj\n<< /Linearized 1.0 /L 12345 /N 5 /O 100 /P 0 >>\nendobj\n",
        );
        // We need enough data to look like a valid PDF, but we're only testing the first object
        pdf.extend_from_slice(b"2 0 obj\n<< >>\nendobj\n");

        let result = detect_linearized(&pdf, ParsingMode::Lenient);
        assert!(result.is_some());

        let info = result.unwrap();
        assert_eq!(info.file_length, 12345);
        assert_eq!(info.page_count, 5);
        assert_eq!(info.primary_page, 0);
        assert_eq!(info.first_page_offset, 100);
        assert!(info.hint_stream_offset.is_none());
        assert!(info.hint_stream_length.is_none());
    }

    #[test]
    fn detect_linearized_with_h_array_2_values() {
        let mut pdf = Vec::new();
        pdf.extend_from_slice(b"%PDF-1.4\n");
        pdf.extend_from_slice(
            b"1 0 obj\n<< /Linearized 1.0 /L 50000 /N 10 /O 200 /H [500 120] >>\nendobj\n",
        );
        pdf.extend_from_slice(b"2 0 obj\n<< >>\nendobj\n");

        let info = detect_linearized(&pdf, ParsingMode::Lenient).unwrap();
        assert_eq!(info.hint_stream_offset, Some(500));
        assert_eq!(info.hint_stream_length, Some(120));
    }

    #[test]
    fn detect_linearized_with_h_array_4_values() {
        let mut pdf = Vec::new();
        pdf.extend_from_slice(b"%PDF-1.4\n");
        pdf.extend_from_slice(
            b"1 0 obj\n<< /Linearized 1.0 /L 50000 /N 10 /O 200 /H [500 120 700 80] >>\nendobj\n",
        );
        pdf.extend_from_slice(b"2 0 obj\n<< >>\nendobj\n");

        let info = detect_linearized(&pdf, ParsingMode::Lenient).unwrap();
        assert_eq!(info.hint_stream_offset, Some(500));
        assert_eq!(info.hint_stream_length, Some(120));
    }

    #[test]
    fn non_linearized_has_no_hint_fields() {
        let mut pdf = Vec::new();
        pdf.extend_from_slice(b"%PDF-1.4\n");
        let obj_offset = pdf.len();
        pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog >>\nendobj\n");
        let xref_offset = pdf.len();
        pdf.extend_from_slice(b"xref\n0 2\n");
        pdf.extend_from_slice(b"0000000000 65535 f \r\n");
        pdf.extend_from_slice(format!("{:010} 00000 n \r\n", obj_offset).as_bytes());
        pdf.extend_from_slice(b"trailer\n<< /Size 2 /Root 1 0 R >>\n");
        pdf.extend_from_slice(format!("startxref\n{}\n%%EOF", xref_offset).as_bytes());

        let result = detect_linearized(&pdf, ParsingMode::Lenient);
        assert!(result.is_none());
    }

    #[test]
    fn detect_linearized_missing_keys() {
        let mut pdf = Vec::new();
        pdf.extend_from_slice(b"%PDF-1.4\n");
        pdf.extend_from_slice(
            b"1 0 obj\n<< /Linearized 1.0 >>\nendobj\n", // Missing /L, /N, /O
        );

        let result = detect_linearized(&pdf, ParsingMode::Lenient);
        assert!(result.is_none());
    }
}