1use rustbasic_core::webp::Encoder;
2use rustbasic_core::image;
3use rustbasic_core::serde::{Serialize, Deserialize};
4use std::path::Path;
5use std::fs;
6
7#[derive(Debug, Clone, Serialize, Deserialize)]
9#[serde(crate = "rustbasic_core::serde")]
10pub struct ImageInfo {
11 pub width: u32,
12 pub height: u32,
13 pub format: String,
14 pub size_bytes: usize,
15}
16
17pub fn get_image_info(image_data: &[u8]) -> Result<ImageInfo, String> {
19 let format = image::guess_format(image_data)
20 .map_err(|e| format!("Gagal mendeteksi format gambar: {}", e))?;
21
22 let img = image::load_from_memory(image_data)
23 .map_err(|e| format!("Gagal memuat gambar untuk membaca info: {}", e))?;
24
25 let format_str = format!("{:?}", format);
26
27 Ok(ImageInfo {
28 width: img.width(),
29 height: img.height(),
30 format: format_str,
31 size_bytes: image_data.len(),
32 })
33}
34
35pub fn convert_to_webp(image_data: &[u8], quality: f32) -> Result<Vec<u8>, String> {
37 let img = image::load_from_memory(image_data)
39 .map_err(|e| format!("Gagal memuat gambar dari memori: {}", e))?;
40
41 let encoder = Encoder::from_image(&img)
43 .map_err(|e| format!("Gagal menginisialisasi encoder WebP: {:?}", e))?;
44
45 let webp_memory = encoder.encode(quality);
46 Ok(webp_memory.to_vec())
47}
48
49pub fn convert_and_resize(image_data: &[u8], max_width: u32, max_height: u32, quality: f32) -> Result<Vec<u8>, String> {
51 let img = image::load_from_memory(image_data)
52 .map_err(|e| format!("Gagal memuat gambar dari memori: {}", e))?;
53
54 let resized = img.resize(max_width, max_height, image::imageops::FilterType::Lanczos3);
56
57 let encoder = Encoder::from_image(&resized)
58 .map_err(|e| format!("Gagal menginisialisasi encoder WebP: {:?}", e))?;
59
60 let webp_memory = encoder.encode(quality);
61 Ok(webp_memory.to_vec())
62}
63
64pub fn convert_and_resize_width(image_data: &[u8], max_width: u32, quality: f32) -> Result<Vec<u8>, String> {
66 let img = image::load_from_memory(image_data)
67 .map_err(|e| format!("Gagal memuat gambar dari memori: {}", e))?;
68
69 let resized = img.resize(max_width, u32::MAX, image::imageops::FilterType::Lanczos3);
70
71 let encoder = Encoder::from_image(&resized)
72 .map_err(|e| format!("Gagal menginisialisasi encoder WebP: {:?}", e))?;
73
74 let webp_memory = encoder.encode(quality);
75 Ok(webp_memory.to_vec())
76}
77
78pub fn convert_and_resize_height(image_data: &[u8], max_height: u32, quality: f32) -> Result<Vec<u8>, String> {
80 let img = image::load_from_memory(image_data)
81 .map_err(|e| format!("Gagal memuat gambar dari memori: {}", e))?;
82
83 let resized = img.resize(u32::MAX, max_height, image::imageops::FilterType::Lanczos3);
84
85 let encoder = Encoder::from_image(&resized)
86 .map_err(|e| format!("Gagal menginisialisasi encoder WebP: {:?}", e))?;
87
88 let webp_memory = encoder.encode(quality);
89 Ok(webp_memory.to_vec())
90}
91
92pub fn convert_file_to_webp<P: AsRef<Path>>(input_path: P, output_path: P, quality: f32) -> Result<(), String> {
94 let data = fs::read(input_path).map_err(|e| format!("Gagal membaca file input: {}", e))?;
95 let webp_data = convert_to_webp(&data, quality)?;
96 fs::write(output_path, webp_data).map_err(|e| format!("Gagal menulis file output: {}", e))?;
97 Ok(())
98}
99
100#[cfg(test)]
101mod tests {
102 use super::*;
103 use rustbasic_core::image::{ImageBuffer, Rgb};
104
105 fn create_test_image_bytes() -> Vec<u8> {
106 let img = ImageBuffer::from_fn(100, 100, |x, y| {
107 if (x + y) % 2 == 0 {
108 Rgb([255, 0, 0])
109 } else {
110 Rgb([0, 255, 0])
111 }
112 });
113 let dynamic_img = image::DynamicImage::ImageRgb8(img);
114 let mut cursor = std::io::Cursor::new(Vec::new());
115 dynamic_img.write_to(&mut cursor, image::ImageFormat::Png).unwrap();
116 cursor.into_inner()
117 }
118
119 #[test]
120 fn test_convert_to_webp() {
121 let png_bytes = create_test_image_bytes();
122 let webp_bytes = convert_to_webp(&png_bytes, 80.0).unwrap();
123 assert!(!webp_bytes.is_empty());
124
125 let info = get_image_info(&webp_bytes).unwrap();
126 assert_eq!(info.format, "WebP");
127 assert_eq!(info.width, 100);
128 assert_eq!(info.height, 100);
129 }
130
131 #[test]
132 fn test_convert_and_resize() {
133 let png_bytes = create_test_image_bytes();
134 let webp_bytes = convert_and_resize(&png_bytes, 50, 50, 80.0).unwrap();
135 let info = get_image_info(&webp_bytes).unwrap();
136 assert_eq!(info.width, 50);
137 assert_eq!(info.height, 50);
138 }
139
140 #[test]
141 fn test_convert_and_resize_width() {
142 let png_bytes = create_test_image_bytes();
143 let webp_bytes = convert_and_resize_width(&png_bytes, 40, 80.0).unwrap();
144 let info = get_image_info(&webp_bytes).unwrap();
145 assert_eq!(info.width, 40);
146 assert_eq!(info.height, 40); }
148
149 #[test]
150 fn test_convert_and_resize_height() {
151 let png_bytes = create_test_image_bytes();
152 let webp_bytes = convert_and_resize_height(&png_bytes, 30, 80.0).unwrap();
153 let info = get_image_info(&webp_bytes).unwrap();
154 assert_eq!(info.width, 30); assert_eq!(info.height, 30);
156 }
157}
158