Able to read stream when it's length is in object stream

Author: J-F-Liu

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lopdf"
-version = "0.17.0"
+version = "0.18.0"
 authors = ["Junfeng Liu <china.liujunfeng@gmail.com>"]
 homepage = "https://github.com/J-F-Liu/lopdf"
 documentation = "https://docs.rs/crate/lopdf/"

src/object.rs

@@ -21,6 +21,8 @@ pub struct Stream {
 	/// Can the stream be compressed by the `Document::compress()` function?
 	/// Font streams may not be compressed, for example
 	pub allows_compression: bool,
+	/// Stream data's position in PDF file.
+	pub start_position: Option<usize>,
 }
 
 /// Basic PDF object types defined in an enum.
@@ -361,6 +363,16 @@ impl Stream {
 			dict: dict,
 			content: content,
 			allows_compression: true,
+			start_position: None,
+		}
+	}
+
+	pub fn with_position(dict: Dictionary, position: usize) -> Stream {
+		Stream {
+			dict: dict,
+			content: vec![],
+			allows_compression: true,
+			start_position: Some(position),
 		}
 	}
 

src/parser.rs

@@ -113,16 +113,18 @@ fn dictionary() -> Parser<u8, Dictionary> {
 }
 
 fn stream<'a>(reader: &'a Reader) -> parser::Parser<'a, u8, Stream> {
-	dictionary() - space() - seq(b"stream") - eol() >>
-	move |dict: Dictionary| {
-		let length = dict.get("Length").and_then(|value| {
+	dictionary() - space() - seq(b"stream") - eol() >> move |dict: Dictionary| {
+		if let Some(length) = dict.get("Length").and_then(|value| {
 			if let Some(id) = value.as_reference() {
-				return reader.get_object(id).and_then(|value|value.as_i64());
+				return reader.get_object(id).and_then(|value| value.as_i64());
 			}
 			return value.as_i64();
-		}).expect("Stream Length should be an integer.");
-		let stream = take(length as usize) - eol().opt() - seq(b"endstream");
-		stream.map(move |data|Stream::new(dict.clone(), data))
+		}) {
+			let stream = take(length as usize) - eol().opt() - seq(b"endstream").expect("endstream");
+			stream.map(move |data| Stream::new(dict.clone(), data))
+		} else {
+			take(0).pos().map(move |pos| Stream::with_position(dict.clone(), pos))
+		}
 	}
 }
 
@@ -164,7 +166,7 @@ fn object<'a>(reader: &'a Reader) -> parser::Parser<'a, u8, Object> {
 }
 
 pub fn indirect_object<'a>(reader: &'a Reader) -> parser::Parser<'a, u8, (ObjectId, Object)> {
-	object_id() - seq(b"obj") - space() + object(reader) - space() - seq(b"endobj") - space()
+	object_id() - seq(b"obj") - space() + object(reader) - space() - seq(b"endobj").opt() - space()
 }
 
 pub fn header() -> Parser<u8, String> {

src/reader.rs

@@ -85,31 +85,63 @@ impl Reader {
 		self.document.trailer = trailer;
 		self.document.reference_table = xref;
 
-		for entry in self.document.reference_table.entries.values().filter(|entry|entry.is_normal()) {
+		let mut zero_length_streams = vec![];
+		for entry in self.document.reference_table.entries.values().filter(|entry| entry.is_normal()) {
 			match *entry {
-				XrefEntry::Normal{offset, ..} => {
+				XrefEntry::Normal { offset, .. } => {
 					let read_result = self.read_object(offset as usize);
 					match read_result {
 						Ok((object_id, mut object)) => {
 							match object {
 								Object::Stream(ref mut stream) => if stream.dict.type_is(b"ObjStm") {
 									let mut obj_stream = ObjectStream::new(stream);
 									self.document.objects.append(&mut obj_stream.objects);
+								} else if stream.content.len() == 0 {
+									zero_length_streams.push(object_id);
 								},
 								_ => {}
 							}
 							self.document.objects.insert(object_id, object);
-						},
-						Err(err) => { println!("{:?}", err); }
+						}
+						Err(err) => {
+							println!("{:?}", err);
+						}
 					}
-				},
-				_ => {},
+				}
+				_ => {}
 			};
 		}
 
+		for object_id in zero_length_streams {
+			if let Some(length) = self.get_stream_length(object_id) {
+				if let Some(ref mut object) = self.document.get_object_mut(object_id) {
+					match object {
+						Object::Stream(ref mut stream) => if let Some(start) = stream.start_position {
+							let end = start + length as usize;
+							stream.set_content(self.buffer[start..end].to_vec());
+						},
+						_ => {}
+					}
+				}
+			}
+		}
+
 		Ok(())
 	}
 
+	fn get_stream_length(&self, object_id: ObjectId) -> Option<i64> {
+		let object = self.document.get_object(object_id).unwrap();
+		match object {
+			Object::Stream(ref stream) => stream.dict.get("Length").and_then(|value| {
+				if let Some(id) = value.as_reference() {
+					return self.document.get_object(id).and_then(|value| value.as_i64());
+				}
+				return value.as_i64();
+			}),
+			_ => None,
+		}
+	}
+
 	/// Get object offset by object id.
 	fn get_offset(&self, id: ObjectId) -> Option<u32> {
 		if let Some(entry) = self.document.reference_table.get(id.0) {