tga: decode 5-bit-per-primary images

This is very loosely based on a patch by red-001 <[email protected]>.

Author: mstoeckl

src/codecs/tga/decoder.rs

@@ -76,6 +76,23 @@ impl TgaOrientation {
     }
 }
 
+/// This contains the nearest integers to the rational numbers
+/// `(255 x) / 31`, for each `x` between 0 and 31, inclusive.
+static LOOKUP_TABLE_5_BIT_TO_8_BIT: [u8; 32] = [
+    0, 8, 16, 25, 33, 41, 49, 58, 66, 74, 82, 90, 99, 107, 115, 123, 132, 140, 148, 156, 165, 173,
+    181, 189, 197, 206, 214, 222, 230, 239, 247, 255,
+];
+
+/// Convert TGA's 15/16-bit pixel format to its 24 bit pixel format
+fn expand_rgb15_to_rgb24(data: [u8; 2]) -> [u8; 3] {
+    let val = u16::from_le_bytes(data);
+    [
+        LOOKUP_TABLE_5_BIT_TO_8_BIT[(val & 0b11111) as usize],
+        LOOKUP_TABLE_5_BIT_TO_8_BIT[((val >> 5) & 0b11111) as usize],
+        LOOKUP_TABLE_5_BIT_TO_8_BIT[((val >> 10) & 0b11111) as usize],
+    ]
+}
+
 impl<R: Read> TgaDecoder<R> {
     /// Create a new decoder that decodes from the stream `r`
     pub fn new(mut r: R) -> ImageResult<TgaDecoder<R>> {
@@ -85,7 +102,7 @@ impl<R: Read> TgaDecoder<R> {
         let width = header.image_width as usize;
         let height = header.image_height as usize;
         let raw_bytes_per_pixel = (header.pixel_depth as usize).div_ceil(8);
-        let num_alpha_bits = header.image_desc & ALPHA_BIT_MASK;
+        let num_attrib_bits = header.image_desc & ALPHA_BIT_MASK;
 
         if width == 0 || height == 0 {
             return Err(ImageError::Decoding(DecodingError::new(
@@ -94,15 +111,6 @@ impl<R: Read> TgaDecoder<R> {
             )));
         }
 
-        // Validate header
-        if ![8, 16, 24, 32].contains(&header.pixel_depth) || ![0, 8].contains(&num_alpha_bits) {
-            return Err(ImageError::Unsupported(
-                UnsupportedError::from_format_and_kind(
-                    ImageFormat::Tga.into(),
-                    UnsupportedErrorKind::Color(ExtendedColorType::Unknown(header.pixel_depth)),
-                ),
-            ));
-        }
         if image_type.is_color_mapped() {
             if header.map_type != 1 {
                 return Err(ImageError::Decoding(DecodingError::new(
@@ -126,49 +134,14 @@ impl<R: Read> TgaDecoder<R> {
             }
         }
 
-        // TODO: validate the rest of the fields in the header.
-
-        // Read image ID (and ignore it)
-        let mut tmp = [0u8; 256];
-        r.read_exact(&mut tmp[0..header.id_length as usize])?;
-
-        // Read color map
-        let mut color_map = None;
-        if header.map_type == 1 {
-            let entry_size = (header.map_entry_size as usize).div_ceil(8);
-            if ![2, 3, 4].contains(&entry_size) {
-                return Err(ImageError::Unsupported(
-                    UnsupportedError::from_format_and_kind(
-                        ImageFormat::Tga.into(),
-                        UnsupportedErrorKind::GenericFeature(
-                            "Unsupported color map entry size".into(),
-                        ),
-                    ),
-                ));
-            }
-
-            let mut bytes = Vec::new();
-            r.read_exact_vec(&mut bytes, entry_size * header.map_length as usize)?;
-
-            // Color maps are technically allowed in non-color-mapped images, so check that we
-            // actually need the color map before storing it.
-            if image_type.is_color_mapped() {
-                color_map = Some(ColorMap {
-                    entry_size,
-                    start_offset: header.map_origin as usize,
-                    bytes,
-                });
-            }
-        }
-
         // Compute output pixel depth
-        let total_pixel_bits = if header.map_type == 1 {
+        let total_pixel_bits = if image_type.is_color_mapped() {
             header.map_entry_size
         } else {
             header.pixel_depth
         };
         let num_other_bits = total_pixel_bits
-            .checked_sub(num_alpha_bits)
+            .checked_sub(num_attrib_bits)
             .ok_or_else(|| {
                 ImageError::Decoding(DecodingError::new(
                     ImageFormat::Tga.into(),
@@ -179,12 +152,19 @@ impl<R: Read> TgaDecoder<R> {
         // Determine color type
         let color_type;
         let mut original_color_type = None;
-        match (num_alpha_bits, num_other_bits, image_type.is_color()) {
+        match (num_attrib_bits, num_other_bits, image_type.is_color()) {
             // really, the encoding is BGR and BGRA, this is fixed up with
             // `TgaDecoder::reverse_encoding`.
             (0, 32, true) => color_type = ColorType::Rgba8,
             (8, 24, true) => color_type = ColorType::Rgba8,
             (0, 24, true) => color_type = ColorType::Rgb8,
+            (1, 15, true) | (0, 15, true) | (0, 16, true) => {
+                // the 'A' bit for 5-bit-per-primary images is an 'attribute'
+                // bit, and cannot safely be interpreted as an alpha channel.
+                // (It may contain all zero values or a pattern unrelated to the image.)
+                color_type = ColorType::Rgb8;
+                original_color_type = Some(ExtendedColorType::Rgb5x1);
+            }
             (8, 8, false) => color_type = ColorType::La8,
             (0, 8, false) => color_type = ColorType::L8,
             (8, 0, false) => {
@@ -202,6 +182,52 @@ impl<R: Read> TgaDecoder<R> {
             }
         }
 
+        // TODO: validate the rest of the fields in the header.
+
+        // Read image ID (and ignore it)
+        let mut tmp = [0u8; 256];
+        r.read_exact(&mut tmp[0..header.id_length as usize])?;
+
+        // Read color map
+        let mut color_map = None;
+        if header.map_type == 1 {
+            if ![15, 16, 24, 32].contains(&header.map_entry_size) {
+                return Err(ImageError::Unsupported(
+                    UnsupportedError::from_format_and_kind(
+                        ImageFormat::Tga.into(),
+                        UnsupportedErrorKind::GenericFeature(
+                            "Unsupported color map entry size".into(),
+                        ),
+                    ),
+                ));
+            }
+            let mut entry_size = (header.map_entry_size as usize).div_ceil(8);
+
+            let mut bytes = Vec::new();
+            r.read_exact_vec(&mut bytes, entry_size * header.map_length as usize)?;
+
+            // Color maps are technically allowed in non-color-mapped images, so check that we
+            // actually need the color map before storing it.
+            if image_type.is_color_mapped() {
+                // Pre-expand 5-bit-per-primary values to simplify later decoding
+                if [15, 16].contains(&header.map_entry_size) {
+                    let mut expanded = Vec::new();
+                    for entry in bytes.chunks_exact(2) {
+                        expanded
+                            .extend_from_slice(&expand_rgb15_to_rgb24(entry.try_into().unwrap()));
+                    }
+                    bytes = expanded;
+                    entry_size = 3;
+                }
+
+                color_map = Some(ColorMap {
+                    entry_size,
+                    start_offset: header.map_origin as usize,
+                    bytes,
+                });
+            }
+        }
+
         Ok(TgaDecoder {
             r,
 
@@ -396,6 +422,15 @@ impl<R: Read> ImageDecoder for TgaDecoder<R> {
             rawbuf.extend_from_slice(&buf[..num_raw_bytes]);
 
             self.expand_color_map(&rawbuf, buf, color_map)?;
+        } else if self.original_color_type == Some(ExtendedColorType::Rgb5x1) {
+            // Expand the 15-bit to 24-bit representation for non-color-mapped images;
+            // the expansion for color-mapped 15-bit images was already done in the color map
+            let mut rawbuf = vec_try_with_capacity(num_raw_bytes)?;
+            rawbuf.extend_from_slice(&buf[..num_raw_bytes]);
+
+            for (src, dst) in rawbuf.chunks_exact(2).zip(buf.chunks_exact_mut(3)) {
+                dst.copy_from_slice(&expand_rgb15_to_rgb24(src.try_into().unwrap()));
+            }
         }
 
         self.reverse_encoding_in_output(buf);

src/codecs/tga/mod.rs

@@ -3,13 +3,8 @@
 //! # Related Links
 //! <http://googlesites.inequation.org/tgautilities>
 
-/// A decoder for TGA images
-///
-/// Currently this decoder does not support 8, 15 and 16 bit color images.
 pub use self::decoder::TgaDecoder;
 
-//TODO add 8, 15, 16 bit color support
-
 pub use self::encoder::TgaEncoder;
 
 mod decoder;

src/color.rs

@@ -125,6 +125,8 @@ pub enum ExtendedColorType {
     Rgb4,
     /// Pixel is 4-bit RGB with an alpha channel
     Rgba4,
+    /// Pixel contains 5-bit R, G and B channels packed into 2 bytes
+    Rgb5x1,
     /// Pixel is 8-bit luminance
     L8,
     /// Pixel is 8-bit luminance with an alpha channel
@@ -184,6 +186,7 @@ impl ExtendedColorType {
             ExtendedColorType::Rgb1
             | ExtendedColorType::Rgb2
             | ExtendedColorType::Rgb4
+            | ExtendedColorType::Rgb5x1
             | ExtendedColorType::Rgb8
             | ExtendedColorType::Rgb16
             | ExtendedColorType::Rgb32F
@@ -216,6 +219,7 @@ impl ExtendedColorType {
             ExtendedColorType::La4 => 8,
             ExtendedColorType::Rgb4 => 12,
             ExtendedColorType::Rgba4 => 16,
+            ExtendedColorType::Rgb5x1 => 16,
             ExtendedColorType::L8 => 8,
             ExtendedColorType::La8 => 16,
             ExtendedColorType::Rgb8 => 24,