gardesk/garshot / c9208e3

+//! JPEG encoding for garshot.

+

+use std::io::Cursor;

+use std::path::Path;

+

+use image::{ImageBuffer, RgbaImage};

+

+use crate::error::Result;

+

+/// Encode RGBA image data to JPEG file.

+pub fn encode_jpeg(data: &[u8], width: u32, height: u32, path: &Path, quality: u8) -> Result<()> {

+    let jpeg_data = encode_jpeg_to_vec(data, width, height, quality)?;

+    std::fs::write(path, jpeg_data)?;

+    Ok(())

+}

+

+/// Encode RGBA image data to JPEG bytes.

+pub fn encode_jpeg_to_vec(data: &[u8], width: u32, height: u32, quality: u8) -> Result<Vec<u8>> {

+    // Create image buffer from RGBA data

+    let img: RgbaImage = ImageBuffer::from_raw(width, height, data.to_vec())

+        .ok_or_else(|| crate::error::GarshotError::EncodeError("Invalid image dimensions".into()))?;

+

+    // Convert to RGB (JPEG doesn't support alpha)

+    let rgb_img = image::DynamicImage::ImageRgba8(img).to_rgb8();

+

+    // Encode to JPEG

+    let mut buffer = Cursor::new(Vec::new());

+    let mut encoder = image::codecs::jpeg::JpegEncoder::new_with_quality(&mut buffer, quality);

+    encoder

+        .encode(

+            rgb_img.as_raw(),

+            width,

+            height,

+            image::ExtendedColorType::Rgb8,

+        )

+        .map_err(|e| crate::error::GarshotError::EncodeError(e.to_string()))?;

+

+    Ok(buffer.into_inner())

+}

+

+#[cfg(test)]

+mod tests {

+    use super::*;

+

+    #[test]

+    fn test_encode_jpeg_to_vec() {

+        // Create a 2x2 red image

+        let data = vec![

+            255, 0, 0, 255, // Red pixel

+            255, 0, 0, 255, // Red pixel

+            255, 0, 0, 255, // Red pixel

+            255, 0, 0, 255, // Red pixel

+        ];

+

+        let jpeg_data = encode_jpeg_to_vec(&data, 2, 2, 90).unwrap();

+

+        // JPEG files start with FF D8 FF

+        assert!(jpeg_data.len() > 10);

+        assert_eq!(jpeg_data[0], 0xFF);

+        assert_eq!(jpeg_data[1], 0xD8);

+    }

+}

+pub mod jpeg;

+pub mod ppm;

+pub mod webp;

+pub use self::jpeg::{encode_jpeg, encode_jpeg_to_vec};

+pub use self::ppm::{encode_pam, encode_pam_to_vec, encode_ppm, encode_ppm_to_vec};

+pub use self::webp::{encode_webp, encode_webp_to_vec};

+    quality: u8,

+        "jpg" | "jpeg" => encode_jpeg(data, width, height, path, quality),

+        "webp" => encode_webp(data, width, height, path, quality),

+        "ppm" => encode_ppm(data, width, height, path),

+        "pam" => encode_pam(data, width, height, path),

+        _ => Err(GarshotError::EncodeError(format!(

+            "Unsupported format: {}",

+            format

+        ))),

+    }

+}

+

+/// Encode image data to bytes based on format.

