Reorganize Packet struct interface and add in-page info

Firstly, we add info about whether a given packet is
the last one ending inside a page or the first one
starting.

Secondly, we redesign the packet struct contents and
make most of them private, only accessible through
functions. This serves the purpose to make such
additions doable in the future in a backwards
compatible fashion, as adding fields to a struct
full of public only fields is not backwards
compatible.
This smart idea is also recommended by the rust API
guidelines [1].

[1]: https://rust-lang-nursery.github.io/api-guidelines/future-proofing.html#structs-have-private-fields-c-struct-private

Author: est31

examples/dump-all.rs

@@ -48,8 +48,8 @@ fn print_u8_slice(arr :&[u8]) {
 
 fn dump_pck_info(p :&Packet, ctr :usize) {
 	println!("Packet: serial 0x{:08x}, data {:08} large, first {: >5}, last {: >5}, absgp 0x{:016x} nth {}",
-		p.stream_serial, p.data.len(), p.first_packet, p.last_packet,
-		p.absgp_page, ctr);
+		p.stream_serial(), p.data.len(), p.first_in_page(), p.last_in_page(),
+		p.absgp_page(), ctr);
 	print_u8_slice(&p.data);
 }
 

examples/format-info.rs

@@ -22,8 +22,8 @@ fn main() {
 
 fn dump_pck_info(p :&Packet) {
 	println!("Packet: serial 0x{:08x}, data {:08} large, first {: >5}, last {: >5}, absgp 0x{:016x}",
-		p.stream_serial, p.data.len(), p.first_packet, p.last_packet,
-		p.absgp_page);
+		p.stream_serial(), p.data.len(), p.first_in_page(), p.last_in_page(),
+		p.absgp_page());
 }
 
 fn run() -> Result<(), std::io::Error> {

examples/repack.rs

@@ -46,15 +46,19 @@ fn run() -> Result<(), std::io::Error> {
 		let r = btry!(pck_rdr.read_packet());
 		match r {
 			Some(pck) => {
-				let inf = if pck.last_packet {
-					PacketWriteEndInfo::NormalPacket
-				} else {
+				let inf = if pck.last_in_stream() {
 					PacketWriteEndInfo::EndStream
+				} else if pck.last_in_page() {
+					PacketWriteEndInfo::EndPage
+				} else {
+					PacketWriteEndInfo::NormalPacket
 				};
+				let stream_serial = pck.stream_serial();
+				let absgp_page = pck.absgp_page();
 				btry!(pck_wtr.write_packet(pck.data.into_boxed_slice(),
-					pck.stream_serial,
+					stream_serial,
 					inf,
-					pck.absgp_page));
+					absgp_page));
 			},
 			// End of stream
 			None => break,

src/lib.rs

@@ -47,16 +47,49 @@ Every logical bitstream is identified by the serial number its pages have stored
 pub struct Packet {
 	/// The data the `Packet` contains
 	pub data :Vec<u8>,
+	/// `true` iff this packet is the first one in the page.
+	first_packet_pg :bool,
 	/// `true` iff this packet is the first one in the logical bitstream.
-	pub first_packet :bool,
+	first_packet_stream :bool,
+	/// `true` iff this packet is the last one in the page.
+	last_packet_pg :bool,
 	/// `true` iff this packet is the last one in the logical bitstream
-	pub last_packet :bool,
+	last_packet_stream :bool,
 	/// Absolute granule position of the last page the packet was in.
 	/// The meaning of the absolute granule position is defined by the codec.
-	pub absgp_page :u64,
+	absgp_page :u64,
 	/// Serial number. Uniquely identifying the logical bitstream.
-	pub stream_serial :u32,
+	stream_serial :u32,
 	/*/// Packet counter
 	/// Why u64? There are MAX_U32 pages, and every page has up to 128 packets. u32 wouldn't be sufficient here...
 	pub sequence_num :u64,*/ // TODO perhaps add this later on...
 }
+
+impl Packet {
+	/// Returns whether the packet is the first one starting in the page
+	pub fn first_in_page(&self) -> bool {
+		self.first_packet_pg
+	}
+	/// Returns whether the packet is the first one of the entire stream
+	pub fn first_in_stream(&self) -> bool {
+		self.first_packet_stream
+	}
+	/// Returns whether the packet is the last one starting in the page
+	pub fn last_in_page(&self) -> bool {
+		self.last_packet_pg
+	}
+	/// Returns whether the packet is the last one of the entire stream
+	pub fn last_in_stream(&self) -> bool {
+		self.last_packet_stream
+	}
+	/// Returns the absolute granule position of the page the packet ended in.
+	///
+	/// The meaning of the absolute granule position is defined by the codec.
+	pub fn absgp_page(&self) -> u64 {
+		self.absgp_page
+	}
+	/// Returns the serial number that uniquely identifies the logical bitstream.
+	pub fn stream_serial(&self) -> u32 {
+		self.stream_serial
+	}
+}

src/reading.rs

@@ -400,8 +400,10 @@ impl BasePacketReader {
 
 		return Some(Packet {
 			data: packet_content,
-			first_packet: first_pck_overall,
-			last_packet: last_pck_overall,
+			first_packet_pg: first_pck_in_pg,
+			first_packet_stream: first_pck_overall,
+			last_packet_pg: last_pck_in_pg,
+			last_packet_stream: last_pck_overall,
 			absgp_page: pg_info.bi.absgp,
 			stream_serial: str_serial,
 		});