Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

1 files changed, 375 insertions, 0 deletions

diff --git a/vendor/image/src/codecs/dds.rs b/vendor/image/src/codecs/dds.rs
new file mode 100644
index 0000000..f0a7357
--- /dev/null
+++ b/vendor/image/src/codecs/dds.rs
@@ -0,0 +1,375 @@
+//!  Decoding of DDS images
+//!
+//!  DDS (DirectDraw Surface) is a container format for storing DXT (S3TC) compressed images.
+//!
+//!  # Related Links
+//!  * <https://docs.microsoft.com/en-us/windows/win32/direct3ddds/dx-graphics-dds-pguide> - Description of the DDS format.
+
+use std::io::Read;
+use std::{error, fmt};
+
+use byteorder::{LittleEndian, ReadBytesExt};
+
+#[allow(deprecated)]
+use crate::codecs::dxt::{DxtDecoder, DxtReader, DxtVariant};
+use crate::color::ColorType;
+use crate::error::{
+    DecodingError, ImageError, ImageFormatHint, ImageResult, UnsupportedError, UnsupportedErrorKind,
+};
+use crate::image::{ImageDecoder, ImageFormat};
+
+/// Errors that can occur during decoding and parsing a DDS image
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
+enum DecoderError {
+    /// Wrong DDS channel width
+    PixelFormatSizeInvalid(u32),
+    /// Wrong DDS header size
+    HeaderSizeInvalid(u32),
+    /// Wrong DDS header flags
+    HeaderFlagsInvalid(u32),
+
+    /// Invalid DXGI format in DX10 header
+    DxgiFormatInvalid(u32),
+    /// Invalid resource dimension
+    ResourceDimensionInvalid(u32),
+    /// Invalid flags in DX10 header
+    Dx10FlagsInvalid(u32),
+    /// Invalid array size in DX10 header
+    Dx10ArraySizeInvalid(u32),
+
+    /// DDS "DDS " signature invalid or missing
+    DdsSignatureInvalid,
+}
+
+impl fmt::Display for DecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            DecoderError::PixelFormatSizeInvalid(s) => {
+                f.write_fmt(format_args!("Invalid DDS PixelFormat size: {}", s))
+            }
+            DecoderError::HeaderSizeInvalid(s) => {
+                f.write_fmt(format_args!("Invalid DDS header size: {}", s))
+            }
+            DecoderError::HeaderFlagsInvalid(fs) => {
+                f.write_fmt(format_args!("Invalid DDS header flags: {:#010X}", fs))
+            }
+            DecoderError::DxgiFormatInvalid(df) => {
+                f.write_fmt(format_args!("Invalid DDS DXGI format: {}", df))
+            }
+            DecoderError::ResourceDimensionInvalid(d) => {
+                f.write_fmt(format_args!("Invalid DDS resource dimension: {}", d))
+            }
+            DecoderError::Dx10FlagsInvalid(fs) => {
+                f.write_fmt(format_args!("Invalid DDS DX10 header flags: {:#010X}", fs))
+            }
+            DecoderError::Dx10ArraySizeInvalid(s) => {
+                f.write_fmt(format_args!("Invalid DDS DX10 array size: {}", s))
+            }
+            DecoderError::DdsSignatureInvalid => f.write_str("DDS signature not found"),
+        }
+    }
+}
+
+impl From<DecoderError> for ImageError {
+    fn from(e: DecoderError) -> ImageError {
+        ImageError::Decoding(DecodingError::new(ImageFormat::Dds.into(), e))
+    }
+}
+
+impl error::Error for DecoderError {}
+
+/// Header used by DDS image files
+#[derive(Debug)]
+struct Header {
+    _flags: u32,
+    height: u32,
+    width: u32,
+    _pitch_or_linear_size: u32,
+    _depth: u32,
+    _mipmap_count: u32,
+    pixel_format: PixelFormat,
+    _caps: u32,
+    _caps2: u32,
+}
+
+/// Extended DX10 header used by some DDS image files
+#[derive(Debug)]
+struct DX10Header {
+    dxgi_format: u32,
+    resource_dimension: u32,
+    misc_flag: u32,
+    array_size: u32,
+    misc_flags_2: u32,
+}
+
+/// DDS pixel format
+#[derive(Debug)]
+struct PixelFormat {
+    flags: u32,
+    fourcc: [u8; 4],
+    _rgb_bit_count: u32,
+    _r_bit_mask: u32,
+    _g_bit_mask: u32,
+    _b_bit_mask: u32,
+    _a_bit_mask: u32,
+}
+
+impl PixelFormat {
+    fn from_reader(r: &mut dyn Read) -> ImageResult<Self> {
+        let size = r.read_u32::<LittleEndian>()?;
+        if size != 32 {
+            return Err(DecoderError::PixelFormatSizeInvalid(size).into());
+        }
+
+        Ok(Self {
+            flags: r.read_u32::<LittleEndian>()?,
+            fourcc: {
+                let mut v = [0; 4];
+                r.read_exact(&mut v)?;
+                v
+            },
+            _rgb_bit_count: r.read_u32::<LittleEndian>()?,
+            _r_bit_mask: r.read_u32::<LittleEndian>()?,
+            _g_bit_mask: r.read_u32::<LittleEndian>()?,
+            _b_bit_mask: r.read_u32::<LittleEndian>()?,
+            _a_bit_mask: r.read_u32::<LittleEndian>()?,
+        })
+    }
+}
+
+impl Header {
+    fn from_reader(r: &mut dyn Read) -> ImageResult<Self> {
+        let size = r.read_u32::<LittleEndian>()?;
+        if size != 124 {
+            return Err(DecoderError::HeaderSizeInvalid(size).into());
+        }
+
+        const REQUIRED_FLAGS: u32 = 0x1 | 0x2 | 0x4 | 0x1000;
+        const VALID_FLAGS: u32 = 0x1 | 0x2 | 0x4 | 0x8 | 0x1000 | 0x20000 | 0x80000 | 0x800000;
+        let flags = r.read_u32::<LittleEndian>()?;
+        if flags & (REQUIRED_FLAGS | !VALID_FLAGS) != REQUIRED_FLAGS {
+            return Err(DecoderError::HeaderFlagsInvalid(flags).into());
+        }
+
+        let height = r.read_u32::<LittleEndian>()?;
+        let width = r.read_u32::<LittleEndian>()?;
+        let pitch_or_linear_size = r.read_u32::<LittleEndian>()?;
+        let depth = r.read_u32::<LittleEndian>()?;
+        let mipmap_count = r.read_u32::<LittleEndian>()?;
+        // Skip `dwReserved1`
+        {
+            let mut skipped = [0; 4 * 11];
+            r.read_exact(&mut skipped)?;
+        }
+        let pixel_format = PixelFormat::from_reader(r)?;
+        let caps = r.read_u32::<LittleEndian>()?;
+        let caps2 = r.read_u32::<LittleEndian>()?;
+        // Skip `dwCaps3`, `dwCaps4`, `dwReserved2` (unused)
+        {
+            let mut skipped = [0; 4 + 4 + 4];
+            r.read_exact(&mut skipped)?;
+        }
+
+        Ok(Self {
+            _flags: flags,
+            height,
+            width,
+            _pitch_or_linear_size: pitch_or_linear_size,
+            _depth: depth,
+            _mipmap_count: mipmap_count,
+            pixel_format,
+            _caps: caps,
+            _caps2: caps2,
+        })
+    }
+}
+
+impl DX10Header {
+    fn from_reader(r: &mut dyn Read) -> ImageResult<Self> {
+        let dxgi_format = r.read_u32::<LittleEndian>()?;
+        let resource_dimension = r.read_u32::<LittleEndian>()?;
+        let misc_flag = r.read_u32::<LittleEndian>()?;
+        let array_size = r.read_u32::<LittleEndian>()?;
+        let misc_flags_2 = r.read_u32::<LittleEndian>()?;
+
+        let dx10_header = Self {
+            dxgi_format,
+            resource_dimension,
+            misc_flag,
+            array_size,
+            misc_flags_2,
+        };
+        dx10_header.validate()?;
+
+        Ok(dx10_header)
+    }
+
+    fn validate(&self) -> Result<(), ImageError> {
+        // Note: see https://docs.microsoft.com/en-us/windows/win32/direct3ddds/dds-header-dxt10 for info on valid values
+        if self.dxgi_format > 132 {
+            // Invalid format
+            return Err(DecoderError::DxgiFormatInvalid(self.dxgi_format).into());
+        }
+
+        if self.resource_dimension < 2 || self.resource_dimension > 4 {
+            // Invalid dimension
+            // Only 1D (2), 2D (3) and 3D (4) resource dimensions are allowed
+            return Err(DecoderError::ResourceDimensionInvalid(self.resource_dimension).into());
+        }
+
+        if self.misc_flag != 0x0 && self.misc_flag != 0x4 {
+            // Invalid flag
+            // Only no (0x0) and DDS_RESOURCE_MISC_TEXTURECUBE (0x4) flags are allowed
+            return Err(DecoderError::Dx10FlagsInvalid(self.misc_flag).into());
+        }
+
+        if self.resource_dimension == 4 && self.array_size != 1 {
+            // Invalid array size
+            // 3D textures (resource dimension == 4) must have an array size of 1
+            return Err(DecoderError::Dx10ArraySizeInvalid(self.array_size).into());
+        }
+
+        if self.misc_flags_2 > 0x4 {
+            // Invalid alpha flags
+            return Err(DecoderError::Dx10FlagsInvalid(self.misc_flags_2).into());
+        }
+
+        Ok(())
+    }
+}
+
+/// The representation of a DDS decoder
+pub struct DdsDecoder<R: Read> {
+    #[allow(deprecated)]
+    inner: DxtDecoder<R>,
+}
+
+impl<R: Read> DdsDecoder<R> {
+    /// Create a new decoder that decodes from the stream `r`
+    pub fn new(mut r: R) -> ImageResult<Self> {
+        let mut magic = [0; 4];
+        r.read_exact(&mut magic)?;
+        if magic != b"DDS "[..] {
+            return Err(DecoderError::DdsSignatureInvalid.into());
+        }
+
+        let header = Header::from_reader(&mut r)?;
+
+        if header.pixel_format.flags & 0x4 != 0 {
+            #[allow(deprecated)]
+            let variant = match &header.pixel_format.fourcc {
+                b"DXT1" => DxtVariant::DXT1,
+                b"DXT3" => DxtVariant::DXT3,
+                b"DXT5" => DxtVariant::DXT5,
+                b"DX10" => {
+                    let dx10_header = DX10Header::from_reader(&mut r)?;
+                    // Format equivalents were taken from https://docs.microsoft.com/en-us/windows/win32/direct3d11/texture-block-compression-in-direct3d-11
+                    // The enum integer values were taken from https://docs.microsoft.com/en-us/windows/win32/api/dxgiformat/ne-dxgiformat-dxgi_format
+                    // DXT1 represents the different BC1 variants, DTX3 represents the different BC2 variants and DTX5 represents the different BC3 variants
+                    match dx10_header.dxgi_format {
+                        70 | 71 | 72 => DxtVariant::DXT1, // DXGI_FORMAT_BC1_TYPELESS, DXGI_FORMAT_BC1_UNORM or DXGI_FORMAT_BC1_UNORM_SRGB
+                        73 | 74 | 75 => DxtVariant::DXT3, // DXGI_FORMAT_BC2_TYPELESS, DXGI_FORMAT_BC2_UNORM or DXGI_FORMAT_BC2_UNORM_SRGB
+                        76 | 77 | 78 => DxtVariant::DXT5, // DXGI_FORMAT_BC3_TYPELESS, DXGI_FORMAT_BC3_UNORM or DXGI_FORMAT_BC3_UNORM_SRGB
+                        _ => {
+                            return Err(ImageError::Unsupported(
+                                UnsupportedError::from_format_and_kind(
+                                    ImageFormat::Dds.into(),
+                                    UnsupportedErrorKind::GenericFeature(format!(
+                                        "DDS DXGI Format {}",
+                                        dx10_header.dxgi_format
+                                    )),
+                                ),
+                            ))
+                        }
+                    }
+                }
+                fourcc => {
+                    return Err(ImageError::Unsupported(
+                        UnsupportedError::from_format_and_kind(
+                            ImageFormat::Dds.into(),
+                            UnsupportedErrorKind::GenericFeature(format!(
+                                "DDS FourCC {:?}",
+                                fourcc
+                            )),
+                        ),
+                    ))
+                }
+            };
+
+            #[allow(deprecated)]
+            let bytes_per_pixel = variant.color_type().bytes_per_pixel();
+
+            if crate::utils::check_dimension_overflow(header.width, header.height, bytes_per_pixel)
+            {
+                return Err(ImageError::Unsupported(
+                    UnsupportedError::from_format_and_kind(
+                        ImageFormat::Dds.into(),
+                        UnsupportedErrorKind::GenericFeature(format!(
+                            "Image dimensions ({}x{}) are too large",
+                            header.width, header.height
+                        )),
+                    ),
+                ));
+            }
+
+            #[allow(deprecated)]
+            let inner = DxtDecoder::new(r, header.width, header.height, variant)?;
+            Ok(Self { inner })
+        } else {
+            // For now, supports only DXT variants
+            Err(ImageError::Unsupported(
+                UnsupportedError::from_format_and_kind(
+                    ImageFormat::Dds.into(),
+                    UnsupportedErrorKind::Format(ImageFormatHint::Name("DDS".to_string())),
+                ),
+            ))
+        }
+    }
+}
+
+impl<'a, R: 'a + Read> ImageDecoder<'a> for DdsDecoder<R> {
+    #[allow(deprecated)]
+    type Reader = DxtReader<R>;
+
+    fn dimensions(&self) -> (u32, u32) {
+        self.inner.dimensions()
+    }
+
+    fn color_type(&self) -> ColorType {
+        self.inner.color_type()
+    }
+
+    fn scanline_bytes(&self) -> u64 {
+        self.inner.scanline_bytes()
+    }
+
+    fn into_reader(self) -> ImageResult<Self::Reader> {
+        self.inner.into_reader()
+    }
+
+    fn read_image(self, buf: &mut [u8]) -> ImageResult<()> {
+        self.inner.read_image(buf)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn dimension_overflow() {
+        // A DXT1 header set to 0xFFFF_FFFC width and height (the highest u32%4 == 0)
+        let header = vec![
+            0x44, 0x44, 0x53, 0x20, 0x7C, 0x0, 0x0, 0x0, 0x7, 0x10, 0x8, 0x0, 0xFC, 0xFF, 0xFF,
+            0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0x0, 0xC0, 0x12, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0,
+            0x0, 0x49, 0x4D, 0x41, 0x47, 0x45, 0x4D, 0x41, 0x47, 0x49, 0x43, 0x4B, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0,
+            0x4, 0x0, 0x0, 0x0, 0x44, 0x58, 0x54, 0x31, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+        ];
+
+        assert!(DdsDecoder::new(&header[..]).is_err());
+    }
+}