+pub fn encode_to_vec(

+    data: &[u8],

+    width: u32,

+    height: u32,

+    format: &str,

+    quality: u8,

+) -> Result<Vec<u8>> {

+    match format.to_lowercase().as_str() {

+        "png" => encode_png_to_vec(data, width, height),

+        "jpg" | "jpeg" => encode_jpeg_to_vec(data, width, height, quality),

+        "webp" => encode_webp_to_vec(data, width, height, quality),

+        "ppm" => encode_ppm_to_vec(data, width, height),

+        "pam" => encode_pam_to_vec(data, width, height),

+//! PPM/PAM encoding for garshot.

+//!

+//! PPM (Portable Pixel Map) and PAM (Portable Arbitrary Map) are simple

+//! uncompressed formats, ideal for piping to other tools.

+

+use std::io::Write;

+use std::path::Path;

+

+use crate::error::Result;

+

+/// Encode RGBA image data to PPM file (RGB, no alpha).

+pub fn encode_ppm(data: &[u8], width: u32, height: u32, path: &Path) -> Result<()> {

+    let ppm_data = encode_ppm_to_vec(data, width, height)?;

+    std::fs::write(path, ppm_data)?;

+    Ok(())

+}

+

+/// Encode RGBA image data to PPM bytes (RGB, no alpha).

+pub fn encode_ppm_to_vec(data: &[u8], width: u32, height: u32) -> Result<Vec<u8>> {

+    let mut buffer = Vec::with_capacity(width as usize * height as usize * 3 + 50);

+

+    // PPM header: P6 (binary RGB)

+    writeln!(buffer, "P6")?;

+    writeln!(buffer, "{} {}", width, height)?;

+    writeln!(buffer, "255")?;

+

+    // Convert RGBA to RGB

+    for pixel in data.chunks_exact(4) {

+        buffer.push(pixel[0]); // R

+        buffer.push(pixel[1]); // G

+        buffer.push(pixel[2]); // B

+    }

+

+    Ok(buffer)

+}

+

+/// Encode RGBA image data to PAM file (with alpha).

+pub fn encode_pam(data: &[u8], width: u32, height: u32, path: &Path) -> Result<()> {

+    let pam_data = encode_pam_to_vec(data, width, height)?;

+    std::fs::write(path, pam_data)?;

+    Ok(())

+}

+

+/// Encode RGBA image data to PAM bytes (with alpha).

+pub fn encode_pam_to_vec(data: &[u8], width: u32, height: u32) -> Result<Vec<u8>> {

+    let mut buffer = Vec::with_capacity(data.len() + 100);

+

+    // PAM header

+    writeln!(buffer, "P7")?;

+    writeln!(buffer, "WIDTH {}", width)?;

+    writeln!(buffer, "HEIGHT {}", height)?;

+    writeln!(buffer, "DEPTH 4")?;

+    writeln!(buffer, "MAXVAL 255")?;

+    writeln!(buffer, "TUPLTYPE RGB_ALPHA")?;

+    writeln!(buffer, "ENDHDR")?;

+

+    // Raw RGBA data

+    buffer.extend_from_slice(data);

+

+    Ok(buffer)

+}

+

+#[cfg(test)]

+mod tests {

+    use super::*;

+

+    #[test]

+    fn test_encode_ppm_to_vec() {

+        // Create a 2x2 red image

+        let data = vec![

+            255, 0, 0, 255, // Red pixel

+            0, 255, 0, 255, // Green pixel

+            0, 0, 255, 255, // Blue pixel

+            255, 255, 255, 255, // White pixel

+        ];

+

+        let ppm_data = encode_ppm_to_vec(&data, 2, 2).unwrap();

+

+        // Check header starts correctly

+        assert!(ppm_data.starts_with(b"P6\n2 2\n255\n"));

+

+        // Header is "P6\n2 2\n255\n" = 11 bytes, then 12 bytes of pixel data

+        assert_eq!(ppm_data.len(), 11 + 12);

+    }

+

+    #[test]

+    fn test_encode_pam_to_vec() {

+        let data = vec![

+            255, 0, 0, 128, // Semi-transparent red

+            0, 255, 0, 255, // Opaque green

+        ];

+

+        let pam_data = encode_pam_to_vec(&data, 2, 1).unwrap();

+

+        // Check header contains expected elements

+        let header_str = String::from_utf8_lossy(&pam_data);

+        assert!(header_str.contains("P7"));

+        assert!(header_str.contains("WIDTH 2"));

+        assert!(header_str.contains("HEIGHT 1"));

+        assert!(header_str.contains("DEPTH 4"));

+        assert!(header_str.contains("TUPLTYPE RGB_ALPHA"));

+        assert!(header_str.contains("ENDHDR"));

+    }

+}

+//! WebP encoding for garshot.

+

+use std::io::Cursor;

+use std::path::Path;

+

+use image::{ImageBuffer, RgbaImage};

+

+use crate::error::Result;

+

+/// Encode RGBA image data to WebP file.

+pub fn encode_webp(data: &[u8], width: u32, height: u32, path: &Path, quality: u8) -> Result<()> {

+    let webp_data = encode_webp_to_vec(data, width, height, quality)?;

+    std::fs::write(path, webp_data)?;

+    Ok(())

+}

+

+/// Encode RGBA image data to WebP bytes.

+pub fn encode_webp_to_vec(data: &[u8], width: u32, height: u32, _quality: u8) -> Result<Vec<u8>> {

+    // Create image buffer from RGBA data

+    let img: RgbaImage = ImageBuffer::from_raw(width, height, data.to_vec())

+        .ok_or_else(|| crate::error::GarshotError::EncodeError("Invalid image dimensions".into()))?;

+

+    // Encode to WebP (lossless for screenshots)

+    let mut buffer = Cursor::new(Vec::new());

+    img.write_to(&mut buffer, image::ImageFormat::WebP)

+        .map_err(|e| crate::error::GarshotError::EncodeError(e.to_string()))?;

+

+    Ok(buffer.into_inner())

+}

+

+#[cfg(test)]

+mod tests {

+    use super::*;

+

+    #[test]

+    fn test_encode_webp_to_vec() {

+        // Create a 2x2 red image

+        let data = vec![

+            255, 0, 0, 255, // Red pixel

+            255, 0, 0, 255, // Red pixel

+            255, 0, 0, 255, // Red pixel

+            255, 0, 0, 255, // Red pixel

+        ];

+

+        let webp_data = encode_webp_to_vec(&data, 2, 2, 90).unwrap();

+

+        // WebP files start with RIFF header

+        assert!(webp_data.len() > 10);

+        assert_eq!(&webp_data[0..4], b"RIFF");

+        assert_eq!(&webp_data[8..12], b"WEBP");

+    }

+}