lopdf 0.40.0

A Rust library for PDF document manipulation.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use lopdf::{Document, SaveOptions, Object};

#[cfg(feature = "async")]
use tokio::runtime::Builder;

#[cfg(not(feature = "async"))]
fn load_document(path: &str) -> Document {
    Document::load(path).unwrap()
}

#[cfg(feature = "async")]
fn load_document(path: &str) -> Document {
    Builder::new_current_thread()
        .enable_all()
        .build()
        .unwrap()
        .block_on(async move {
            Document::load(path).await.unwrap()
        })
}

fn main() {
    println!("Checking raw object stream in saved PDF...\n");
    
    // Create a simple document
    let mut doc = Document::with_version("1.5");
    
    // Add some objects that will be compressed
    for i in 1..=10 {
        doc.add_object(Object::Integer(i * 100));
    }
    
    // Add catalog
    let pages_id = doc.add_object(lopdf::dictionary! {
        "Type" => "Pages",
        "Kids" => vec![],
        "Count" => 0
    });
    
    let catalog_id = doc.add_object(lopdf::dictionary! {
        "Type" => "Catalog",
        "Pages" => pages_id
    });
    
    doc.trailer.set("Root", catalog_id);
    
    // Save with object streams
    let options = SaveOptions {
        use_object_streams: true,
        use_xref_streams: true,
        ..Default::default()
    };
    
    let filename = "test_raw_objstream.pdf";
    let mut buffer = Vec::new();
    doc.save_with_options(&mut buffer, options).unwrap();
    std::fs::write(filename, &buffer).unwrap();
    
    println!("Saved {} bytes to {}", buffer.len(), filename);
    
    // Now read the raw file and look for object streams
    println!("\nSearching for object streams in raw file...");
    
    let file_str = String::from_utf8_lossy(&buffer);
    
    // Find object streams by looking for "/Type/ObjStm"
    let mut pos = 0;
    while let Some(found) = file_str[pos..].find("/Type/ObjStm") {
        let abs_pos = pos + found;
        println!("\nFound /Type/ObjStm at position {}", abs_pos);
        
        // Find the start of this object (look backwards for "obj")
        if let Some(obj_start) = file_str[..abs_pos].rfind(" obj") {
            // Extract object number
            let obj_line_start = file_str[..obj_start].rfind('\n').unwrap_or(0) + 1;
            let obj_header = &file_str[obj_line_start..obj_start];
            println!("Object header: {}", obj_header.trim());
            
            // Look for dictionary end and stream content
            if let Some(dict_end) = file_str[abs_pos..].find(">>") {
                let dict_end_pos = abs_pos + dict_end + 2;
                let dict_content = &file_str[obj_start + 4..dict_end_pos];
                println!("Dictionary content: {}", dict_content.trim());
                
                // Check if there's a Filter
                if dict_content.contains("/Filter") {
                    println!("✓ Has Filter!");
                } else {
                    println!("✗ No Filter found!");
                }
                
                // Check stream content
                if let Some(stream_start) = file_str[dict_end_pos..].find("stream") {
                    let stream_pos = dict_end_pos + stream_start + 6;
                    if file_str.len() > stream_pos + 2 {
                        let next_char = file_str.as_bytes()[stream_pos + 1];
                        if next_char == b'\n' || next_char == b'\r' {
                            let stream_content_start = stream_pos + 2;
                            // Check first few bytes
                            let preview = &buffer[stream_content_start..stream_content_start.min(buffer.len()).min(stream_content_start + 20)];
                            println!("First 20 bytes of stream: {:?}", preview);
                            
                            // Check if it looks compressed
                            let looks_compressed = preview.iter().any(|&b| b > 127 || (b < 32 && b != b'\n' && b != b'\r'));
                            println!("Looks compressed: {}", looks_compressed);
                        }
                    }
                }
            }
        }
        
        pos = abs_pos + 10;
    }
    
    // Now load it back and check
    println!("\n\nLoading PDF back...");
    let loaded = load_document(filename);
    
    let mut found_objstream = false;
    for (id, obj) in &loaded.objects {
        if let Object::Stream(stream) = obj {
            if let Ok(type_obj) = stream.dict.get(b"Type") {
                if let Ok(type_name) = type_obj.as_name() {
                    if type_name == b"ObjStm" {
                        found_objstream = true;
                        println!("\nLoaded object stream {} 0 R:", id.0);
                        println!("  Has Filter: {}", stream.dict.get(b"Filter").is_ok());
                        println!("  Dictionary: {:?}", stream.dict);
                    }
                }
            }
        }
    }
    
    if !found_objstream {
        println!("No object streams found in loaded PDF!");
    }
}