looklook 0.6.0

Descriptive signal synthesiser.
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

// Copyright 2026 Gabriel Bjørnager Jensen.
//
// This file is part of LOOKLOOK.
//
// LOOKLOOK is free software: you can redistribute
// it and/or modify it under the terms of the GNU
// Affero General Public License as published by
// the Free Software Foundation, either version 3
// of the License, or (at your option) any later
// version.
//
// LOOKLOOK is distributed in the hope that it will
// be useful, but WITHOUT ANY WARRANTY; without
// even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Affero General Public License for more details.
//
// You should have received a copy of the GNU Af-
// fero General Public License along with LOOKLOOK.
// If not, see <https://www.gnu.org/licenses/>.

//! The [`Blob::dump`] method.

use crate::signal::Blob;
use crate::config::{Config, Format};

use std::debug_assert_matches;
use std::fs::File;
use std::io::{self, Write};
use std::path::Path;

impl Blob<'_> {
	/// Dumps the blob.
	///
	/// # Errors
	///
	/// Any I/O errors are forwarded.
	pub fn dump<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
		let path = path.as_ref();

		eprintln!("dumping as `{}` at \"{}\"", self.config().format.as_str(), path.display());

		let mut file = File::create_buffered(path)?;

		match self.config().format {
			Format::Png => {
				Self::dump_png_frame(self.config(), self.data(), &mut file)?;
			}

			_ => {
				unimplemented!();
			}
		}

		Ok(())
	}

	/// Dumps the encoded render as video.
	///
	/// # Errors
	///
	/// Any I/O errors are forwarded.
	fn dump_png_frame<W: ?Sized + Write>(config: &Config, data: &[u8], w: &mut W) -> io::Result<()> {
		debug_assert_matches!(config.format, Format::Png);

		let mut encoder = png::Encoder::new(w, config.width.into(), config.height.into());

		let colour_type = match config.channel_count {
			1 => png::ColorType::Grayscale,
			2 => png::ColorType::GrayscaleAlpha,
			3 => png::ColorType::Rgb,
			4 => png::ColorType::Rgba,

			count => {
				unimplemented!("channel count of `{count}` is not supported for PNG");
			}
		};

		let bit_depth = match config.sample_depth {
			1 => png::BitDepth::Eight,
			2 => png::BitDepth::Sixteen,

			depth => {
				unimplemented!("sampling depth of `{depth}B` is not supported for PNG");
			}
		};

		encoder.set_color(colour_type);
		encoder.set_depth(bit_depth);

		let mut w = encoder.write_header()?;
		w.write_image_data(data)?;

		Ok(())
	}
}