shade 0.0.5

Another graphics library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use std::{fs, io, path};

use super::{AnimatedImage, DecodedImage, Image, ImageRGBA};

pub const GIF_SIGNATURE_87A: &[u8] = b"GIF87a";
pub const GIF_SIGNATURE_89A: &[u8] = b"GIF89a";

//----------------------------------------------------------------
// Animated GIF loading

fn load_animated_file(path: &path::Path) -> Result<AnimatedImage, gif::DecodingError> {
	let file = fs::File::open(path).map_err(gif::DecodingError::Io)?;
	let reader = io::BufReader::new(file);
	load_animated_stream(reader)
}

fn load_animated_stream(stream: impl io::Read) -> Result<AnimatedImage, gif::DecodingError> {
	let mut opts = gif::DecodeOptions::new();
	opts.set_color_output(gif::ColorOutput::RGBA);
	let mut decoder = opts.read_info(stream)?;

	let width = decoder.width() as usize;
	let height = decoder.height() as usize;
	let len = width * height;

	let mut frames = Vec::new();
	let mut delays = Vec::new();
	while let Some(frame) = decoder.read_next_frame()? {
		// Add delay in seconds
		delays.push(frame.delay as i32 as f32 * 0.01);

		// Convert pixel data
		let pixels = frame.buffer.as_ref();
		assert_eq!(pixels.len(), len * 4);
		let mut data = Vec::with_capacity(len);
		for chunk in pixels.chunks_exact(4) {
			data.push([chunk[0], chunk[1], chunk[2], chunk[3]]);
		}

		// Create and add image frame
		let frame = crate::image::Image {
			width: width as i32,
			height: height as i32,
			data,
		};
		frames.push(frame);
	}

	let width = width as i32;
	let height = height as i32;
	let repeat = match decoder.repeat() {
		gif::Repeat::Infinite => true,
		gif::Repeat::Finite(count) => count > 0,
	};
	Ok(AnimatedImage { width, height, frames, delays, repeat })
}

impl AnimatedImage {
	/// Loads a GIF image from a file.
	#[inline]
	pub fn load_file_gif(path: impl AsRef<path::Path>) -> Result<Self, gif::DecodingError> {
		load_animated_file(path.as_ref())
	}
	/// Loads a GIF image from an I/O stream.
	#[inline]
	pub fn load_stream_gif(stream: impl io::Read) -> Result<Self, gif::DecodingError> {
		load_animated_stream(stream)
	}
	/// Loads a GIF image from memory.
	#[inline]
	pub fn load_memory_gif(mut data: &[u8]) -> Result<Self, gif::DecodingError> {
		load_animated_stream(&mut data)
	}
}

//----------------------------------------------------------------
// Single-frame GIF loading

fn load_single_file(path: &path::Path) -> Result<ImageRGBA, gif::DecodingError> {
	let file = fs::File::open(path).map_err(gif::DecodingError::Io)?;
	let reader = io::BufReader::new(file);
	load_single_stream(reader)
}

fn load_single_stream(stream: impl io::Read) -> Result<ImageRGBA, gif::DecodingError> {
	let mut opts = gif::DecodeOptions::new();
	opts.set_color_output(gif::ColorOutput::RGBA);
	let mut decoder = opts.read_info(stream)?;

	let width = decoder.width() as usize;
	let height = decoder.height() as usize;
	let len = width * height;

	let Some(frame) = decoder.read_next_frame()? else {
		return Err(gif::DecodingError::Io(io::Error::new(io::ErrorKind::UnexpectedEof, "No frames in GIF")));
	};

	// Convert pixel data
	let pixels = frame.buffer.as_ref();
	assert_eq!(pixels.len(), len * 4);
	let mut data = Vec::with_capacity(len);
	for chunk in pixels.chunks_exact(4) {
		data.push([chunk[0], chunk[1], chunk[2], chunk[3]]);
	}

	Ok(Image {
		width: width as i32,
		height: height as i32,
		data,
	})
}

impl DecodedImage {
	/// Loads a GIF image from a file.
	#[inline]
	pub fn load_file_gif(path: impl AsRef<path::Path>) -> Result<Self, gif::DecodingError> {
		let image = load_single_file(path.as_ref())?;
		Ok(DecodedImage::RGBA(image))
	}
	/// Loads a GIF image from an I/O stream.
	#[inline]
	pub fn load_stream_gif(stream: impl io::Read) -> Result<Self, gif::DecodingError> {
		let image = load_single_stream(stream)?;
		Ok(DecodedImage::RGBA(image))
	}
	/// Loads a GIF image from memory.
	#[inline]
	pub fn load_memory_gif(mut data: &[u8]) -> Result<Self, gif::DecodingError> {
		let image = load_single_stream(&mut data)?;
		Ok(DecodedImage::RGBA(image))
	}
}

impl<T> Image<T> where Image<T>: From<DecodedImage> {
	/// Loads a GIF image from a file.
	#[inline]
	pub fn load_file_gif(path: impl AsRef<path::Path>) -> Result<Self, gif::DecodingError> {
		let decoded = DecodedImage::load_file_gif(path)?;
		Ok(decoded.into())
	}
	/// Loads a GIF image from an I/O stream.
	#[inline]
	pub fn load_stream_gif(stream: impl io::Read) -> Result<Self, gif::DecodingError> {
		let decoded = DecodedImage::load_stream_gif(stream)?;
		Ok(decoded.into())
	}
	/// Loads a GIF image from memory.
	#[inline]
	pub fn load_memory_gif(mut data: &[u8]) -> Result<Self, gif::DecodingError> {
		let decoded = DecodedImage::load_memory_gif(&mut data)?;
		Ok(decoded.into())
	}
}