nihav-core/src/io/byteio.rs

   1 //! Bytestream reading/writing functionality.
   2 pub use std::io::SeekFrom;
   3 use std::io::prelude::*;
   4 use std::ptr;
   5
   6 /// A list specifying general bytestream reading and writing errors.
   7 #[derive(Debug)]
   8 pub enum ByteIOError {
   9     /// End of stream.
  10     EOF,
  11     /// Wrong seek position was provided.
  12     WrongRange,
  13     /// Tried to call read() on bytestream writer or write() on bytestream reader.
  14     WrongIOMode,
  15     /// Functionality is not implemented.
  16     NotImplemented,
  17     /// Read error.
  18     ReadError,
  19     /// Write error.
  20     WriteError,
  21     /// Seeking failed.
  22     SeekError,
  23 }
  24
  25 /// A specialised `Result` type for bytestream operations.
  26 pub type ByteIOResult<T> = Result<T, ByteIOError>;
  27
  28 /// Common trait for bytestream operations.
  29 pub trait ByteIO {
  30     /// Reads data into provided buffer. Fails if it cannot fill whole buffer.
  31     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
  32     /// Reads data into provided buffer. Partial read is treated as success.
  33     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
  34     /// Reads data into provided buffer but does not advance read position.
  35     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
  36     /// Reads single byte from the stream.
  37     fn read_byte(&mut self) -> ByteIOResult<u8>;
  38     /// Returns the next byte value in the stream without advancing read position.
  39     fn peek_byte(&mut self) -> ByteIOResult<u8>;
  40     /// Writes buffer to the stream.
  41     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()>;
  42     /// Returns current read or write position.
  43     fn tell(&mut self) -> u64;
  44     /// Seeks to the provided position.
  45     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64>;
  46     /// Tells whether this is end of stream.
  47     fn is_eof(&self) -> bool;
  48     /// Reports whether stream is seekable or not.
  49     fn is_seekable(&mut self) -> bool;
  50     /// Returns stream size or -1 if it is not known.
  51     fn size(&mut self) -> i64;
  52 }
  53
  54 /// High-level bytestream reader.
  55 ///
  56 /// User is supposed to create some reader implementing [`ByteIO`] trait e.g. [`MemoryReader`] and use it to create `ByteReader` which can be used for reading e.g. various integer types.
  57 ///
  58 /// # Examples
  59 ///
  60 /// ````
  61 /// use nihav_core::io::byteio::{MemoryReader,ByteReader};
  62 /// # use nihav_core::io::byteio::ByteIOResult;
  63 ///
  64 /// # fn foo() -> ByteIOResult<()> {
  65 /// let memory: [u8; 4] = [ 0, 42, 42, 0 ];
  66 /// let mut mr = MemoryReader::new_read(&memory);
  67 /// let mut br = ByteReader::new(&mut mr);
  68 /// let val = br.read_u16be()?; // read 16-bit big-endian integer, should be 42
  69 /// let val = br.read_u16le()?; // read 16-bit little-endian integer, should be 42 as well
  70 /// # Ok(())
  71 /// # }
  72 /// ````
  73 ///
  74 /// [`ByteIO`]: ./trait.ByteIO.html
  75 /// [`MemoryReader`]: ./struct.MemoryReader.html
  76 #[allow(dead_code)]
  77 pub struct ByteReader<'a> {
  78     io: &'a mut dyn ByteIO,
  79 }
  80
  81 /// Bytestream reader from memory.
  82 pub struct MemoryReader<'a> {
  83     buf:      &'a [u8],
  84     pos:      usize,
  85 }
  86
  87 /// Bytestream reader from anything implementing `std::io::Read` and `std::io::Seek`.
  88 pub struct FileReader<T: Read+Seek> {
  89     file:     Box<T>,
  90     eof:      bool,
  91 }
  92
  93 macro_rules! read_int {
  94     ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
  95         unsafe {
  96             let mut buf: $inttype = 0;
  97             $s.read_buf(&mut *(&mut buf as *mut $inttype as *mut [u8; $size]))?;
  98             Ok(buf.$which())
  99         }
 100     })
 101 }
 102
 103 macro_rules! peek_int {
 104     ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
 105         unsafe {
 106             let mut buf: $inttype = 0;
 107             $s.peek_buf(&mut *(&mut buf as *mut $inttype as *mut [u8; $size]))?;
 108             Ok(buf.$which())
 109         }
 110     })
 111 }
 112
 113 macro_rules! read_int_func {
 114     ($s: ident, $inttype: ty, $size: expr, $which: ident) => {
 115 /// Reads integer of certain size and endianness.
 116         pub fn $s(src: &[u8]) -> ByteIOResult<$inttype> {
 117             if src.len() < $size { return Err(ByteIOError::ReadError); }
 118             unsafe {
 119                 let mut buf: $inttype = 0;
 120                 ptr::copy_nonoverlapping(src.as_ptr(), &mut buf as *mut $inttype as *mut u8, std::mem::size_of::<$inttype>());
 121                 Ok(buf.$which())
 122             }
 123         }
 124     }
 125 }
 126
 127 read_int_func!(read_u16be, u16, 2, to_be);
 128 read_int_func!(read_u16le, u16, 2, to_le);
 129 read_int_func!(read_u32be, u32, 4, to_be);
 130 read_int_func!(read_u32le, u32, 4, to_le);
 131 read_int_func!(read_u64be, u64, 8, to_be);
 132 read_int_func!(read_u64le, u64, 8, to_le);
 133
 134 /// Reads 24-bit big-endian integer.
 135 ///
 136 /// # Example
 137 ///
 138 /// ````
 139 /// use nihav_core::io::byteio::read_u24be;
 140 /// # use nihav_core::io::byteio::ByteIOResult;
 141 ///
 142 /// # fn foo() -> ByteIOResult<()> {
 143 /// let src: [u8; 3] = [ 1, 2, 3];
 144 /// let value = read_u24be(&src)?; // should return 0x010203
 145 /// # Ok(())
 146 /// # }
 147 /// ````
 148 pub fn read_u24be(src: &[u8]) -> ByteIOResult<u32> {
 149     if src.len() < 3 { return Err(ByteIOError::ReadError); }
 150     Ok((u32::from(src[0]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[2]))
 151 }
 152 /// Reads 24-bit little-endian integer.
 153 pub fn read_u24le(src: &[u8]) -> ByteIOResult<u32> {
 154     if src.len() < 3 { return Err(ByteIOError::ReadError); }
 155     Ok((u32::from(src[2]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[0]))
 156 }
 157 /// Reads 32-bit big-endian floating point number.
 158 pub fn read_f32be(src: &[u8]) -> ByteIOResult<f32> { Ok(f32::from_bits(read_u32be(src)?)) }
 159 /// Reads 32-bit little-endian floating point number.
 160 pub fn read_f32le(src: &[u8]) -> ByteIOResult<f32> { Ok(f32::from_bits(read_u32le(src)?)) }
 161 /// Reads 64-bit big-endian floating point number.
 162 pub fn read_f64be(src: &[u8]) -> ByteIOResult<f64> { Ok(f64::from_bits(read_u64be(src)?)) }
 163 /// Reads 64-bit little-endian floating point number.
 164 pub fn read_f64le(src: &[u8]) -> ByteIOResult<f64> { Ok(f64::from_bits(read_u64le(src)?)) }
 165
 166 macro_rules! write_int_func {
 167     ($s: ident, $inttype: ty, $size: expr, $which: ident) => {
 168 /// Writes integer of certain size and endianness into byte buffer.
 169         pub fn $s(dst: &mut [u8], val: $inttype) -> ByteIOResult<()> {
 170             if dst.len() < $size { return Err(ByteIOError::WriteError); }
 171             unsafe {
 172                 let val = val.$which();
 173                 ptr::copy_nonoverlapping(&val as *const $inttype as *const u8, dst.as_mut_ptr(), std::mem::size_of::<$inttype>());
 174             }
 175             Ok(())
 176         }
 177     }
 178 }
 179
 180 write_int_func!(write_u16be, u16, 2, to_be);
 181 write_int_func!(write_u16le, u16, 2, to_le);
 182 write_int_func!(write_u32be, u32, 4, to_be);
 183 write_int_func!(write_u32le, u32, 4, to_le);
 184 write_int_func!(write_u64be, u64, 8, to_be);
 185 write_int_func!(write_u64le, u64, 8, to_le);
 186
 187 /// Writes 24-bit big-endian integer to the provided buffer.
 188 ///
 189 /// # Example
 190 ///
 191 /// ````
 192 /// use nihav_core::io::byteio::write_u24be;
 193 /// # use nihav_core::io::byteio::ByteIOResult;
 194 ///
 195 /// # fn foo() -> ByteIOResult<()> {
 196 /// let mut dst = [0u8; 3];
 197 /// write_u24be(&mut dst, 0x010203)?;
 198 /// // dst should contain [ 1, 2, 3] now
 199 /// # Ok(())
 200 /// # }
 201 /// ````
 202 #[allow(clippy::identity_op)]
 203 pub fn write_u24be(dst: &mut [u8], val: u32) -> ByteIOResult<()> {
 204     if dst.len() < 3 { return Err(ByteIOError::WriteError); }
 205     dst[0] = (val >> 16) as u8;
 206     dst[1] = (val >>  8) as u8;
 207     dst[2] = (val >>  0) as u8;
 208     Ok(())
 209 }
 210 /// Writes 24-bit little-endian integer to the provided buffer.
 211 #[allow(clippy::identity_op)]
 212 pub fn write_u24le(dst: &mut [u8], val: u32) -> ByteIOResult<()> {
 213     if dst.len() < 3 { return Err(ByteIOError::WriteError); }
 214     dst[0] = (val >>  0) as u8;
 215     dst[1] = (val >>  8) as u8;
 216     dst[2] = (val >> 16) as u8;
 217     Ok(())
 218 }
 219 /// Writes 32-bit big-endian floating point number to the provided buffer.
 220 pub fn write_f32be(dst: &mut [u8], val: f32) -> ByteIOResult<()> { write_u32be(dst, val.to_bits()) }
 221 /// Writes 32-bit little-endian floating point number to the provided buffer.
 222 pub fn write_f32le(dst: &mut [u8], val: f32) -> ByteIOResult<()> { write_u32le(dst, val.to_bits()) }
 223 /// Writes 64-bit big-endian floating point number to the provided buffer.
 224 pub fn write_f64be(dst: &mut [u8], val: f64) -> ByteIOResult<()> { write_u64be(dst, val.to_bits()) }
 225 /// Writes 64-bit little-endian floating point number to the provided buffer.
 226 pub fn write_f64le(dst: &mut [u8], val: f64) -> ByteIOResult<()> { write_u64le(dst, val.to_bits()) }
 227
 228 impl<'a> ByteReader<'a> {
 229     /// Constructs a new instance of bytestream reader.
 230     ///
 231     /// # Examples
 232     ///
 233     /// ````
 234     /// use nihav_core::io::byteio::{MemoryReader,ByteReader};
 235     /// # use nihav_core::io::byteio::ByteIOResult;
 236     ///
 237     /// # fn foo() -> ByteIOResult<()> {
 238     /// let memory: [u8; 4] = [ 0, 42, 42, 0 ];
 239     /// let mut mr = MemoryReader::new_read(&memory);
 240     /// let mut br = ByteReader::new(&mut mr);
 241     /// # Ok(())
 242     /// # }
 243     /// ````
 244     pub fn new(io: &'a mut dyn ByteIO) -> Self { ByteReader { io } }
 245
 246     /// Reads data into provided buffer. Partial read is treated as success.
 247     pub fn read_buf(&mut self, buf: &mut [u8])  -> ByteIOResult<usize> {
 248         self.io.read_buf(buf)
 249     }
 250
 251     /// Reads data into provided buffer. Partial read is treated as success.
 252     pub fn read_buf_some(&mut self, buf: &mut [u8])  -> ByteIOResult<usize> {
 253         self.io.read_buf_some(buf)
 254     }
 255
 256     /// Reads data into provided buffer but does not advance read position.
 257     pub fn peek_buf(&mut self, buf: &mut [u8])  -> ByteIOResult<usize> {
 258         self.io.peek_buf(buf)
 259     }
 260
 261     /// Reads single byte from the stream.
 262     pub fn read_byte(&mut self) -> ByteIOResult<u8> {
 263         self.io.read_byte()
 264     }
 265
 266     /// Returns the next byte value in the stream without advancing read position.
 267     pub fn peek_byte(&mut self) -> ByteIOResult<u8> {
 268         self.io.peek_byte()
 269     }
 270
 271     /// Reads four-byte array from the stream.
 272     pub fn read_tag(&mut self)  -> ByteIOResult<[u8; 4]> {
 273         let mut buf = [0u8; 4];
 274         self.io.read_buf(&mut buf)?;
 275         Ok(buf)
 276     }
 277
 278     /// Reads four-byte array from the stream without advancing read position.
 279     pub fn peek_tag(&mut self)  -> ByteIOResult<[u8; 4]> {
 280         let mut buf = [0u8; 4];
 281         self.io.peek_buf(&mut buf)?;
 282         Ok(buf)
 283     }
 284
 285     /// Reads 16-bit big-endian integer from the stream.
 286     pub fn read_u16be(&mut self) -> ByteIOResult<u16> {
 287         read_int!(self, u16, 2, to_be)
 288     }
 289
 290     /// Reads 16-bit big-endian integer from the stream without advancing read position.
 291     pub fn peek_u16be(&mut self) -> ByteIOResult<u16> {
 292         peek_int!(self, u16, 2, to_be)
 293     }
 294
 295     /// Reads 24-bit big-endian integer from the stream.
 296     pub fn read_u24be(&mut self) -> ByteIOResult<u32> {
 297         let p16 = self.read_u16be()?;
 298         let p8 = self.read_byte()?;
 299         Ok((u32::from(p16) << 8) | u32::from(p8))
 300     }
 301
 302     /// Reads 24-bit big-endian integer from the stream without advancing read position.
 303     pub fn peek_u24be(&mut self) -> ByteIOResult<u32> {
 304         let mut src: [u8; 3] = [0; 3];
 305         self.peek_buf(&mut src)?;
 306         Ok((u32::from(src[0]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[2]))
 307     }
 308
 309     /// Reads 32-bit big-endian integer from the stream.
 310     pub fn read_u32be(&mut self) -> ByteIOResult<u32> {
 311         read_int!(self, u32, 4, to_be)
 312     }
 313
 314     /// Reads 32-bit big-endian integer from the stream without advancing read position.
 315     pub fn peek_u32be(&mut self) -> ByteIOResult<u32> {
 316         peek_int!(self, u32, 4, to_be)
 317     }
 318
 319     /// Reads 64-bit big-endian integer from the stream.
 320     pub fn read_u64be(&mut self) -> ByteIOResult<u64> {
 321         read_int!(self, u64, 8, to_be)
 322     }
 323
 324     /// Reads 64-bit big-endian integer from the stream without advancing read position.
 325     pub fn peek_u64be(&mut self) -> ByteIOResult<u64> {
 326         peek_int!(self, u64, 8, to_be)
 327     }
 328
 329     /// Reads 32-bit big-endian floating point number from the stream.
 330     pub fn read_f32be(&mut self) -> ByteIOResult<f32> {
 331         Ok(f32::from_bits(self.read_u32be()?))
 332     }
 333
 334     /// Reads 32-bit big-endian floating point number from the stream without advancing read position.
 335     pub fn peek_f32be(&mut self) -> ByteIOResult<f32> {
 336         Ok(f32::from_bits(self.peek_u32be()?))
 337     }
 338
 339     /// Reads 64-bit big-endian floating point number from the stream.
 340     pub fn read_f64be(&mut self) -> ByteIOResult<f64> {
 341         Ok(f64::from_bits(self.read_u64be()?))
 342     }
 343
 344     /// Reads 64-bit big-endian floating point number from the stream without advancing read position.
 345     pub fn peek_f64be(&mut self) -> ByteIOResult<f64> {
 346         Ok(f64::from_bits(self.peek_u64be()?))
 347     }
 348
 349     /// Reads 16-bit little-endian integer from the stream.
 350     pub fn read_u16le(&mut self) -> ByteIOResult<u16> {
 351         read_int!(self, u16, 2, to_le)
 352     }
 353
 354     /// Reads 16-bit little-endian integer from the stream without advancing read position.
 355     pub fn peek_u16le(&mut self) -> ByteIOResult<u16> {
 356         peek_int!(self, u16, 2, to_le)
 357     }
 358
 359     /// Reads 24-bit little-endian integer from the stream.
 360     pub fn read_u24le(&mut self) -> ByteIOResult<u32> {
 361         let p8 = self.read_byte()?;
 362         let p16 = self.read_u16le()?;
 363         Ok((u32::from(p16) << 8) | u32::from(p8))
 364     }
 365
 366     /// Reads 24-bit little-endian integer from the stream without advancing read position.
 367     pub fn peek_u24le(&mut self) -> ByteIOResult<u32> {
 368         let mut src: [u8; 3] = [0; 3];
 369         self.peek_buf(&mut src)?;
 370         Ok(u32::from(src[0]) | (u32::from(src[1]) << 8) | (u32::from(src[2]) << 16))
 371     }
 372
 373     /// Reads 32-bit little-endian integer from the stream.
 374     pub fn read_u32le(&mut self) -> ByteIOResult<u32> {
 375         read_int!(self, u32, 4, to_le)
 376     }
 377
 378     /// Reads 32-bit little-endian integer from the stream without advancing read position.
 379     pub fn peek_u32le(&mut self) -> ByteIOResult<u32> {
 380         peek_int!(self, u32, 4, to_le)
 381     }
 382
 383     /// Reads 64-bit little-endian integer from the stream.
 384     pub fn read_u64le(&mut self) -> ByteIOResult<u64> {
 385         read_int!(self, u64, 8, to_le)
 386     }
 387
 388     /// Reads 64-bit little-endian integer from the stream without advancing read position.
 389     pub fn peek_u64le(&mut self) -> ByteIOResult<u64> {
 390         peek_int!(self, u64, 8, to_le)
 391     }
 392
 393     /// Reads 32-bit little-endian floating point number from the stream.
 394     pub fn read_f32le(&mut self) -> ByteIOResult<f32> {
 395         Ok(f32::from_bits(self.read_u32le()?))
 396     }
 397
 398     /// Reads 32-bit little-endian floating point number from the stream without advancing read position.
 399     pub fn peek_f32le(&mut self) -> ByteIOResult<f32> {
 400         Ok(f32::from_bits(self.peek_u32le()?))
 401     }
 402
 403     /// Reads 64-bit little-endian floating point number from the stream.
 404     pub fn read_f64le(&mut self) -> ByteIOResult<f64> {
 405         Ok(f64::from_bits(self.read_u64le()?))
 406     }
 407
 408     /// Reads 64-bit little-endian floating point number from the stream without advancing read position.
 409     pub fn peek_f64le(&mut self) -> ByteIOResult<f64> {
 410         Ok(f64::from_bits(self.peek_u64le()?))
 411     }
 412
 413     /// Skips requested number of bytes.
 414     pub fn read_skip(&mut self, len: usize) -> ByteIOResult<()> {
 415         if self.io.is_seekable() {
 416             self.io.seek(SeekFrom::Current(len as i64))?;
 417         } else {
 418             let mut ssize = len;
 419             let mut buf : [u8; 16] = [0; 16];
 420             let bref = &mut buf;
 421             while ssize > bref.len() {
 422                 self.io.read_buf(bref)?;
 423                 ssize -= bref.len();
 424             }
 425             while ssize > 0 {
 426                 self.io.read_byte()?;
 427                 ssize -= 1;
 428             }
 429         }
 430         Ok(())
 431     }
 432
 433     /// Returns current read position.
 434     pub fn tell(&mut self) -> u64 {
 435         self.io.tell()
 436     }
 437
 438     /// Seeks to the provided position.
 439     pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 440         self.io.seek(pos)
 441     }
 442
 443     /// Tells whether this is end of stream.
 444     pub fn is_eof(&self) -> bool {
 445         self.io.is_eof()
 446     }
 447
 448     /// Returns stream size or -1 if it is not known.
 449     pub fn size(&mut self) -> i64 {
 450         self.io.size()
 451     }
 452
 453     /// Reports number of bytes left in the stream.
 454     pub fn left(&mut self) -> i64 {
 455         let size = self.io.size();
 456         if size == -1 { return -1; }
 457         size - (self.io.tell() as i64)
 458     }
 459 }
 460
 461 impl<'a> MemoryReader<'a> {
 462     /// Constructs a new instance of `MemoryReader`.
 463     pub fn new_read(buf: &'a [u8]) -> Self {
 464         MemoryReader { buf, pos: 0 }
 465     }
 466
 467     fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
 468         if pos < 0 || (pos as usize) > self.buf.len() {
 469             return Err(ByteIOError::WrongRange);
 470         }
 471         self.pos = pos as usize;
 472         Ok(pos as u64)
 473     }
 474 }
 475
 476 impl<'a> ByteIO for MemoryReader<'a> {
 477     fn read_byte(&mut self) -> ByteIOResult<u8> {
 478         if self.is_eof() { return Err(ByteIOError::EOF); }
 479         let res = self.buf[self.pos];
 480         self.pos += 1;
 481         Ok(res)
 482     }
 483
 484     fn peek_byte(&mut self) -> ByteIOResult<u8> {
 485         if self.is_eof() { return Err(ByteIOError::EOF); }
 486         Ok(self.buf[self.pos])
 487     }
 488
 489     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 490         let copy_size = if self.buf.len() - self.pos < buf.len() { self.buf.len() - self.pos } else { buf.len() };
 491         if copy_size == 0 { return Err(ByteIOError::EOF); }
 492         let dst = &mut buf[0..copy_size];
 493         dst.copy_from_slice(&self.buf[self.pos..][..copy_size]);
 494         Ok(copy_size)
 495     }
 496
 497     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 498         let read_size = self.peek_buf(buf)?;
 499         if read_size < buf.len() { return Err(ByteIOError::EOF); }
 500         self.pos += read_size;
 501         Ok(read_size)
 502     }
 503
 504     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 505         let read_size = self.peek_buf(buf)?;
 506         self.pos += read_size;
 507         Ok(read_size)
 508     }
 509
 510     #[allow(unused_variables)]
 511     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
 512         Err(ByteIOError::NotImplemented)
 513     }
 514
 515     fn tell(&mut self) -> u64 {
 516         self.pos as u64
 517     }
 518
 519     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 520         let cur_pos  = self.pos       as i64;
 521         let cur_size = self.buf.len() as i64;
 522         match pos {
 523             SeekFrom::Start(x)   => self.real_seek(x as i64),
 524             SeekFrom::Current(x) => self.real_seek(cur_pos + x),
 525             SeekFrom::End(x)     => self.real_seek(cur_size + x),
 526         }
 527     }
 528
 529     fn is_eof(&self) -> bool {
 530         self.pos >= self.buf.len()
 531     }
 532
 533     fn is_seekable(&mut self) -> bool {
 534         true
 535     }
 536
 537     fn size(&mut self) -> i64 {
 538         self.buf.len() as i64
 539     }
 540 }
 541
 542 impl<T: Read+Seek> FileReader<T> {
 543
 544     /// Constructs a new instance of `FileReader`.
 545     pub fn new_read(file: T) -> Self {
 546         FileReader { file: Box::new(file), eof : false }
 547     }
 548 }
 549
 550 impl<T: Read+Seek> ByteIO for FileReader<T> {
 551     fn read_byte(&mut self) -> ByteIOResult<u8> {
 552         let mut byte : [u8; 1] = [0];
 553         let ret = self.file.read(&mut byte);
 554         if ret.is_err() { return Err(ByteIOError::ReadError); }
 555         let sz = ret.unwrap();
 556         if sz == 0 { self.eof = true; return Err(ByteIOError::EOF); }
 557         Ok (byte[0])
 558     }
 559
 560     fn peek_byte(&mut self) -> ByteIOResult<u8> {
 561         let b = self.read_byte()?;
 562         self.seek(SeekFrom::Current(-1))?;
 563         Ok(b)
 564     }
 565
 566     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 567         let ret = self.file.read(buf);
 568         if ret.is_err() { return Err(ByteIOError::ReadError); }
 569         let sz = ret.unwrap();
 570         if sz < buf.len() { self.eof = true; return Err(ByteIOError::EOF); }
 571         Ok(sz)
 572     }
 573
 574     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 575         let ret = self.file.read(buf);
 576         if ret.is_err() { return Err(ByteIOError::ReadError); }
 577         let sz = ret.unwrap();
 578         if sz < buf.len() { self.eof = true; }
 579         Ok(sz)
 580     }
 581
 582     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 583         let size = self.read_buf(buf)?;
 584         self.seek(SeekFrom::Current(-(size as i64)))?;
 585         Ok(size)
 586     }
 587
 588     #[allow(unused_variables)]
 589     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
 590         Err(ByteIOError::NotImplemented)
 591     }
 592
 593     fn tell(&mut self) -> u64 {
 594         self.file.seek(SeekFrom::Current(0)).unwrap()
 595     }
 596
 597     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 598         let res = self.file.seek(pos);
 599         match res {
 600             Ok(r) => Ok(r),
 601             Err(_) => Err(ByteIOError::SeekError),
 602         }
 603     }
 604
 605     fn is_eof(&self) -> bool {
 606         self.eof
 607     }
 608
 609     fn is_seekable(&mut self) -> bool {
 610         true
 611     }
 612
 613     fn size(&mut self) -> i64 {
 614         -1
 615     }
 616 }
 617
 618 /// High-level bytestream writer.
 619 ///
 620 /// User is supposed to create some writer implementing [`ByteIO`] trait e.g. [`MemoryWriter`] and use it to create `ByteWriter` which can be used for writing e.g. various integer types.
 621 ///
 622 /// # Examples
 623 ///
 624 /// ````
 625 /// use nihav_core::io::byteio::{MemoryWriter,ByteWriter};
 626 /// # use nihav_core::io::byteio::ByteIOResult;
 627 ///
 628 /// # fn foo() -> ByteIOResult<()> {
 629 /// let mut memory = [0u8; 4];
 630 /// let mut mw = MemoryWriter::new_write(&mut memory);
 631 /// let mut bw = ByteWriter::new(&mut mw);
 632 /// let val = bw.write_u16be(42)?; // memory should be [ 0, 42, 0, 0 ]
 633 /// let val = bw.write_u16le(42)?; // memory should be [ 0, 42, 42, 0 ]
 634 /// # Ok(())
 635 /// # }
 636 /// ````
 637 ///
 638 /// [`ByteIO`]: ./trait.ByteIO.html
 639 /// [`MemoryWriter`]: ./struct.MemoryWriter.html
 640 #[allow(dead_code)]
 641 pub struct ByteWriter<'a> {
 642     io: &'a mut dyn ByteIO,
 643 }
 644
 645 /// Bytestream writer to memory.
 646 pub struct MemoryWriter<'a> {
 647     buf:      &'a mut [u8],
 648     pos:      usize,
 649 }
 650
 651 /// Bytestream writer to anything implementing `std::io::Write` and `std::io::Seek`.
 652 pub struct FileWriter<T: Write+Seek> {
 653     file:     Box<T>,
 654 }
 655
 656 /// Bytestream writer to memory.
 657 ///
 658 /// Unlike [`MemoryWriter`] which writes to an array of fixed size, `GrowableMemoryWriter` grows output size when output size exceeds capacity.
 659 ///
 660 /// [`MemoryWriter`]: ./struct.MemoryWriter.html
 661 pub struct GrowableMemoryWriter<'a> {
 662     buf:    &'a mut Vec<u8>,
 663     pos:    usize,
 664 }
 665
 666 impl<'a> ByteWriter<'a> {
 667     /// Constructs a new instance of `ByteWriter`.
 668     pub fn new(io: &'a mut dyn ByteIO) -> Self { ByteWriter { io } }
 669
 670     /// Writes byte array to the output.
 671     pub fn write_buf(&mut self, buf: &[u8])  -> ByteIOResult<()> {
 672         self.io.write_buf(buf)
 673     }
 674
 675     /// Writes single byte to the output.
 676     pub fn write_byte(&mut self, val: u8) -> ByteIOResult<()> {
 677         let buf: [u8; 1] = [val];
 678         self.io.write_buf(&buf)
 679     }
 680
 681     /// Writes 16-bit big-endian integer to the output.
 682     pub fn write_u16be(&mut self, val: u16) -> ByteIOResult<()> {
 683         let buf: [u8; 2] = [((val >> 8) & 0xFF) as u8, (val & 0xFF) as u8];
 684         self.io.write_buf(&buf)
 685     }
 686
 687     /// Writes 16-bit little-endian integer to the output.
 688     pub fn write_u16le(&mut self, val: u16) -> ByteIOResult<()> {
 689         let buf: [u8; 2] = [(val & 0xFF) as u8, ((val >> 8) & 0xFF) as u8];
 690         self.io.write_buf(&buf)
 691     }
 692
 693     /// Writes 24-bit big-endian integer to the output.
 694     pub fn write_u24be(&mut self, val: u32) -> ByteIOResult<()> {
 695         let buf: [u8; 3] = [((val >> 16) & 0xFF) as u8, ((val >> 8) & 0xFF) as u8, (val & 0xFF) as u8];
 696         self.write_buf(&buf)
 697     }
 698
 699     /// Writes 24-bit little-endian integer to the output.
 700     pub fn write_u24le(&mut self, val: u32) -> ByteIOResult<()> {
 701         let buf: [u8; 3] = [(val & 0xFF) as u8, ((val >> 8) & 0xFF) as u8, ((val >> 16) & 0xFF) as u8];
 702         self.write_buf(&buf)
 703     }
 704
 705     /// Writes 32-bit big-endian integer to the output.
 706     pub fn write_u32be(&mut self, val: u32) -> ByteIOResult<()> {
 707         self.write_u16be(((val >> 16) & 0xFFFF) as u16)?;
 708         self.write_u16be((val & 0xFFFF) as u16)
 709     }
 710
 711     /// Writes 32-bit little-endian integer to the output.
 712     pub fn write_u32le(&mut self, val: u32) -> ByteIOResult<()> {
 713         self.write_u16le((val & 0xFFFF) as u16)?;
 714         self.write_u16le(((val >> 16) & 0xFFFF) as u16)
 715     }
 716
 717     /// Writes 64-bit big-endian integer to the output.
 718     pub fn write_u64be(&mut self, val: u64) -> ByteIOResult<()> {
 719         self.write_u32be((val >> 32) as u32)?;
 720         self.write_u32be(val as u32)
 721     }
 722
 723     /// Writes 64-bit little-endian integer to the output.
 724     pub fn write_u64le(&mut self, val: u64) -> ByteIOResult<()> {
 725         self.write_u32le(val as u32)?;
 726         self.write_u32le((val >> 32) as u32)
 727     }
 728
 729     /// Writes 32-bit big-endian floating point number to the output.
 730     pub fn write_f32be(&mut self, val: f32) -> ByteIOResult<()> {
 731         self.write_u32be(val.to_bits())
 732     }
 733
 734     /// Writes 32-bit little-endian floating point number to the output.
 735     pub fn write_f32le(&mut self, val: f32) -> ByteIOResult<()> {
 736         self.write_u32le(val.to_bits())
 737     }
 738
 739     /// Writes 64-bit big-endian floating point number to the output.
 740     pub fn write_f64be(&mut self, val: f64) -> ByteIOResult<()> {
 741         self.write_u64be(val.to_bits())
 742     }
 743
 744     /// Writes 64-bit little-endian floating point number to the output.
 745     pub fn write_f64le(&mut self, val: f64) -> ByteIOResult<()> {
 746         self.write_u64le(val.to_bits())
 747     }
 748
 749     /// Reports the current write position.
 750     pub fn tell(&mut self) -> u64 {
 751         self.io.tell()
 752     }
 753
 754     /// Seeks to the requested position.
 755     pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 756         self.io.seek(pos)
 757     }
 758
 759     /// Reports the amount of bytes the writer can still write (-1 if unknown).
 760     pub fn size_left(&mut self) -> i64 {
 761         let sz = self.io.size();
 762         if sz == -1 { return -1; }
 763         sz - (self.tell() as i64)
 764     }
 765 }
 766
 767 impl<'a> MemoryWriter<'a> {
 768
 769     /// Constructs a new instance of `MemoryWriter`.
 770     pub fn new_write(buf: &'a mut [u8]) -> Self {
 771         MemoryWriter { buf, pos: 0 }
 772     }
 773
 774     fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
 775         if pos < 0 || (pos as usize) > self.buf.len() {
 776             return Err(ByteIOError::WrongRange)
 777         }
 778         self.pos = pos as usize;
 779         Ok(pos as u64)
 780     }
 781 }
 782
 783 impl<'a> ByteIO for MemoryWriter<'a> {
 784     #[allow(unused_variables)]
 785     fn read_byte(&mut self) -> ByteIOResult<u8> {
 786         Err(ByteIOError::NotImplemented)
 787     }
 788
 789     #[allow(unused_variables)]
 790     fn peek_byte(&mut self) -> ByteIOResult<u8> {
 791         Err(ByteIOError::NotImplemented)
 792     }
 793
 794     #[allow(unused_variables)]
 795     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 796         Err(ByteIOError::NotImplemented)
 797     }
 798
 799     #[allow(unused_variables)]
 800     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 801         Err(ByteIOError::NotImplemented)
 802     }
 803
 804     #[allow(unused_variables)]
 805     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 806         Err(ByteIOError::NotImplemented)
 807     }
 808
 809     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
 810         if self.pos + buf.len() > self.buf.len() { return Err(ByteIOError::WriteError); }
 811         self.buf[self.pos..][..buf.len()].copy_from_slice(buf);
 812         self.pos += buf.len();
 813         Ok(())
 814     }
 815
 816     fn tell(&mut self) -> u64 {
 817         self.pos as u64
 818     }
 819
 820     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 821         let cur_pos  = self.pos       as i64;
 822         let cur_size = self.buf.len() as i64;
 823         match pos {
 824             SeekFrom::Start(x)   => self.real_seek(x as i64),
 825             SeekFrom::Current(x) => self.real_seek(cur_pos + x),
 826             SeekFrom::End(x)     => self.real_seek(cur_size + x),
 827         }
 828     }
 829
 830     fn is_eof(&self) -> bool {
 831         self.pos >= self.buf.len()
 832     }
 833
 834     fn is_seekable(&mut self) -> bool {
 835         true
 836     }
 837
 838     fn size(&mut self) -> i64 {
 839         self.buf.len() as i64
 840     }
 841 }
 842
 843 impl<'a> GrowableMemoryWriter<'a> {
 844
 845     /// Constructs a new instance of `GrowableMemoryWriter`.
 846     pub fn new_write(buf: &'a mut Vec<u8>) -> Self {
 847         GrowableMemoryWriter { buf, pos: 0 }
 848     }
 849
 850     fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
 851         if pos < 0 || (pos as usize) > self.buf.len() {
 852             return Err(ByteIOError::WrongRange)
 853         }
 854         self.pos = pos as usize;
 855         Ok(pos as u64)
 856     }
 857 }
 858
 859 impl<'a> ByteIO for GrowableMemoryWriter<'a> {
 860     #[allow(unused_variables)]
 861     fn read_byte(&mut self) -> ByteIOResult<u8> {
 862         Err(ByteIOError::NotImplemented)
 863     }
 864
 865     #[allow(unused_variables)]
 866     fn peek_byte(&mut self) -> ByteIOResult<u8> {
 867         Err(ByteIOError::NotImplemented)
 868     }
 869
 870     #[allow(unused_variables)]
 871     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 872         Err(ByteIOError::NotImplemented)
 873     }
 874
 875     #[allow(unused_variables)]
 876     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 877         Err(ByteIOError::NotImplemented)
 878     }
 879
 880     #[allow(unused_variables)]
 881     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 882         Err(ByteIOError::NotImplemented)
 883     }
 884
 885     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
 886         if self.pos + buf.len() > self.buf.len() {
 887             self.buf.resize(self.pos + buf.len(), 0);
 888         }
 889         self.buf[self.pos..][..buf.len()].copy_from_slice(buf);
 890         self.pos += buf.len();
 891         Ok(())
 892     }
 893
 894     fn tell(&mut self) -> u64 {
 895         self.pos as u64
 896     }
 897
 898     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 899         let cur_pos  = self.pos       as i64;
 900         let cur_size = self.buf.len() as i64;
 901         match pos {
 902             SeekFrom::Start(x)   => self.real_seek(x as i64),
 903             SeekFrom::Current(x) => self.real_seek(cur_pos + x),
 904             SeekFrom::End(x)     => self.real_seek(cur_size + x),
 905         }
 906     }
 907
 908     fn is_eof(&self) -> bool {
 909         self.pos >= self.buf.len()
 910     }
 911
 912     fn is_seekable(&mut self) -> bool {
 913         true
 914     }
 915
 916     fn size(&mut self) -> i64 {
 917         self.buf.len() as i64
 918     }
 919 }
 920
 921 impl<T: Write+Seek> FileWriter<T> {
 922     /// Constructs a new instance of `FileWriter`.
 923     pub fn new_write(file: T) -> Self {
 924         FileWriter { file: Box::new(file) }
 925     }
 926 }
 927
 928 impl<T: Write+Seek> ByteIO for FileWriter<T> {
 929     #[allow(unused_variables)]
 930     fn read_byte(&mut self) -> ByteIOResult<u8> {
 931         Err(ByteIOError::NotImplemented)
 932     }
 933
 934     #[allow(unused_variables)]
 935     fn peek_byte(&mut self) -> ByteIOResult<u8> {
 936         Err(ByteIOError::NotImplemented)
 937     }
 938
 939     #[allow(unused_variables)]
 940     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 941         Err(ByteIOError::NotImplemented)
 942     }
 943
 944     #[allow(unused_variables)]
 945     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 946         Err(ByteIOError::NotImplemented)
 947     }
 948
 949     #[allow(unused_variables)]
 950     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 951         Err(ByteIOError::NotImplemented)
 952     }
 953
 954     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
 955         match self.file.write_all(buf) {
 956             Ok(()) => Ok(()),
 957             Err(_) => Err(ByteIOError::WriteError),
 958         }
 959     }
 960
 961     fn tell(&mut self) -> u64 {
 962         self.file.seek(SeekFrom::Current(0)).unwrap()
 963     }
 964
 965     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 966         let res = self.file.seek(pos);
 967         match res {
 968             Ok(r) => Ok(r),
 969             Err(_) => Err(ByteIOError::SeekError),
 970         }
 971     }
 972
 973     fn is_eof(&self) -> bool {
 974         false
 975     }
 976
 977     fn is_seekable(&mut self) -> bool {
 978         true
 979     }
 980
 981     fn size(&mut self) -> i64 {
 982         -1
 983     }
 984 }
 985
 986 #[cfg(test)]
 987 mod test {
 988     use super::*;
 989     use std::fs::File;
 990
 991     #[test]
 992     fn test_read() {
 993         //const DATA : &'static [u8] = include_bytes!("../../assets/file");
 994         let buf: [u8; 64] = [1; 64];
 995         let mut mr = MemoryReader::new_read(&buf);
 996         let mut reader = ByteReader::new(&mut mr);
 997         assert_eq!(reader.read_byte().unwrap(),  0x01u8);
 998         assert_eq!(reader.read_u16le().unwrap(), 0x0101u16);
 999         assert_eq!(reader.read_u24le().unwrap(), 0x010101u32);
1000         assert_eq!(reader.read_u32le().unwrap(), 0x01010101u32);
1001         assert_eq!(reader.read_u64le().unwrap(), 0x0101010101010101u64);
1002         let mut file = File::open("assets/Misc/MaoMacha.asx").unwrap();
1003         let mut fr = FileReader::new_read(&mut file);
1004         let mut br2 = ByteReader::new(&mut fr);
1005         assert_eq!(br2.read_byte().unwrap(), 0x30);
1006         assert_eq!(br2.read_u24be().unwrap(), 0x26B275);
1007         assert_eq!(br2.read_u24le().unwrap(), 0xCF668E);
1008         assert_eq!(br2.read_u32be().unwrap(), 0x11A6D900);
1009         assert_eq!(br2.read_u32le().unwrap(), 0xCE6200AA);
1010     }
1011     #[test]
1012     fn test_write() {
1013         let mut buf: [u8; 64] = [0; 64];
1014         {
1015             let mut mw = MemoryWriter::new_write(&mut buf);
1016             let mut bw = ByteWriter::new(&mut mw);
1017             bw.write_byte(0x00).unwrap();
1018             bw.write_u16be(0x0102).unwrap();
1019             bw.write_u24be(0x030405).unwrap();
1020             bw.write_u32be(0x06070809).unwrap();
1021             bw.write_u64be(0x0A0B0C0D0E0F1011).unwrap();
1022             bw.write_byte(0x00).unwrap();
1023             bw.write_u16le(0x0201).unwrap();
1024             bw.write_u24le(0x050403).unwrap();
1025             bw.write_u32le(0x09080706).unwrap();
1026             bw.write_u64le(0x11100F0E0D0C0B0A).unwrap();
1027             assert_eq!(bw.size_left(), 28);
1028         }
1029         for i in 0..0x12 {
1030             assert_eq!(buf[(i + 0x00) as usize], i);
1031             assert_eq!(buf[(i + 0x12) as usize], i);
1032         }
1033     }
1034 }