summaryrefslogtreecommitdiff
path: root/racer-tracer/src/image_action/png.rs
blob: c43e86332a1f1f8a803527b4f1fb8aae9e0623a0 (plain)
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
use std::{path::PathBuf, sync::RwLock};

use sha2::{Digest, Sha256};
use synchronoise::SignalEvent;

use crate::{config::Config, error::TracerError};

use super::ImageAction;

pub struct SavePng {}

impl ImageAction for SavePng {
    fn action(
        &self,
        screen_buffer: &RwLock<Vec<u32>>,
        _event: &SignalEvent,
        config: &Config,
    ) -> Result<(), TracerError> {
        screen_buffer
            .read()
            .map_err(|e| TracerError::FailedToAcquireLock(e.to_string()))
            .map(|buf| {
                // Convert ARGB8 to RGBA8
                buf.iter()
                    .map(|v| {
                        let a: u32 = (v >> 24) & 0xff;
                        let r: u32 = (v >> 16) & 0xff;
                        let g: u32 = (v >> 8) & 0xff;
                        let b: u32 = v & 0xff;

                        (r << 24) | (g << 16) | (b << 8) | a
                    })
                    .flat_map(|val| val.to_be_bytes())
                    .collect::<Vec<u8>>()
            })
            .and_then(|buf| match &config.image_output_dir {
                Some(image_dir) => {
                    println!("Saving image...");
                    let mut sha = Sha256::new();

                    sha.update(buf.as_slice());

                    let mut file_path = PathBuf::from(image_dir);
                    file_path.push(format!("{:X}.png", sha.finalize()));

                    img::save_buffer(
                        file_path.as_path(),
                        buf.as_slice(),
                        config.screen.width as u32,
                        config.screen.height as u32,
                        img::ColorType::Rgba8,
                    )
                    .map_err(|e| {
                        let error = e.to_string();
                        TracerError::ImageSave(error)
                    })
                    .map(|_| {
                        println!("Saved image to: {}", file_path.to_string_lossy());
                    })
                }
                None => Ok(()),
            })
    }
}