diff --git a/src/lib.rs b/src/lib.rs index 081ae2a..ae8c7a9 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -26,15 +26,6 @@ mod are `PacketReader` and `PacketWriter`. #[cfg(test)] mod test; -macro_rules! tri { - ($e:expr) => { - match $e { - Ok(val) => val, - Err(err) => return Err(err.into()), - } - }; -} - mod crc; pub mod reading; pub mod writing; diff --git a/src/reading.rs b/src/reading.rs index ea8fca5..a4d9d67 100644 --- a/src/reading.rs +++ b/src/reading.rs @@ -237,9 +237,9 @@ impl PageParser { pub fn new_with_parse_opts(header_buf :[u8; 27], parse_opts :impl Into>) -> Result<(PageParser, usize), OggReadError> { let mut header_rdr = Cursor::new(header_buf); header_rdr.set_position(4); - let stream_structure_version = tri!(header_rdr.read_u8()); + let stream_structure_version = header_rdr.read_u8()?; if stream_structure_version != 0 { - tri!(Err(OggReadError::InvalidStreamStructVer(stream_structure_version))); + return Err(OggReadError::InvalidStreamStructVer(stream_structure_version)); } let header_type_flag = header_rdr.read_u8().unwrap(); let absgp = header_rdr.read_u64::().unwrap(); @@ -336,7 +336,7 @@ impl PageParser { // 3. Compare to the extracted one if self.checksum != hash_calculated { - tri!(Err(OggReadError::HashMismatch(self.checksum, hash_calculated))); + return Err(OggReadError::HashMismatch(self.checksum, hash_calculated)); } } self.segments_or_packets_buf = packet_data; @@ -471,11 +471,11 @@ impl BasePacketReader { Entry::Occupied(mut o) => { let inf = o.get_mut(); if pg_prs.bi.first_page { - tri!(Err(OggReadError::InvalidData)); + return Err(OggReadError::InvalidData); } if pg_prs.bi.starts_with_continued != inf.bi.ends_with_continued { if !self.has_seeked { - tri!(Err(OggReadError::InvalidData)); + return Err(OggReadError::InvalidData); } else { // If we have seeked, we are more tolerant here, // and just drop the continued packet's content. @@ -517,7 +517,7 @@ impl BasePacketReader { if !self.has_seeked { if !pg_prs.bi.first_page || pg_prs.bi.starts_with_continued { // If we haven't seeked, this is an error. - tri!(Err(OggReadError::InvalidData)); + return Err(OggReadError::InvalidData); } } else { if !pg_prs.bi.first_page { @@ -635,7 +635,7 @@ impl UntilPageHeaderReader { // and must well fit into an i32 (needs to be stored in SeekNeeded) let mut buf :[u8; 1024] = [0; 1024]; - let rd_len = tri!(rdr.read(if self.read_amount < 27 { + let rd_len = rdr.read(if self.read_amount < 27 { // This is an optimisation for the most likely case: // the next page directly follows the current read position. // Then it would be a waste to read more than the needed amount. @@ -647,7 +647,7 @@ impl UntilPageHeaderReader { SeekNeeded(_) => return Ok(Res::SeekNeeded), Found => return Ok(Res::Found), } - })); + })?; if rd_len == 0 { // Reached EOF. This means we're in one of these cases: @@ -672,7 +672,7 @@ impl UntilPageHeaderReader { if self.read_amount > read_amount_max { // Exhaustive searching for the capture pattern // has returned no ogg capture pattern. - tri!(Err(OggReadError::NoCapturePatternFound)); + return Err(OggReadError::NoCapturePatternFound); } let rd_buf = &buf[0 .. rd_len]; @@ -733,7 +733,7 @@ impl UntilPageHeaderReader { match self.mode { Searching | FoundWithNeeded(_) => Ok(Res::ReadNeeded), SeekNeeded(offs) => { - tri!(skr.seek(SeekFrom::Current(offs as i64))); + skr.seek(SeekFrom::Current(offs as i64))?; self.mode = Found; Ok(Res::Found) }, @@ -806,9 +806,8 @@ impl PacketReader { if let Some(pck) = self.base_pck_rdr.read_packet() { return Ok(Some(pck)); } - let page = tri!(self.read_ogg_page()); - match page { - Some(page) => tri!(self.base_pck_rdr.push_page(page)), + match self.read_ogg_page()? { + Some(page) => self.base_pck_rdr.push_page(page)?, None => return Ok(None), } } @@ -819,10 +818,10 @@ impl PacketReader { /// returns an Err(_) if the physical stream has ended. /// This function is useful if you expect a new packet to come. pub fn read_packet_expected(&mut self) -> Result { - match tri!(self.read_packet()) { + match self.read_packet()? { Some(p) => Ok(p), - None => tri!(Err(Error::new(ErrorKind::UnexpectedEof, - "Expected ogg packet but found end of physical stream"))), + None => Err(Error::new(ErrorKind::UnexpectedEof, + "Expected ogg packet but found end of physical stream").into()), } } @@ -837,7 +836,7 @@ impl PacketReader { fn read_until_pg_header(&mut self) -> Result, OggReadError> { let mut r = UntilPageHeaderReader::new(); use self::UntilPageHeaderResult::*; - let mut res = tri!(r.do_read(&mut self.rdr)); + let mut res = r.do_read(&mut self.rdr)?; loop { res = match res { Eof => return Ok(None), @@ -847,8 +846,8 @@ impl PacketReader { self.read_some_pg = true; break }, - ReadNeeded => tri!(r.do_read(&mut self.rdr)), - SeekNeeded => tri!(r.do_seek(&mut self.rdr)) + ReadNeeded => r.do_read(&mut self.rdr)?, + SeekNeeded => r.do_seek(&mut self.rdr)?, } } Ok(Some(r.into_header())) @@ -860,22 +859,22 @@ impl PacketReader { /// is at the current reader position. /// Instead it searches until it finds the capture pattern. fn read_ogg_page(&mut self) -> Result, OggReadError> { - let header_buf :[u8; 27] = match tri!(self.read_until_pg_header()) { + let header_buf :[u8; 27] = match self.read_until_pg_header()? { Some(s) => s, None if self.read_some_pg => return Ok(None), None => return Err(OggReadError::NoCapturePatternFound) }; - let (mut pg_prs, page_segments) = tri!(PageParser::new_with_parse_opts(header_buf, Arc::clone(&self.pg_parse_opts))); + let (mut pg_prs, page_segments) = PageParser::new_with_parse_opts(header_buf, Arc::clone(&self.pg_parse_opts))?; let mut segments_buf = vec![0; page_segments]; // TODO fix this, we initialize memory for NOTHING!!! Out of some reason, this is seen as "unsafe" by rustc. - tri!(self.rdr.read_exact(&mut segments_buf)); + self.rdr.read_exact(&mut segments_buf)?; let page_siz = pg_prs.parse_segments(segments_buf); let mut packet_data = vec![0; page_siz]; - tri!(self.rdr.read_exact(&mut packet_data)); + self.rdr.read_exact(&mut packet_data)?; - Ok(Some(tri!(pg_prs.parse_packet_data(packet_data)))) + Ok(Some(pg_prs.parse_packet_data(packet_data)?)) } /// Seeks the underlying reader @@ -885,7 +884,7 @@ impl PacketReader { /// /// This also flushes all the unread packets in the queue. pub fn seek_bytes(&mut self, pos :SeekFrom) -> Result { - let r = tri!(self.rdr.seek(pos)); + let r = self.rdr.seek(pos)?; // Reset the internal state self.base_pck_rdr.update_after_seek(); return Ok(r); @@ -912,14 +911,14 @@ impl PacketReader { macro_rules! found { ($pos:expr) => {{ // println!("found: {}", $pos); - tri!(self.rdr.seek(SeekFrom::Start($pos))); + self.rdr.seek(SeekFrom::Start($pos))?; self.base_pck_rdr.update_after_seek(); return Ok(true); }}; } macro_rules! bt { ($e:expr) => {{ - match tri!($e) { + match $e? { Some(s) => s, None => return Ok(false), } @@ -965,7 +964,7 @@ impl PacketReader { let mut pg; let mut continued_pck_start = None; loop { - pos = tri!(self.rdr.seek(SeekFrom::Current(0))); + pos = self.rdr.seek(SeekFrom::Current(0))?; pg = bt!(self.read_ogg_page()); /*println!("absgp {} serial {} wh {} pe {} @ {}", pg.0.bi.absgp, pg.0.bi.sequence_num, @@ -1007,7 +1006,7 @@ impl PacketReader { // First, find initial "boundaries" // Seek to the start of the file to get the starting boundary - tri!(self.rdr.seek(SeekFrom::Start(0))); + self.rdr.seek(SeekFrom::Start(0))?; let (mut begin_pos, mut begin_pg) = pg_read_match_serial!(); // If the goal is the beginning, we are done. @@ -1019,7 +1018,7 @@ impl PacketReader { // Seek to the end of the file to get the ending boundary // TODO the 200 KB is just a guessed number, any ideas // to improve it? - tri!(seek_before_end(&mut self.rdr, 200 * 1024)); + seek_before_end(&mut self.rdr, 200 * 1024)?; let (mut end_pos, mut end_pg) = pg_read_until_end_or_goal!(pos_goal); // Then perform the bisection @@ -1031,7 +1030,7 @@ impl PacketReader { } // Perform the bisection step let pos_to_seek = begin_pos + (end_pos - begin_pos) / 2; - tri!(self.rdr.seek(SeekFrom::Start(pos_to_seek))); + self.rdr.seek(SeekFrom::Start(pos_to_seek))?; let (pos, pg) = pg_read_match_serial!(); /*println!("seek {} {} . {} @ {} {} . {}", ab_of(&begin_pg), ab_of(&end_pg), ab_of(&pg), @@ -1045,9 +1044,9 @@ impl PacketReader { let mut pos; let mut pg; let mut last_packet_end_pos = begin_pos; - tri!(self.rdr.seek(SeekFrom::Start(begin_pos))); + self.rdr.seek(SeekFrom::Start(begin_pos))?; loop { - pos = tri!(self.rdr.stream_position()); + pos = self.rdr.stream_position()?; pg = bt!(self.read_ogg_page()); /*println!("absgp {} pck_start {} whole_pck {} pck_end {} @ {} {}", ab_of(&pg), pg.has_packet_start(), pg.has_whole_packet(), @@ -1088,9 +1087,9 @@ impl PacketReader { // util function fn seek_before_end(mut rdr :T, offs :u64) -> Result { - let end_pos = tri!(rdr.seek(SeekFrom::End(0))); + let end_pos = rdr.seek(SeekFrom::End(0))?; let end_pos_to_seek = ::std::cmp::min(end_pos, offs); - return Ok(tri!(rdr.seek(SeekFrom::End(-(end_pos_to_seek as i64))))); + return Ok(rdr.seek(SeekFrom::End(-(end_pos_to_seek as i64)))?); } #[cfg(feature = "async")] diff --git a/src/writing.rs b/src/writing.rs index 01c8703..809b9c2 100644 --- a/src/writing.rs +++ b/src/writing.rs @@ -166,13 +166,13 @@ impl <'writer, T :io::Write> PacketWriter<'writer, T> { if segment_i + 1 < needed_segments { // We have to flush a page, but we know there are more to come... pg.pck_this_overflow_idx = Some((segment_i + 1) * 255); - tri!(PacketWriter::write_page(&mut self.wtr, serial, pg, - false)); + PacketWriter::write_page(&mut self.wtr, serial, pg, + false)?; } else { // We have to write a page end, and it's the very last // we need to write - tri!(PacketWriter::write_page(&mut self.wtr, - serial, pg, is_end_stream)); + PacketWriter::write_page(&mut self.wtr, + serial, pg, is_end_stream)?; // Not actually required // (it is always None except if we set it to Some directly // before we call write_page) @@ -185,8 +185,8 @@ impl <'writer, T :io::Write> PacketWriter<'writer, T> { } if (inf != PacketWriteEndInfo::NormalPacket) && !at_page_end { // Write a page end - tri!(PacketWriter::write_page(&mut self.wtr, serial, pg, - is_end_stream)); + PacketWriter::write_page(&mut self.wtr, serial, pg, + is_end_stream)?; pg.pck_last_overflow_idx = None; @@ -202,13 +202,13 @@ impl <'writer, T :io::Write> PacketWriter<'writer, T> { { // The page header with everything but the lacing values: let mut hdr_cur = Cursor::new(Vec::with_capacity(27)); - tri!(hdr_cur.write_all(&[0x4f, 0x67, 0x67, 0x53, 0x00])); + hdr_cur.write_all(&[0x4f, 0x67, 0x67, 0x53, 0x00])?; let mut flags :u8 = 0; if pg.pck_last_overflow_idx.is_some() { flags |= 0x01; } if pg.first_page { flags |= 0x02; } if last_page { flags |= 0x04; } - tri!(hdr_cur.write_u8(flags)); + hdr_cur.write_u8(flags)?; let pck_data = &pg.cur_pg_data; @@ -220,14 +220,13 @@ impl <'writer, T :io::Write> PacketWriter<'writer, T> { } } - tri!(hdr_cur.write_u64::(last_finishing_pck_absgp)); - tri!(hdr_cur.write_u32::(serial)); - tri!(hdr_cur.write_u32::(pg.sequence_num)); + hdr_cur.write_u64::(last_finishing_pck_absgp)?; + hdr_cur.write_u32::(serial)?; + hdr_cur.write_u32::(pg.sequence_num)?; // checksum, calculated later on :) - tri!(hdr_cur.write_u32::(0)); - - tri!(hdr_cur.write_u8(pg.segment_cnt)); + hdr_cur.write_u32::(0)?; + hdr_cur.write_u8(pg.segment_cnt)?; let mut hash_calculated :u32; @@ -256,12 +255,12 @@ impl <'writer, T :io::Write> PacketWriter<'writer, T> { // Don't do excessive checking here (that the seek // succeeded & we are at the right pos now). // It's hopefully not required. - tri!(hdr_cur.seek(SeekFrom::Start(22))); - tri!(hdr_cur.write_u32::(hash_calculated)); + hdr_cur.seek(SeekFrom::Start(22))?; + hdr_cur.write_u32::(hash_calculated)?; // Now all is done, write the stuff! - tri!(wtr.write_all(hdr_cur.get_ref())); - tri!(wtr.write_all(pg_lacing)); + wtr.write_all(hdr_cur.get_ref())?; + wtr.write_all(pg_lacing)?; for (idx, (pck, _)) in pck_data.iter().enumerate() { let mut start :usize = 0; if idx == 0 { if let Some(idx) = pg.pck_last_overflow_idx { @@ -273,7 +272,7 @@ impl <'writer, T :io::Write> PacketWriter<'writer, T> { end = idx; } } - tri!(wtr.write_all(&pck[start .. end])); + wtr.write_all(&pck[start .. end])?; } }