3 use std::io::prelude::*;
16 pub type ByteIOResult<T> = Result<T, ByteIOError>;
19 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
20 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
21 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
22 fn read_byte(&mut self) -> ByteIOResult<u8>;
23 fn peek_byte(&mut self) -> ByteIOResult<u8>;
24 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()>;
25 fn tell(&mut self) -> u64;
26 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64>;
27 fn is_eof(&mut self) -> bool;
28 fn is_seekable(&mut self) -> bool;
29 fn size(&mut self) -> i64;
33 pub struct ByteReader<'a> {
37 pub struct MemoryReader<'a> {
43 pub struct FileReader<'a> {
48 macro_rules! read_int {
49 ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
50 let mut buf = [0; $size];
51 $s.read_buf(&mut buf)?;
53 Ok((*(buf.as_ptr() as *const $inttype)).$which())
58 macro_rules! peek_int {
59 ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
60 let mut buf = [0; $size];
61 $s.peek_buf(&mut buf)?;
63 Ok((*(buf.as_ptr() as *const $inttype)).$which())
68 macro_rules! read_int_func {
69 ($s: ident, $inttype: ty, $size: expr, $which: ident) => {
70 pub fn $s(src: &[u8]) -> ByteIOResult<$inttype> {
71 if src.len() < $size { return Err(ByteIOError::ReadError); }
73 Ok((*(src.as_ptr() as *const $inttype)).$which())
79 read_int_func!(read_u16be, u16, 2, to_be);
80 read_int_func!(read_u16le, u16, 2, to_le);
81 read_int_func!(read_u32be, u32, 4, to_be);
82 read_int_func!(read_u32le, u32, 4, to_le);
83 read_int_func!(read_u64be, u64, 8, to_be);
84 read_int_func!(read_u64le, u64, 8, to_le);
86 pub fn read_u24be(src: &[u8]) -> ByteIOResult<u32> {
87 if src.len() < 3 { return Err(ByteIOError::ReadError); }
88 Ok(((src[0] as u32) << 16) | ((src[1] as u32) << 8) | (src[2] as u32))
90 pub fn read_u24le(src: &[u8]) -> ByteIOResult<u32> {
91 if src.len() < 3 { return Err(ByteIOError::ReadError); }
92 Ok(((src[2] as u32) << 16) | ((src[1] as u32) << 8) | (src[0] as u32))
95 impl<'a> ByteReader<'a> {
96 pub fn new(io: &'a mut ByteIO) -> Self { ByteReader { io: io } }
98 pub fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
102 pub fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
103 self.io.read_buf_some(buf)
106 pub fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
107 self.io.peek_buf(buf)
110 pub fn read_byte(&mut self) -> ByteIOResult<u8> {
114 pub fn peek_byte(&mut self) -> ByteIOResult<u8> {
118 pub fn read_u16be(&mut self) -> ByteIOResult<u16> {
119 read_int!(self, u16, 2, to_be)
122 pub fn peek_u16be(&mut self) -> ByteIOResult<u16> {
123 peek_int!(self, u16, 2, to_be)
126 pub fn read_u24be(&mut self) -> ByteIOResult<u32> {
127 let p16 = self.read_u16be()?;
128 let p8 = self.read_byte()?;
129 Ok(((p16 as u32) << 8) | (p8 as u32))
132 pub fn peek_u24be(&mut self) -> ByteIOResult<u32> {
133 let mut src: [u8; 3] = [0; 3];
134 self.peek_buf(&mut src)?;
135 Ok(((src[0] as u32) << 16) | ((src[1] as u32) << 8) | (src[2] as u32))
138 pub fn read_u32be(&mut self) -> ByteIOResult<u32> {
139 read_int!(self, u32, 4, to_be)
142 pub fn peek_u32be(&mut self) -> ByteIOResult<u32> {
143 peek_int!(self, u32, 4, to_be)
146 pub fn read_u64be(&mut self) -> ByteIOResult<u64> {
147 read_int!(self, u64, 8, to_be)
150 pub fn peek_u64be(&mut self) -> ByteIOResult<u64> {
151 peek_int!(self, u64, 8, to_be)
154 pub fn read_u16le(&mut self) -> ByteIOResult<u16> {
155 read_int!(self, u16, 2, to_le)
158 pub fn peek_u16le(&mut self) -> ByteIOResult<u16> {
159 peek_int!(self, u16, 2, to_le)
162 pub fn read_u24le(&mut self) -> ByteIOResult<u32> {
163 let p8 = self.read_byte()?;
164 let p16 = self.read_u16le()?;
165 Ok(((p16 as u32) << 8) | (p8 as u32))
168 pub fn peek_u24le(&mut self) -> ByteIOResult<u32> {
169 let mut src: [u8; 3] = [0; 3];
170 self.peek_buf(&mut src)?;
171 Ok((src[0] as u32) | ((src[1] as u32) << 8) | ((src[2] as u32) << 16))
174 pub fn read_u32le(&mut self) -> ByteIOResult<u32> {
175 read_int!(self, u32, 4, to_le)
178 pub fn peek_u32le(&mut self) -> ByteIOResult<u32> {
179 peek_int!(self, u32, 4, to_le)
182 pub fn read_u64le(&mut self) -> ByteIOResult<u64> {
183 read_int!(self, u64, 8, to_le)
186 pub fn peek_u64le(&mut self) -> ByteIOResult<u64> {
187 peek_int!(self, u64, 8, to_le)
190 pub fn read_skip(&mut self, len: usize) -> ByteIOResult<()> {
191 if self.io.is_seekable() {
192 self.io.seek(SeekFrom::Current(len as i64))?;
195 let mut buf : [u8; 16] = [0; 16];
197 while ssize > bref.len() {
198 self.io.read_buf(bref)?;
202 self.io.read_byte()?;
209 pub fn tell(&mut self) -> u64 {
213 pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
217 pub fn is_eof(&mut self) -> bool {
221 pub fn size(&mut self) -> i64 {
225 pub fn left(&mut self) -> i64 {
226 let size = self.io.size();
227 if size == -1 { return -1; }
228 return size - (self.io.tell() as i64)
232 impl<'a> MemoryReader<'a> {
234 pub fn new_read(buf: &'a [u8]) -> Self {
235 MemoryReader { buf: buf, size: buf.len(), pos: 0 }
238 fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
239 if pos < 0 || (pos as usize) > self.size {
240 return Err(ByteIOError::WrongRange)
242 self.pos = pos as usize;
247 impl<'a> ByteIO for MemoryReader<'a> {
248 fn read_byte(&mut self) -> ByteIOResult<u8> {
249 if self.is_eof() { return Err(ByteIOError::EOF); }
250 let res = self.buf[self.pos];
251 self.pos = self.pos + 1;
255 fn peek_byte(&mut self) -> ByteIOResult<u8> {
256 if self.is_eof() { return Err(ByteIOError::EOF); }
257 Ok(self.buf[self.pos])
260 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
261 let copy_size = if self.size - self.pos < buf.len() { self.size } else { buf.len() };
262 if copy_size == 0 { return Err(ByteIOError::EOF); }
263 for i in 0..copy_size {
264 buf[i] = self.buf[self.pos + i];
269 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
270 let read_size = self.peek_buf(buf)?;
271 if read_size < buf.len() { return Err(ByteIOError::EOF); }
272 self.pos += read_size;
276 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
277 let read_size = self.peek_buf(buf)?;
278 self.pos += read_size;
282 #[allow(unused_variables)]
283 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
284 Err(ByteIOError::NotImplemented)
287 fn tell(&mut self) -> u64 {
291 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
292 let cur_pos = self.pos as i64;
293 let cur_size = self.size as i64;
295 SeekFrom::Start(x) => self.real_seek(x as i64),
296 SeekFrom::Current(x) => self.real_seek(cur_pos + x),
297 SeekFrom::End(x) => self.real_seek(cur_size + x),
301 fn is_eof(&mut self) -> bool {
302 self.pos >= self.size
305 fn is_seekable(&mut self) -> bool {
309 fn size(&mut self) -> i64 {
310 self.buf.len() as i64
314 impl<'a> FileReader<'a> {
316 pub fn new_read(file: &'a mut File) -> Self {
317 FileReader { file: file, eof : false }
321 impl<'a> ByteIO for FileReader<'a> {
322 fn read_byte(&mut self) -> ByteIOResult<u8> {
323 let mut byte : [u8; 1] = [0];
324 let err = self.file.read(&mut byte);
325 if let Err(_) = err { return Err(ByteIOError::ReadError); }
326 let sz = err.unwrap();
327 if sz == 0 { self.eof = true; return Err(ByteIOError::EOF); }
331 fn peek_byte(&mut self) -> ByteIOResult<u8> {
332 let b = self.read_byte()?;
333 self.seek(SeekFrom::Current(-1))?;
337 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
338 let res = self.file.read(buf);
339 if let Err(_) = res { return Err(ByteIOError::ReadError); }
340 let sz = res.unwrap();
341 if sz < buf.len() { self.eof = true; return Err(ByteIOError::EOF); }
345 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
346 let res = self.file.read(buf);
347 if let Err(_) = res { return Err(ByteIOError::ReadError); }
348 let sz = res.unwrap();
349 if sz < buf.len() { self.eof = true; }
353 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
354 let size = self.read_buf(buf)?;
355 self.seek(SeekFrom::Current(-(size as i64)))?;
359 #[allow(unused_variables)]
360 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
361 Err(ByteIOError::NotImplemented)
364 fn tell(&mut self) -> u64 {
365 self.file.seek(SeekFrom::Current(0)).unwrap()
368 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
369 let res = self.file.seek(pos);
372 Err(_) => Err(ByteIOError::SeekError),
376 fn is_eof(&mut self) -> bool {
380 fn is_seekable(&mut self) -> bool {
384 fn size(&mut self) -> i64 {
390 pub struct ByteWriter<'a> {
394 pub struct MemoryWriter<'a> {
400 pub struct FileWriter {
404 impl<'a> ByteWriter<'a> {
405 pub fn new(io: &'a mut ByteIO) -> Self { ByteWriter { io: io } }
407 pub fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
408 self.io.write_buf(buf)
411 pub fn write_byte(&mut self, val: u8) -> ByteIOResult<()> {
412 let buf: [u8; 1] = [val];
413 self.io.write_buf(&buf)
416 pub fn write_u16be(&mut self, val: u16) -> ByteIOResult<()> {
417 let buf: [u8; 2] = [((val >> 8) & 0xFF) as u8, (val & 0xFF) as u8];
418 self.io.write_buf(&buf)
421 pub fn write_u16le(&mut self, val: u16) -> ByteIOResult<()> {
422 let buf: [u8; 2] = [(val & 0xFF) as u8, ((val >> 8) & 0xFF) as u8];
423 self.io.write_buf(&buf)
426 pub fn write_u24be(&mut self, val: u32) -> ByteIOResult<()> {
427 let buf: [u8; 3] = [((val >> 16) & 0xFF) as u8, ((val >> 8) & 0xFF) as u8, (val & 0xFF) as u8];
431 pub fn write_u24le(&mut self, val: u32) -> ByteIOResult<()> {
432 let buf: [u8; 3] = [(val & 0xFF) as u8, ((val >> 8) & 0xFF) as u8, ((val >> 16) & 0xFF) as u8];
436 pub fn write_u32be(&mut self, val: u32) -> ByteIOResult<()> {
437 self.write_u16be(((val >> 16) & 0xFFFF) as u16)?;
438 self.write_u16be((val & 0xFFFF) as u16)
441 pub fn write_u32le(&mut self, val: u32) -> ByteIOResult<()> {
442 self.write_u16le((val & 0xFFFF) as u16)?;
443 self.write_u16le(((val >> 16) & 0xFFFF) as u16)
446 pub fn write_u64be(&mut self, val: u64) -> ByteIOResult<()> {
447 self.write_u32be(((val >> 32) & 0xFFFFFFFF) as u32)?;
448 self.write_u32be((val & 0xFFFFFFFF) as u32)
451 pub fn write_u64le(&mut self, val: u64) -> ByteIOResult<()> {
452 self.write_u32le((val & 0xFFFFFFFF) as u32)?;
453 self.write_u32le(((val >> 32) & 0xFFFFFFFF) as u32)
456 pub fn tell(&mut self) -> u64 {
460 pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
464 pub fn size_left(&mut self) -> i64 {
465 let sz = self.io.size();
466 if sz == -1 { return -1; }
467 sz - (self.tell() as i64)
471 impl<'a> MemoryWriter<'a> {
473 pub fn new_write(buf: &'a mut [u8]) -> Self {
475 MemoryWriter { buf: buf, size: len, pos: 0 }
478 fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
479 if pos < 0 || (pos as usize) > self.size {
480 return Err(ByteIOError::WrongRange)
482 self.pos = pos as usize;
487 impl<'a> ByteIO for MemoryWriter<'a> {
488 #[allow(unused_variables)]
489 fn read_byte(&mut self) -> ByteIOResult<u8> {
490 Err(ByteIOError::NotImplemented)
493 #[allow(unused_variables)]
494 fn peek_byte(&mut self) -> ByteIOResult<u8> {
495 Err(ByteIOError::NotImplemented)
498 #[allow(unused_variables)]
499 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
500 Err(ByteIOError::NotImplemented)
503 #[allow(unused_variables)]
504 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
505 Err(ByteIOError::NotImplemented)
508 #[allow(unused_variables)]
509 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
510 Err(ByteIOError::NotImplemented)
513 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
514 if self.pos + buf.len() > self.size { return Err(ByteIOError::WriteError); }
515 for i in 0..buf.len() {
516 self.buf[self.pos + i] = buf[i];
518 self.pos += buf.len();
522 fn tell(&mut self) -> u64 {
526 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
527 let cur_pos = self.pos as i64;
528 let cur_size = self.size as i64;
530 SeekFrom::Start(x) => self.real_seek(x as i64),
531 SeekFrom::Current(x) => self.real_seek(cur_pos + x),
532 SeekFrom::End(x) => self.real_seek(cur_size + x),
536 fn is_eof(&mut self) -> bool {
537 self.pos >= self.size
540 fn is_seekable(&mut self) -> bool {
544 fn size(&mut self) -> i64 {
545 self.buf.len() as i64
550 pub fn new_write(file: File) -> Self {
551 FileWriter { file: file }
555 impl ByteIO for FileWriter {
556 #[allow(unused_variables)]
557 fn read_byte(&mut self) -> ByteIOResult<u8> {
558 Err(ByteIOError::NotImplemented)
561 #[allow(unused_variables)]
562 fn peek_byte(&mut self) -> ByteIOResult<u8> {
563 Err(ByteIOError::NotImplemented)
566 #[allow(unused_variables)]
567 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
568 Err(ByteIOError::NotImplemented)
571 #[allow(unused_variables)]
572 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
573 Err(ByteIOError::NotImplemented)
576 #[allow(unused_variables)]
577 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
578 Err(ByteIOError::NotImplemented)
581 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
582 match self.file.write_all(buf) {
584 Err(_) => Err(ByteIOError::WriteError),
588 fn tell(&mut self) -> u64 {
589 self.file.seek(SeekFrom::Current(0)).unwrap()
592 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
593 let res = self.file.seek(pos);
596 Err(_) => Err(ByteIOError::SeekError),
600 fn is_eof(&mut self) -> bool {
604 fn is_seekable(&mut self) -> bool {
608 fn size(&mut self) -> i64 {
620 //const DATA : &'static [u8] = include_bytes!("../../assets/file");
621 let buf: [u8; 64] = [1; 64];
622 let mut mr = MemoryReader::new_read(&buf);
623 let mut reader = ByteReader::new(&mut mr);
624 assert_eq!(reader.read_byte().unwrap(), 0x01u8);
625 assert_eq!(reader.read_u16le().unwrap(), 0x0101u16);
626 assert_eq!(reader.read_u24le().unwrap(), 0x010101u32);
627 assert_eq!(reader.read_u32le().unwrap(), 0x01010101u32);
628 assert_eq!(reader.read_u64le().unwrap(), 0x0101010101010101u64);
629 let mut file = File::open("assets/Misc/MaoMacha.asx").unwrap();
630 let mut fr = FileReader::new_read(&mut file);
631 let mut br2 = ByteReader::new(&mut fr);
632 assert_eq!(br2.read_byte().unwrap(), 0x30);
633 assert_eq!(br2.read_u24be().unwrap(), 0x26B275);
634 assert_eq!(br2.read_u24le().unwrap(), 0xCF668E);
635 assert_eq!(br2.read_u32be().unwrap(), 0x11A6D900);
636 assert_eq!(br2.read_u32le().unwrap(), 0xCE6200AA);
640 let mut buf: [u8; 64] = [0; 64];
642 let mut mw = MemoryWriter::new_write(&mut buf);
643 let mut bw = ByteWriter::new(&mut mw);
644 bw.write_byte(0x00).unwrap();
645 bw.write_u16be(0x0102).unwrap();
646 bw.write_u24be(0x030405).unwrap();
647 bw.write_u32be(0x06070809).unwrap();
648 bw.write_u64be(0x0A0B0C0D0E0F1011).unwrap();
649 bw.write_byte(0x00).unwrap();
650 bw.write_u16le(0x0201).unwrap();
651 bw.write_u24le(0x050403).unwrap();
652 bw.write_u32le(0x09080706).unwrap();
653 bw.write_u64le(0x11100F0E0D0C0B0A).unwrap();
654 assert_eq!(bw.size_left(), 28);
657 assert_eq!(buf[(i + 0x00) as usize], i);
658 assert_eq!(buf[(i + 0x12) as usize], i);