lifning
/
image-gif
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

refactor: change try! with ?

This commit is contained in:
Théo Gaillard 2019-05-07 04:21:30 +02:00
parent ed33159bde
commit cf1ace22b9
7 changed files with 70 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
gif-afl/src/main.rs
View File

@ -19,16 +19,16 @@ fn main() {
let mut decoder = gif::Decoder::new(file);*/
decoder.set(gif::ColorOutput::RGBA);
match (|| -> Result<(), gif::DecodingError> {
let mut decoder = try!(decoder.read_info());
let mut decoder = decoder.read_info()?;
println!("width = {}, height = {}", decoder.width(), decoder.height());
let mut i = 0;
loop {
if let Some(frame) = try!(decoder.next_frame_info()) {
if let Some(frame) = decoder.next_frame_info()? {
i += 1;
println!("frame {}: {:?}", i, frame);
} else { break }
let mut vec = vec![0; decoder.buffer_size()];
try!(decoder.fill_buffer(&mut vec));
decoder.fill_buffer(&mut vec)?;
test::black_box(vec);
}
Ok(())

82
src/encoder.rs
View File

@ -92,8 +92,8 @@ impl<'a, W: Write + 'a> Write for BlockWriter<'a, W> {
self.bytes += to_copy;
if self.bytes == 0xFF {
self.bytes = 0;
try!(self.w.write_le(0xFFu8));
try!(self.w.write_all(&self.buf));
self.w.write_le(0xFFu8)?;
self.w.write_all(&self.buf)?;
}
Ok(to_copy)
}
@ -157,8 +157,8 @@ impl<W: Write> Encoder<W> {
}
flags |= flag_size(num_colors);
flags |= flag_size(num_colors) << 4; // wtf flag
try!(self.write_screen_desc(flags));
try!(self.write_color_table(palette));
self.write_screen_desc(flags)?;
self.write_color_table(palette)?;
Ok(self)
}
@ -168,24 +168,24 @@ impl<W: Write> Encoder<W> {
pub fn write_frame(&mut self, frame: &Frame) -> io::Result<()> {
// TODO commented off to pass test in lib.rs
//if frame.delay > 0 || frame.transparent.is_some() {
try!(self.write_extension(ExtensionData::new_control_ext(
self.write_extension(ExtensionData::new_control_ext(
frame.delay,
frame.dispose,
frame.needs_user_input,
frame.transparent
)));
))?;
//}
try!(self.w.write_le(Block::Image as u8));
try!(self.w.write_le(frame.left));
try!(self.w.write_le(frame.top));
try!(self.w.write_le(frame.width));
try!(self.w.write_le(frame.height));
self.w.write_le(Block::Image as u8)?;
self.w.write_le(frame.left)?;
self.w.write_le(frame.top)?;
self.w.write_le(frame.width)?;
self.w.write_le(frame.height)?;
let mut flags = 0;
if frame.interlaced {
flags |= 0b0100_0000;
}
try!(match frame.palette {
match frame.palette {
Some(ref palette) => {
flags |= 0b1000_0000;
let num_colors = palette.len() / 3;
@ -193,7 +193,7 @@ impl<W: Write> Encoder<W> {
return Err(io::Error::new(io::ErrorKind::InvalidInput, "Too many colors"));
}
flags |= flag_size(num_colors);
try!(self.w.write_le(flags));
self.w.write_le(flags)?;
self.write_color_table(palette)
},
None => if !self.global_palette {
@ -204,7 +204,7 @@ impl<W: Write> Encoder<W> {
} else {
self.w.write_le(flags)
}
});
}?;
self.write_image_block(&frame.buffer)
}
@ -214,10 +214,10 @@ impl<W: Write> Encoder<W> {
1 => 2, // As per gif spec: The minimal code size has to be >= 2
n => n
};
try!(self.w.write_le(min_code_size));
self.w.write_le(min_code_size)?;
let mut bw = BlockWriter::new(&mut self.w);
let mut enc = try!(lzw::Encoder::new(lzw::LsbWriter::new(&mut bw), min_code_size));
try!(enc.encode_bytes(data));
let mut enc = lzw::Encoder::new(lzw::LsbWriter::new(&mut bw), min_code_size));
enc.encode_bytes(data)?;
}
self.w.write_le(0u8)
}
@ -228,10 +228,10 @@ impl<W: Write> Encoder<W> {
return Err(io::Error::new(io::ErrorKind::InvalidInput, "Too many colors"));
}
let size = flag_size(num_colors);
try!(self.w.write_all(&table[..num_colors * 3]));
self.w.write_all(&table[..num_colors * 3])?;
// Waste some space as of gif spec
for _ in 0..((2 << size) - num_colors) {
try!(self.w.write_all(&[0, 0, 0]))
self.w.write_all(&[0, 0, 0])?
}
Ok(())
}
@ -246,24 +246,24 @@ impl<W: Write> Encoder<W> {
if let Repetitions(Repeat::Finite(0)) = extension {
return Ok(())
}
try!(self.w.write_le(Block::Extension as u8));
self.w.write_le(Block::Extension as u8)?;
match extension {
Control { flags, delay, trns } => {
try!(self.w.write_le(Extension::Control as u8));
try!(self.w.write_le(4u8));
try!(self.w.write_le(flags));
try!(self.w.write_le(delay));
try!(self.w.write_le(trns));
self.w.write_le(Extension::Control as u8)?;
self.w.write_le(4u8)?;
self.w.write_le(flags)?;
self.w.write_le(delay)?;
self.w.write_le(trns)?;
}
Repetitions(repeat) => {
try!(self.w.write_le(Extension::Application as u8));
try!(self.w.write_le(11u8));
try!(self.w.write(b"NETSCAPE2.0"));
try!(self.w.write_le(3u8));
try!(self.w.write_le(1u8));
self.w.write_le(Extension::Application as u8)?;
self.w.write_le(11u8)?;
self.w.write(b"NETSCAPE2.0")?;
self.w.write_le(3u8)?;
self.w.write_le(1u8)?;
match repeat {
Repeat::Finite(no) => try!(self.w.write_le(no)),
Repeat::Infinite => try!(self.w.write_le(0u16)),
Repeat::Finite(no) => self.w.write_le(no)?,
Repeat::Infinite => self.w.write_le(0u16)?,
}
}
}
@ -276,12 +276,12 @@ impl<W: Write> Encoder<W> {
/// identifier (e.g. `Extension::Application as u8`). `data` are the extension payload blocks. If any
/// contained slice has a lenght > 255 it is automatically divided into sub-blocks.
pub fn write_raw_extension(&mut self, func: u8, data: &[&[u8]]) -> io::Result<()> {
try!(self.w.write_le(Block::Extension as u8));
try!(self.w.write_le(func as u8));
self.w.write_le(Block::Extension as u8)?;
self.w.write_le(func as u8)?;
for block in data {
for chunk in block.chunks(0xFF) {
try!(self.w.write_le(chunk.len() as u8));
try!(self.w.write_all(chunk));
self.w.write_le(chunk.len() as u8)?;
self.w.write_all(chunk)?;
}
}
self.w.write_le(0u8)
@ -289,11 +289,11 @@ impl<W: Write> Encoder<W> {
/// Writes the logical screen desriptor
fn write_screen_desc(&mut self, flags: u8) -> io::Result<()> {
try!(self.w.write_all(b"GIF89a"));
try!(self.w.write_le(self.width));
try!(self.w.write_le(self.height));
try!(self.w.write_le(flags)); // packed field
try!(self.w.write_le(0u8)); // bg index
self.w.write_all(b"GIF89a")?;
self.w.write_le(self.width)?;
self.w.write_le(self.height)?;
self.w.write_le(flags)?; // packed field
self.w.write_le(0u8)?; // bg index
self.w.write_le(0u8) // aspect ratio
}
}

4
src/lib.rs
View File

@ -108,9 +108,9 @@
// }
// # (|| {
// {
// let mut file = try!(File::create("test.gif"));
// let mut file = File::create("test.gif")?;
// let mut encoder = Encoder::new(&mut file, 100, 100);
// try!(encoder.write_global_palette(color_map)).write_frame(&frame)
// encoder.write_global_palette(color_map)?.write_frame(&frame)
// }
// # })().unwrap();
// ```

8
src/reader/decoder.rs
View File

@ -221,7 +221,7 @@ impl StreamingDecoder {
// this is safe.
// ### NOTE
// To check that everything is sound, return the result without
// the match (e.g. `return Ok(try!(self.next_state(buf)))`). If
// the match (e.g. `return Ok(self.next_state(buf)?)`). If
// it compiles the returned lifetime is correct.
unsafe {
mem::transmute::<Decoded, Decoded>(result)
@ -460,7 +460,7 @@ impl StreamingDecoder {
if let Some(ext) = Extension::from_u8(type_) {
match ext {
Control => {
goto!(try!(self.read_control_extension(b)))
goto!(self.read_control_extension(b)?)
}
Text | Comment | Application => {
goto!(SkipBlock(b as usize))
@ -513,7 +513,7 @@ impl StreamingDecoder {
if left > 0 {
let n = cmp::min(left, buf.len());
let decoder = self.lzw_reader.as_mut().unwrap();
let (consumed, bytes) = try!(decoder.decode_bytes(&buf[..n]));
let (consumed, bytes) = decoder.decode_bytes(&buf[..n])?;
goto!(consumed, DecodeSubBlock(left - consumed), emit Decoded::Data(bytes))
} else if b != 0 { // decode next sub-block
goto!(DecodeSubBlock(b as usize))
@ -521,7 +521,7 @@ impl StreamingDecoder {
// The end of the lzw stream is only reached if left == 0 and an additional call
// to `decode_bytes` results in an empty slice.
let decoder = self.lzw_reader.as_mut().unwrap();
let (_, bytes) = try!(decoder.decode_bytes(&[]));
let (_, bytes) = decoder.decode_bytes(&[])?;
if bytes.len() > 0 {
goto!(0, DecodeSubBlock(0), emit Decoded::Data(bytes))
} else {

30
src/reader/mod.rs
View File

@ -96,13 +96,13 @@ impl<R: Read> ReadDecoder<R> {
fn decode_next(&mut self) -> Result<Option<Decoded>, DecodingError> {
while !self.at_eof {
let (consumed, result) = {
let buf = try!(self.reader.fill_buf());
let buf = self.reader.fill_buf()?;
if buf.len() == 0 {
return Err(DecodingError::Format(
"unexpected EOF"
))
}
try!(self.decoder.update(buf))
self.decoder.update(buf)?
};
self.reader.consume(consumed);
match result {
@ -157,7 +157,7 @@ impl<R> Reader<R> where R: Read {
fn init(mut self) -> Result<Self, DecodingError> {
loop {
match try!(self.decoder.decode_next()) {
match self.decoder.decode_next()? {
Some(Decoded::BackgroundColor(bg_color)) => {
self.bg_color = Some(bg_color)
}
@ -191,7 +191,7 @@ impl<R> Reader<R> where R: Read {
/// Returns the next frame info
pub fn next_frame_info(&mut self) -> Result<Option<&Frame<'static>>, DecodingError> {
loop {
match try!(self.decoder.decode_next()) {
match self.decoder.decode_next()? {
Some(Decoded::Frame(frame)) => {
self.current_frame = frame.clone();
if frame.palette.is_none() && self.global_palette.is_none() {
@ -222,9 +222,9 @@ impl<R> Reader<R> where R: Read {
/// Do not call `Self::next_frame_info` beforehand.
/// Deinterlaces the result.
pub fn read_next_frame(&mut self) -> Result<Option<&Frame<'static>>, DecodingError> {
if try!(self.next_frame_info()).is_some() {
if self.next_frame_info()?.is_some() {
let mut vec = vec![0; self.buffer_size()];
try!(self.read_into_buffer(&mut vec));
self.read_into_buffer(&mut vec)?;
self.current_frame.buffer = Cow::Owned(vec);
self.current_frame.interlaced = false;
Ok(Some(&self.current_frame))
@ -243,13 +243,13 @@ impl<R> Reader<R> where R: Read {
let width = self.line_length();
let height = self.current_frame.height as usize;
for row in (InterlaceIterator { len: height, next: 0, pass: 0 }) {
if !try!(self.fill_buffer(&mut buf[row*width..][..width])) {
if !self.fill_buffer(&mut buf[row*width..][..width])? {
return Err(DecodingError::Format("Image truncated"))
}
}
} else {
let buf = &mut buf[..self.buffer_size()];
if !try!(self.fill_buffer(buf)) {
if !self.fill_buffer(buf)? {
return Err(DecodingError::Format("Image truncated"))
}
};
@ -309,7 +309,7 @@ impl<R> Reader<R> where R: Read {
}
}
loop {
match try!(self.decoder.decode_next()) {
match self.decoder.decode_next()? {
Some(Decoded::Data(data)) => {
let (len, channels) = handle_data!(data);
let buf_ = buf; buf = &mut buf_[len*channels..]; // shorten buf
@ -346,9 +346,9 @@ impl<R> Reader<R> where R: Read {
// TODO prevent planic
Ok(match self.current_frame.palette {
Some(ref table) => &*table,
None => &*try!(self.global_palette.as_ref().ok_or(DecodingError::Format(
None => &*self.global_palette.as_ref().ok_or(DecodingError::Format(
"No color table available for current frame."
))),
))?,
})
}
@ -514,7 +514,7 @@ mod c_interface {
fn current_image_buffer(&mut self) -> Result<(&[u8], &mut usize), DecodingError> {
if let Cow::Borrowed(_) = self.current_frame.buffer {
try!(self.read_next_frame());
self.read_next_frame()?;
}
Ok((&self.current_frame.buffer, &mut self.offset))
}
@ -525,7 +525,7 @@ mod c_interface {
fn next_record_type(&mut self) -> Result<Block, DecodingError> {
loop {
match try!(self.decoder.decode_next()) {
match self.decoder.decode_next()? {
Some(Decoded::BlockStart(type_)) => return Ok(type_),
Some(_) => (),
None => return Ok(Block::Trailer)
@ -539,8 +539,8 @@ mod c_interface {
/*
unsafe fn read_to_end(&mut self, this: &mut c_api::GifFileType) -> Result<(), DecodingError> {
try!(self.read_screen_desc(this));
try!(self.read_to_end());
self.read_screen_desc(this)?;
self.read_to_end()?;
this.ImageCount = self.frames().len() as c_int;
let images = saved_images_new(this.ImageCount as usize);
for (i, frame) in self.frames().iter().enumerate() {

4
src/traits.rs
View File

@ -56,7 +56,7 @@ impl<W: io::Write + ?Sized> WriteBytesExt<u16> for W {
impl<W: io::Write + ?Sized> WriteBytesExt<u32> for W {
#[inline]
fn write_le(&mut self, n: u32) -> io::Result<()> {
try!(self.write_le(n as u16));
self.write_le(n as u16)?;
self.write_le((n >> 16) as u16)
}
@ -65,7 +65,7 @@ impl<W: io::Write + ?Sized> WriteBytesExt<u32> for W {
impl<W: io::Write + ?Sized> WriteBytesExt<u64> for W {
#[inline]
fn write_le(&mut self, n: u64) -> io::Result<()> {
try!(self.write_le(n as u32));
self.write_le(n as u32)?;
self.write_le((n >> 32) as u32)
}

6
tests/check_testimages.rs
View File

@ -69,11 +69,11 @@ fn error_cast() {
#[test]
fn render_images() {
process_images(|path| {
let mut decoder = gif::Decoder::new(try!(File::open(path)));
let mut decoder = gif::Decoder::new(File::open(path)?);
decoder.set(gif::ColorOutput::RGBA);
let mut decoder = try!(decoder.read_info());
let mut decoder = decoder.read_info()?;
let mut crc = Crc32::new();
while let Some(frame) = try!(decoder.read_next_frame()) {
while let Some(frame) = decoder.read_next_frame()? {
// First sanity check:
assert_eq!(
frame.buffer.len(),