pixelrush/src/main.rs

mod pixelflut;

use std::{
    io::{self, BufReader, Read},
    thread::JoinHandle,
};

use crossbeam::channel::*;
use pixelflut::*;

enum Message {
    Pixel(u32, u32, image::Rgba<u8>),
    Exit,
}

fn main() -> Result<(), std::io::Error> {
    let mut stdin_reader = BufReader::new(io::stdin());
    let mut image_buffer: Vec<u8> = Vec::new();
    let _ = stdin_reader.read_to_end(&mut image_buffer)?;
    let mut image = image::load_from_memory(&image_buffer).expect("Unable to read image format");

    let manager = PixelflutConnectionManager::new("localhost:1234")?;
    let pool = r2d2::Pool::builder()
        .max_size(16)
        .build(manager)
        .expect("Could not initialize connection pool");

    let image = image.as_rgba8().expect("Not a valid Image");

    let (sender, receiver) = unbounded::<Message>();
    let mut handles: Vec<JoinHandle<()>> = Vec::new();
    for _ in 0..16 {
        let r2 = receiver.clone();
        let p2 = pool.clone();
        let handle = std::thread::spawn(move || {
            let mut connection = match p2.get() {
                Ok(c) => c,
                Err(_) => return,
            };
            loop {
                match r2.recv().unwrap() {
                    Message::Pixel(x, y, c) => {
                        let _ = connection.set(x, y, c);
                    }
                    Message::Exit => return,
                }
            }
        });
        handles.push(handle);
    }

    for (x, y, p) in image.enumerate_pixels() {
        let _ = sender.send(Message::Pixel(x, y, p.clone()));
    }

    (0..16).for_each(|_| {
        let _ = sender.send(Message::Exit);
    });

    for thread in handles {
        let _ = thread.join();
    }

    Ok(())
}