Handle OOM where possible

Author: kornelski

src/common.rs

@@ -325,7 +325,8 @@ impl Frame<'static> {
     #[cfg(feature = "color_quant")]
     pub fn from_rgb_speed(width: u16, height: u16, pixels: &[u8], speed: i32) -> Frame<'static> {
         assert_eq!(width as usize * height as usize * 3, pixels.len(), "Too much or too little pixel data for the given width and height to create a GIF Frame");
-        let mut vec: Vec<u8> = Vec::with_capacity(pixels.len() + width as usize * height as usize);
+        let mut vec: Vec<u8> = Vec::new();
+        vec.try_reserve_exact(pixels.len() + width as usize * height as usize).expect("OOM");
         for v in pixels.chunks_exact(3) {
             vec.extend_from_slice(&[v[0], v[1], v[2], 0xFF])
         }

src/encoder.rs

@@ -141,12 +141,13 @@ impl<W: Write> Encoder<W> {
     /// if no global palette shall be used an empty slice may be supplied.
     pub fn new(w: W, width: u16, height: u16, global_palette: &[u8]) -> Result<Self, EncodingError> {
         let buffer_size = (width as usize) * (height as usize);
+        let mut buffer = Vec::new();
+        buffer.try_reserve_exact(buffer_size).map_err(|_| io::Error::from(io::ErrorKind::OutOfMemory))?;
         Encoder {
             w: Some(w),
             global_palette: false,
-            width: width,
-            height: height,
-            buffer: Vec::with_capacity(buffer_size)
+            width, height,
+            buffer,
         }.write_global_palette(global_palette)
     }
 

src/reader/decoder.rs

@@ -507,7 +507,7 @@ impl StreamingDecoder {
                         let global_table = b & 0x80 != 0;
                         let entries = if global_table {
                             let entries = PLTE_CHANNELS*(1 << ((b & 0b111) + 1) as usize);
-                            self.global_color_table.reserve_exact(entries);
+                            self.global_color_table.try_reserve_exact(entries).map_err(|_| io::Error::from(io::ErrorKind::OutOfMemory))?;
                             entries
                         } else {
                             0usize
@@ -568,9 +568,9 @@ impl StreamingDecoder {
 
                         if local_table {
                             let entries = PLTE_CHANNELS * (1 << (table_size + 1));
-                            
-                            self.current_frame_mut().palette =
-                                Some(Vec::with_capacity(entries));
+                            let mut pal = Vec::new();
+                            pal.try_reserve_exact(entries).map_err(|_| io::Error::from(io::ErrorKind::OutOfMemory))?;
+                            self.current_frame_mut().palette = Some(pal);
                             goto!(LocalPalette(entries))
                         } else {
                             goto!(Byte(CodeSize))

src/reader/mod.rs

@@ -336,8 +336,9 @@ impl<R> Decoder<R> where R: Read {
                     self.current_frame.interlaced = false;
                 }
                 FrameDataType::Lzw { min_code_size } => {
+                    let mut vec = Vec::new();
                     // Guesstimate 2bpp
-                    let mut vec = Vec::with_capacity(pixel_bytes/4);
+                    vec.try_reserve(pixel_bytes/4).map_err(|_| io::Error::from(io::ErrorKind::OutOfMemory))?;
                     self.copy_lzw_into_buffer(min_code_size, &mut vec)?;
                     self.current_frame.buffer = Cow::Owned(vec);
                 },
@@ -380,6 +381,7 @@ impl<R> Decoder<R> where R: Read {
         loop {
             match self.decoder.decode_next(None)? {
                 Some(Decoded::LzwData(data)) => {
+                    buf.try_reserve(data.len()).map_err(|_| io::Error::from(io::ErrorKind::OutOfMemory))?;
                     buf.extend_from_slice(data);
                 },
                 Some(Decoded::DataEnd) => return Ok(()),