add rest of compression algorithms

src/command.rs

@@ -1,9 +1,7 @@
-use std::io::Read;
-use flate2::bufread::GzEncoder;
-use flate2::Compression;
-use flate2::read::GzDecoder;
-use crate::{BitVec, ByteGrid, Header, Packet, Payload, PixelGrid, TILE_SIZE};
+use crate::{BitVec, ByteGrid, Header, Packet, PixelGrid, TILE_SIZE};
 use crate::command_codes::{CommandCode, CompressionCode};
+use crate::compression::{into_compressed, into_decompressed};
+
 
 /// An origin marks the top left position of the
 /// data sent to the display.
@@ -239,38 +237,3 @@ fn packet_into_linear_bitmap(packet: Packet) -> Result<(BitVec, CompressionCode)
     };
     Ok((BitVec::load(&payload), sub))
 }
-
-fn into_decompressed(kind: CompressionCode, payload: Payload) -> Option<Payload> {
-    match kind {
-        CompressionCode::None => Some(payload),
-        CompressionCode::Gz => {
-            let mut decoder = GzDecoder::new(&*payload);
-            let mut decompressed = vec!();
-            match decoder.read_to_end(&mut decompressed) {
-                Err(_) => None,
-                Ok(_) => Some(decompressed)
-            }
-        }
-        CompressionCode::Bz => todo!(),
-        CompressionCode::Lz => todo!(),
-        CompressionCode::Zs => todo!(),
-    }
-}
-
-fn into_compressed(kind: CompressionCode, payload: Payload) -> Payload {
-    match kind {
-        CompressionCode::None => payload,
-        CompressionCode::Gz => {
-            let mut encoder = GzEncoder::new(&*payload, Compression::best());
-            let mut compressed = vec!();
-            match encoder.read_to_end(&mut compressed) {
-                Err(err) => panic!("could not compress payload: {}", err),
-                Ok(_) => compressed,
-            }
-        }
-        CompressionCode::Bz => todo!(),
-        CompressionCode::Lz => todo!(),
-        CompressionCode::Zs => todo!(),
-    }
-}
-

src/command_codes.rs

@@ -33,9 +33,13 @@ impl CommandCode {
 #[derive(Debug, FromPrimitive, ToPrimitive, Clone, Copy)]
 pub enum CompressionCode {
     None = 0x0,
+    #[cfg(feature = "compression-gz")]
     Gz = 0x677a,
+    #[cfg(feature = "compression-bz")]
     Bz = 0x627a,
+    #[cfg(feature = "compression-lz")]
     Lz = 0x6c7a,
+    #[cfg(feature = "compression-zs")]
     Zs = 0x7a73,
 }
 

src/compression.rs

@@ -0,0 +1,103 @@
+use crate::{CompressionCode, Payload};
+use std::io::{Read, Write};
+
+#[cfg(feature = "compression-bz")]
+use bzip2::read::{BzEncoder, BzDecoder};
+#[cfg(feature = "compression-gz")]
+use flate2::read::{GzEncoder, GzDecoder};
+#[cfg(feature = "compression-lz")]
+use lz4::{EncoderBuilder as Lz4EncoderBuilder, Decoder as Lz4Decoder};
+#[cfg(feature = "compression-zs")]
+use zstd::{Encoder as ZstdEncoder, Decoder as ZstdDecoder};
+
+pub(crate) fn into_decompressed(kind: CompressionCode, payload: Payload) -> Option<Payload> {
+    match kind {
+        CompressionCode::None => Some(payload),
+        #[cfg(feature = "compression-gz")]
+        CompressionCode::Gz => {
+            let mut decoder = GzDecoder::new(&*payload);
+            let mut decompressed = vec!();
+            match decoder.read_to_end(&mut decompressed) {
+                Err(_) => None,
+                Ok(_) => Some(decompressed)
+            }
+        }
+        #[cfg(feature = "compression-bz")]
+        CompressionCode::Bz => {
+            let mut decoder = BzDecoder::new(&*payload);
+            let mut decompressed = vec!();
+            match decoder.read_to_end(&mut decompressed) {
+                Err(_) => None,
+                Ok(_) => Some(decompressed)
+            }
+        }
+        #[cfg(feature = "compression-lz")]
+        CompressionCode::Lz => {
+            let mut decoder = match Lz4Decoder::new(&*payload) {
+                Err(_) => return None,
+                Ok(value) => value
+            };
+            let mut decompressed = vec!();
+            match decoder.read_to_end(&mut decompressed) {
+                Err(_) => None,
+                Ok(_) => Some(decompressed)
+            }
+        }
+        #[cfg(feature = "compression-zs")]
+        CompressionCode::Zs => {
+            let mut decoder = match ZstdDecoder::new(&*payload) {
+                Err(_) => return None,
+                Ok(value) => value
+            };
+            let mut decompressed = vec!();
+            match decoder.read_to_end(&mut decompressed) {
+                Err(_) => None,
+                Ok(_) => Some(decompressed)
+            }
+        }
+    }
+}
+
+pub(crate) fn into_compressed(kind: CompressionCode, payload: Payload) -> Payload {
+    match kind {
+        CompressionCode::None => payload,
+        #[cfg(feature = "compression-gz")]
+        CompressionCode::Gz => {
+            let mut encoder = GzEncoder::new(&*payload, flate2::Compression::fast());
+            let mut compressed = vec!();
+            match encoder.read_to_end(&mut compressed) {
+                Err(err) => panic!("could not compress payload: {}", err),
+                Ok(_) => compressed,
+            }
+        }
+        #[cfg(feature = "compression-bz")]
+        CompressionCode::Bz => {
+            let mut encoder = BzEncoder::new(&*payload, bzip2::Compression::fast());
+            let mut compressed = vec!();
+            match encoder.read_to_end(&mut compressed) {
+                Err(err) => panic!("could not compress payload: {}", err),
+                Ok(_) => compressed,
+            }
+        }
+        #[cfg(feature = "compression-lz")]
+        CompressionCode::Lz => {
+            let mut encoder = Lz4EncoderBuilder::new()
+                .build(vec!())
+                .expect("could not create encoder");
+            encoder.write(&*payload)
+                .expect("could not write payload");
+            let (payload, _) = encoder.finish();
+            payload
+        }
+        #[cfg(feature = "compression-zs")]
+        CompressionCode::Zs => {
+            let mut encoder = ZstdEncoder::new(vec!(), zstd::DEFAULT_COMPRESSION_LEVEL)
+                .expect("could not create encoder");
+            encoder.write(&*payload)
+                .expect("could not compress payload");
+            encoder.finish()
+                .expect("could not finish encoding")
+        }
+    }
+}
+

src/lib.rs

@@ -5,6 +5,7 @@ mod packet;
 mod command;
 mod command_codes;
 mod byte_grid;
+mod compression;
 
 pub use crate::connection::Connection;
 pub use crate::pixel_grid::PixelGrid;