]> git.nihav.org Git - nihav.git/blob - nihav-core/src/formats.rs
core/compr: make code length limiting in deflate actually work
[nihav.git] / nihav-core / src / formats.rs
1 //! Audio and image sample format definitions.
2 //!
3 //! NihAV does not have a fixed list of supported formats but rather accepts format definitions both for audio and video.
4 //! In result exotic formats like YUV410+alpha plane that is used by Indeo 4 are supported without any additional case handing.
5 //! Some common format definitions are provided as constants for convenience.
6 use std::str::FromStr;
7 use std::string::*;
8 use std::fmt;
9
10 /// Generic format parsing error.
11 #[derive(Clone,Copy,Debug,PartialEq)]
12 pub struct FormatParseError {}
13
14 /// Audio format definition.
15 ///
16 /// The structure describes how audio samples are stored and what characteristics they have.
17 #[derive(Debug,Copy,Clone,PartialEq)]
18 pub struct NASoniton {
19 /// Bits per sample.
20 pub bits: u8,
21 /// Audio format is big-endian.
22 pub be: bool,
23 /// Audio samples are packed (e.g. 20-bit audio samples).
24 pub packed: bool,
25 /// Audio data is stored in planar format instead of interleaving samples for different channels.
26 pub planar: bool,
27 /// Audio data is in floating point format.
28 pub float: bool,
29 /// Audio data is signed (usually only 8-bit audio is unsigned).
30 pub signed: bool,
31 }
32
33 /// Flag for specifying that audio format is big-endian in `NASoniton::`[`new`]`()`. Related to [`be`] field of `NASoniton`.
34 ///
35 /// [`new`]: ./struct.NASoniton.html#method.new
36 /// [`be`]: ./struct.NASoniton.html#structfield.be
37 pub const SONITON_FLAG_BE :u32 = 0x01;
38 /// Flag for specifying that audio format has packed samples in `NASoniton::`[`new`]`()`. Related to [`packed`] field of `NASoniton`.
39 ///
40 /// [`new`]: ./struct.NASoniton.html#method.new
41 /// [`packed`]: ./struct.NASoniton.html#structfield.packed
42 pub const SONITON_FLAG_PACKED :u32 = 0x02;
43 /// Flag for specifying that audio data is stored as planar in `NASoniton::`[`new`]`()`. Related to [`planar`] field of `NASoniton`.
44 ///
45 /// [`new`]: ./struct.NASoniton.html#method.new
46 /// [`planar`]: ./struct.NASoniton.html#structfield.planar
47 pub const SONITON_FLAG_PLANAR :u32 = 0x04;
48 /// Flag for specifying that audio samples are in floating point format in `NASoniton::`[`new`]`()`. Related to [`float`] field of `NASoniton`.
49 ///
50 /// [`new`]: ./struct.NASoniton.html#method.new
51 /// [`float`]: ./struct.NASoniton.html#structfield.float
52 pub const SONITON_FLAG_FLOAT :u32 = 0x08;
53 /// Flag for specifying that audio format is signed in `NASoniton::`[`new`]`()`. Related to [`signed`] field of `NASoniton`.
54 ///
55 /// [`new`]: ./struct.NASoniton.html#method.new
56 /// [`signed`]: ./struct.NASoniton.html#structfield.signed
57 pub const SONITON_FLAG_SIGNED :u32 = 0x10;
58
59 /// Predefined format for interleaved 8-bit unsigned audio.
60 pub const SND_U8_FORMAT: NASoniton = NASoniton { bits: 8, be: false, packed: false, planar: false, float: false, signed: false };
61 /// Predefined format for interleaved 16-bit signed audio.
62 pub const SND_S16_FORMAT: NASoniton = NASoniton { bits: 16, be: false, packed: false, planar: false, float: false, signed: true };
63 /// Predefined format for planar 16-bit signed audio.
64 pub const SND_S16P_FORMAT: NASoniton = NASoniton { bits: 16, be: false, packed: false, planar: true, float: false, signed: true };
65 /// Predefined format for planar 32-bit signed audio.
66 pub const SND_S32P_FORMAT: NASoniton = NASoniton { bits: 32, be: false, packed: false, planar: true, float: false, signed: true };
67 /// Predefined format for planar 32-bit floating point audio.
68 pub const SND_F32P_FORMAT: NASoniton = NASoniton { bits: 32, be: false, packed: false, planar: true, float: true, signed: true };
69
70 impl NASoniton {
71 /// Constructs a new audio format definition using flags like [`SONITON_FLAG_BE`].
72 ///
73 /// [`SONITON_FLAG_BE`]: ./constant.SONITON_FLAG_BE.html
74 pub fn new(bits: u8, flags: u32) -> Self {
75 let is_be = (flags & SONITON_FLAG_BE) != 0;
76 let is_pk = (flags & SONITON_FLAG_PACKED) != 0;
77 let is_pl = (flags & SONITON_FLAG_PLANAR) != 0;
78 let is_fl = (flags & SONITON_FLAG_FLOAT) != 0;
79 let is_sg = (flags & SONITON_FLAG_SIGNED) != 0;
80 NASoniton { bits, be: is_be, packed: is_pk, planar: is_pl, float: is_fl, signed: is_sg }
81 }
82
83 /// Returns the number of bits per sample.
84 pub fn get_bits(self) -> u8 { self.bits }
85 /// Reports whether the format is big-endian.
86 pub fn is_be(self) -> bool { self.be }
87 /// Reports whether the format has packed samples.
88 pub fn is_packed(self) -> bool { self.packed }
89 /// Reports whether audio data is planar instead of interleaved.
90 pub fn is_planar(self) -> bool { self.planar }
91 /// Reports whether audio samples are in floating point format.
92 pub fn is_float(self) -> bool { self.float }
93 /// Reports whether audio samples are signed.
94 pub fn is_signed(self) -> bool { self.signed }
95
96 /// Returns the amount of bytes needed to store the audio of requested length (in samples).
97 pub fn get_audio_size(self, length: u64) -> usize {
98 if self.packed {
99 ((length * u64::from(self.bits) + 7) >> 3) as usize
100 } else {
101 (length * u64::from((self.bits + 7) >> 3)) as usize
102 }
103 }
104
105 /// Returns soniton description as a short string.
106 pub fn to_short_string(self) -> String {
107 let ltype = if self.float { 'f' } else if self.signed { 's' } else { 'u' };
108 let endianness = if self.bits == 8 { "" } else if self.be { "be" } else { "le" };
109 let planar = if self.planar { "p" } else { "" };
110 let packed = if self.packed { "x" } else { "" };
111 format!("{}{}{}{}{}", ltype, self.bits, endianness, planar, packed)
112 }
113 }
114
115 impl fmt::Display for NASoniton {
116 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
117 let fmt = if self.float { "float" } else if self.signed { "int" } else { "uint" };
118 let end = if self.be { "BE" } else { "LE" };
119 write!(f, "({} bps, {} planar: {} packed: {} {})", self.bits, end, self.planar, self.packed, fmt)
120 }
121 }
122
123 impl FromStr for NASoniton {
124 type Err = FormatParseError;
125
126 fn from_str(s: &str) -> Result<Self, Self::Err> {
127 match s {
128 "u8" => Ok(NASoniton { bits: 8, be: true, packed: false, planar: false, float: false, signed: false }),
129 "s16be" => Ok(NASoniton { bits: 16, be: true, packed: false, planar: false, float: false, signed: true }),
130 "s16le" => Ok(NASoniton { bits: 16, be: false, packed: false, planar: false, float: false, signed: true }),
131 "s24be" => Ok(NASoniton { bits: 24, be: true, packed: false, planar: false, float: false, signed: true }),
132 "s24le" => Ok(NASoniton { bits: 24, be: false, packed: false, planar: false, float: false, signed: true }),
133 "s32be" => Ok(NASoniton { bits: 32, be: true, packed: false, planar: false, float: false, signed: true }),
134 "s32le" => Ok(NASoniton { bits: 32, be: false, packed: false, planar: false, float: false, signed: true }),
135 "f32be" => Ok(NASoniton { bits: 32, be: true, packed: false, planar: false, float: true, signed: true }),
136 "f32le" => Ok(NASoniton { bits: 32, be: false, packed: false, planar: false, float: true, signed: true }),
137 _ => Err(FormatParseError{}),
138 }
139 }
140 }
141
142 /// Known channel types.
143 #[derive(Debug,Clone,Copy,PartialEq)]
144 pub enum NAChannelType {
145 C, L, R, Cs, Ls, Rs, Lss, Rss, LFE, Lc, Rc, Lh, Rh, Ch, LFE2, Lw, Rw, Ov, Lhs, Rhs, Chs, Ll, Rl, Cl, Lt, Rt, Lo, Ro
146 }
147
148 impl NAChannelType {
149 /// Reports whether this is some center channel.
150 pub fn is_center(self) -> bool {
151 matches!(self,
152 NAChannelType::C | NAChannelType::Ch |
153 NAChannelType::Cl | NAChannelType::Ov |
154 NAChannelType::LFE | NAChannelType::LFE2 |
155 NAChannelType::Cs | NAChannelType::Chs)
156 }
157 /// Reports whether this is some left channel.
158 pub fn is_left(self) -> bool {
159 matches!(self,
160 NAChannelType::L | NAChannelType::Ls |
161 NAChannelType::Lss | NAChannelType::Lc |
162 NAChannelType::Lh | NAChannelType::Lw |
163 NAChannelType::Lhs | NAChannelType::Ll |
164 NAChannelType::Lt | NAChannelType::Lo)
165 }
166 /// Reports whether this is some right channel.
167 pub fn is_right(self) -> bool {
168 matches!(self,
169 NAChannelType::R | NAChannelType::Rs |
170 NAChannelType::Rss | NAChannelType::Rc |
171 NAChannelType::Rh | NAChannelType::Rw |
172 NAChannelType::Rhs | NAChannelType::Rl |
173 NAChannelType::Rt | NAChannelType::Ro)
174 }
175 }
176
177 impl FromStr for NAChannelType {
178 type Err = FormatParseError;
179
180 fn from_str(s: &str) -> Result<Self, Self::Err> {
181 match s {
182 "C" => Ok(NAChannelType::C),
183 "L" => Ok(NAChannelType::L),
184 "R" => Ok(NAChannelType::R),
185 "Cs" => Ok(NAChannelType::Cs),
186 "Ls" => Ok(NAChannelType::Ls),
187 "Rs" => Ok(NAChannelType::Rs),
188 "Lss" => Ok(NAChannelType::Lss),
189 "Rss" => Ok(NAChannelType::Rss),
190 "LFE" => Ok(NAChannelType::LFE),
191 "Lc" => Ok(NAChannelType::Lc),
192 "Rc" => Ok(NAChannelType::Rc),
193 "Lh" => Ok(NAChannelType::Lh),
194 "Rh" => Ok(NAChannelType::Rh),
195 "Ch" => Ok(NAChannelType::Ch),
196 "LFE2" => Ok(NAChannelType::LFE2),
197 "Lw" => Ok(NAChannelType::Lw),
198 "Rw" => Ok(NAChannelType::Rw),
199 "Ov" => Ok(NAChannelType::Ov),
200 "Lhs" => Ok(NAChannelType::Lhs),
201 "Rhs" => Ok(NAChannelType::Rhs),
202 "Chs" => Ok(NAChannelType::Chs),
203 "Ll" => Ok(NAChannelType::Ll),
204 "Rl" => Ok(NAChannelType::Rl),
205 "Cl" => Ok(NAChannelType::Cl),
206 "Lt" => Ok(NAChannelType::Lt),
207 "Rt" => Ok(NAChannelType::Rt),
208 "Lo" => Ok(NAChannelType::Lo),
209 "Ro" => Ok(NAChannelType::Ro),
210 _ => Err(FormatParseError{}),
211 }
212 }
213 }
214
215 impl fmt::Display for NAChannelType {
216 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
217 let name = match *self {
218 NAChannelType::C => "C".to_string(),
219 NAChannelType::L => "L".to_string(),
220 NAChannelType::R => "R".to_string(),
221 NAChannelType::Cs => "Cs".to_string(),
222 NAChannelType::Ls => "Ls".to_string(),
223 NAChannelType::Rs => "Rs".to_string(),
224 NAChannelType::Lss => "Lss".to_string(),
225 NAChannelType::Rss => "Rss".to_string(),
226 NAChannelType::LFE => "LFE".to_string(),
227 NAChannelType::Lc => "Lc".to_string(),
228 NAChannelType::Rc => "Rc".to_string(),
229 NAChannelType::Lh => "Lh".to_string(),
230 NAChannelType::Rh => "Rh".to_string(),
231 NAChannelType::Ch => "Ch".to_string(),
232 NAChannelType::LFE2 => "LFE2".to_string(),
233 NAChannelType::Lw => "Lw".to_string(),
234 NAChannelType::Rw => "Rw".to_string(),
235 NAChannelType::Ov => "Ov".to_string(),
236 NAChannelType::Lhs => "Lhs".to_string(),
237 NAChannelType::Rhs => "Rhs".to_string(),
238 NAChannelType::Chs => "Chs".to_string(),
239 NAChannelType::Ll => "Ll".to_string(),
240 NAChannelType::Rl => "Rl".to_string(),
241 NAChannelType::Cl => "Cl".to_string(),
242 NAChannelType::Lt => "Lt".to_string(),
243 NAChannelType::Rt => "Rt".to_string(),
244 NAChannelType::Lo => "Lo".to_string(),
245 NAChannelType::Ro => "Ro".to_string(),
246 };
247 write!(f, "{}", name)
248 }
249 }
250
251 /// Channel map.
252 ///
253 /// This is essentially an ordered sequence of channels.
254 #[derive(Clone,Default)]
255 pub struct NAChannelMap {
256 ids: Vec<NAChannelType>,
257 }
258
259 const MS_CHANNEL_MAP: [NAChannelType; 11] = [
260 NAChannelType::L,
261 NAChannelType::R,
262 NAChannelType::C,
263 NAChannelType::LFE,
264 NAChannelType::Ls,
265 NAChannelType::Rs,
266 NAChannelType::Lss,
267 NAChannelType::Rss,
268 NAChannelType::Cs,
269 NAChannelType::Lc,
270 NAChannelType::Rc,
271 ];
272
273 impl NAChannelMap {
274 /// Constructs a new `NAChannelMap` instance.
275 pub fn new() -> Self { NAChannelMap { ids: Vec::new() } }
276 /// Adds a new channel to the map.
277 pub fn add_channel(&mut self, ch: NAChannelType) {
278 self.ids.push(ch);
279 }
280 /// Adds several channels to the map at once.
281 pub fn add_channels(&mut self, chs: &[NAChannelType]) {
282 for e in chs.iter() {
283 self.ids.push(*e);
284 }
285 }
286 /// Returns the total number of channels.
287 pub fn num_channels(&self) -> usize {
288 self.ids.len()
289 }
290 /// Reports channel type for a requested index.
291 pub fn get_channel(&self, idx: usize) -> NAChannelType {
292 self.ids[idx]
293 }
294 /// Tries to find position of the channel with requested type.
295 pub fn find_channel_id(&self, t: NAChannelType) -> Option<u8> {
296 for i in 0..self.ids.len() {
297 if self.ids[i] as i32 == t as i32 { return Some(i as u8); }
298 }
299 None
300 }
301 /// Creates a new `NAChannelMap` using the channel mapping flags from WAVE format.
302 pub fn from_ms_mapping(chmap: u32) -> Self {
303 let mut cm = NAChannelMap::new();
304 for (i, ch) in MS_CHANNEL_MAP.iter().enumerate() {
305 if ((chmap >> i) & 1) != 0 {
306 cm.add_channel(*ch);
307 }
308 }
309 cm
310 }
311 }
312
313 impl fmt::Display for NAChannelMap {
314 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
315 let mut map = String::new();
316 for el in self.ids.iter() {
317 if !map.is_empty() { map.push(','); }
318 map.push_str(&*el.to_string());
319 }
320 write!(f, "{}", map)
321 }
322 }
323
324 impl FromStr for NAChannelMap {
325 type Err = FormatParseError;
326
327 fn from_str(s: &str) -> Result<Self, Self::Err> {
328 let mut chm = NAChannelMap::new();
329 for tok in s.split(',') {
330 chm.add_channel(NAChannelType::from_str(tok)?);
331 }
332 Ok(chm)
333 }
334 }
335
336 /// A list of RGB colour model variants.
337 #[derive(Debug,Clone,Copy,PartialEq)]
338 pub enum RGBSubmodel {
339 RGB,
340 SRGB,
341 }
342
343 impl fmt::Display for RGBSubmodel {
344 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
345 let name = match *self {
346 RGBSubmodel::RGB => "RGB".to_string(),
347 RGBSubmodel::SRGB => "sRGB".to_string(),
348 };
349 write!(f, "{}", name)
350 }
351 }
352
353 /// A list of YUV colour model variants.
354 #[derive(Debug,Clone,Copy,PartialEq)]
355 pub enum YUVSubmodel {
356 YCbCr,
357 /// NTSC variant.
358 YIQ,
359 /// The YUV variant used by JPEG.
360 YUVJ,
361 }
362
363 impl fmt::Display for YUVSubmodel {
364 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
365 let name = match *self {
366 YUVSubmodel::YCbCr => "YCbCr".to_string(),
367 YUVSubmodel::YIQ => "YIQ".to_string(),
368 YUVSubmodel::YUVJ => "YUVJ".to_string(),
369 };
370 write!(f, "{}", name)
371 }
372 }
373
374 /// A list of known colour models.
375 #[derive(Debug, Clone,Copy,PartialEq)]
376 pub enum ColorModel {
377 RGB(RGBSubmodel),
378 YUV(YUVSubmodel),
379 CMYK,
380 HSV,
381 LAB,
382 XYZ,
383 }
384
385 impl ColorModel {
386 /// Returns the number of colour model components.
387 ///
388 /// The actual image may have more components e.g. alpha component.
389 pub fn get_default_components(self) -> usize {
390 match self {
391 ColorModel::CMYK => 4,
392 _ => 3,
393 }
394 }
395 /// Reports whether the current colour model is RGB.
396 pub fn is_rgb(self) -> bool {
397 matches!(self, ColorModel::RGB(_))
398 }
399 /// Reports whether the current colour model is YUV.
400 pub fn is_yuv(self) -> bool {
401 matches!(self, ColorModel::YUV(_))
402 }
403 /// Returns short name for the current colour mode.
404 pub fn get_short_name(self) -> &'static str {
405 match self {
406 ColorModel::RGB(_) => "rgb",
407 ColorModel::YUV(_) => "yuv",
408 ColorModel::CMYK => "cmyk",
409 ColorModel::HSV => "hsv",
410 ColorModel::LAB => "lab",
411 ColorModel::XYZ => "xyz",
412 }
413 }
414 }
415
416 impl fmt::Display for ColorModel {
417 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
418 let name = match *self {
419 ColorModel::RGB(fmt) => format!("RGB({})", fmt),
420 ColorModel::YUV(fmt) => format!("YUV({})", fmt),
421 ColorModel::CMYK => "CMYK".to_string(),
422 ColorModel::HSV => "HSV".to_string(),
423 ColorModel::LAB => "LAB".to_string(),
424 ColorModel::XYZ => "XYZ".to_string(),
425 };
426 write!(f, "{}", name)
427 }
428 }
429
430 /// Single colourspace component definition.
431 ///
432 /// This structure defines how components of a colourspace are subsampled and where and how they are stored.
433 #[derive(Clone,Copy,PartialEq)]
434 pub struct NAPixelChromaton {
435 /// Horizontal subsampling in power of two (e.g. `0` = no subsampling, `1` = only every second value is stored).
436 pub h_ss: u8,
437 /// Vertial subsampling in power of two (e.g. `0` = no subsampling, `1` = only every second value is stored).
438 pub v_ss: u8,
439 /// A flag to signal that component is packed.
440 pub packed: bool,
441 /// Bit depth of current component.
442 pub depth: u8,
443 /// Shift for packed components.
444 pub shift: u8,
445 /// Component offset for byte-packed components.
446 pub comp_offs: u8,
447 /// The distance to the next packed element in bytes.
448 pub next_elem: u8,
449 }
450
451 /// Flag for specifying that image data is stored big-endian in `NAPixelFormaton::`[`new`]`()`. Related to its [`be`] field.
452 ///
453 /// [`new`]: ./struct.NAPixelFormaton.html#method.new
454 /// [`be`]: ./struct.NAPixelFormaton.html#structfield.new
455 pub const FORMATON_FLAG_BE :u32 = 0x01;
456 /// Flag for specifying that image data has alpha plane in `NAPixelFormaton::`[`new`]`()`. Related to its [`alpha`] field.
457 ///
458 /// [`new`]: ./struct.NAPixelFormaton.html#method.new
459 /// [`alpha`]: ./struct.NAPixelFormaton.html#structfield.alpha
460 pub const FORMATON_FLAG_ALPHA :u32 = 0x02;
461 /// Flag for specifying that image data is stored in paletted form for `NAPixelFormaton::`[`new`]`()`. Related to its [`palette`] field.
462 ///
463 /// [`new`]: ./struct.NAPixelFormaton.html#method.new
464 /// [`palette`]: ./struct.NAPixelFormaton.html#structfield.palette
465 pub const FORMATON_FLAG_PALETTE :u32 = 0x04;
466
467 /// The current limit on number of components in image colourspace model (including alpha component).
468 pub const MAX_CHROMATONS: usize = 5;
469
470 /// Image colourspace representation.
471 ///
472 /// This structure includes both definitions for each component and some common definitions.
473 /// For example the format can be paletted and then components describe the palette storage format while actual data is 8-bit palette indices.
474 #[derive(Clone,Copy,PartialEq)]
475 pub struct NAPixelFormaton {
476 /// Image colour model.
477 pub model: ColorModel,
478 /// Actual number of components present.
479 pub components: u8,
480 /// Format definition for each component.
481 pub comp_info: [Option<NAPixelChromaton>; MAX_CHROMATONS],
482 /// Single pixel size for packed formats.
483 pub elem_size: u8,
484 /// A flag signalling that data is stored as big-endian.
485 pub be: bool,
486 /// A flag signalling that image has alpha component.
487 pub alpha: bool,
488 /// A flag signalling that data is paletted.
489 ///
490 /// This means that image data is stored as 8-bit indices (in the first image component) for the palette stored as second component of the image and actual palette format is described in this structure.
491 pub palette: bool,
492 }
493
494 macro_rules! chromaton {
495 ($hs: expr, $vs: expr, $pck: expr, $d: expr, $sh: expr, $co: expr, $ne: expr) => ({
496 Some(NAPixelChromaton{ h_ss: $hs, v_ss: $vs, packed: $pck, depth: $d, shift: $sh, comp_offs: $co, next_elem: $ne })
497 });
498 (yuv8; $hs: expr, $vs: expr, $co: expr) => ({
499 Some(NAPixelChromaton{ h_ss: $hs, v_ss: $vs, packed: false, depth: 8, shift: 0, comp_offs: $co, next_elem: 1 })
500 });
501 (packrgb; $d: expr, $s: expr, $co: expr, $ne: expr) => ({
502 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: $d, shift: $s, comp_offs: $co, next_elem: $ne })
503 });
504 (pal8; $co: expr) => ({
505 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: $co, next_elem: 3 })
506 });
507 }
508
509 /// Predefined format for planar 8-bit YUV with 4:2:0 subsampling.
510 pub const YUV420_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 3,
511 comp_info: [
512 chromaton!(0, 0, false, 8, 0, 0, 1),
513 chromaton!(yuv8; 1, 1, 1),
514 chromaton!(yuv8; 1, 1, 2),
515 None, None],
516 elem_size: 0, be: false, alpha: false, palette: false };
517
518 /// Predefined format for planar 8-bit YUV with 4:1:0 subsampling.
519 pub const YUV410_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 3,
520 comp_info: [
521 chromaton!(0, 0, false, 8, 0, 0, 1),
522 chromaton!(yuv8; 2, 2, 1),
523 chromaton!(yuv8; 2, 2, 2),
524 None, None],
525 elem_size: 0, be: false, alpha: false, palette: false };
526 /// Predefined format for planar 8-bit YUV with 4:1:0 subsampling and alpha component.
527 pub const YUVA410_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 4,
528 comp_info: [
529 chromaton!(0, 0, false, 8, 0, 0, 1),
530 chromaton!(yuv8; 2, 2, 1),
531 chromaton!(yuv8; 2, 2, 2),
532 chromaton!(0, 0, false, 8, 0, 3, 1),
533 None],
534 elem_size: 0, be: false, alpha: true, palette: false };
535
536 /// Predefined format with RGB24 palette.
537 pub const PAL8_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
538 comp_info: [
539 chromaton!(pal8; 0),
540 chromaton!(pal8; 1),
541 chromaton!(pal8; 2),
542 None, None],
543 elem_size: 3, be: false, alpha: false, palette: true };
544
545 /// Predefined format for RGB565 packed video.
546 pub const RGB565_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
547 comp_info: [
548 chromaton!(packrgb; 5, 11, 0, 2),
549 chromaton!(packrgb; 6, 5, 0, 2),
550 chromaton!(packrgb; 5, 0, 0, 2),
551 None, None],
552 elem_size: 2, be: false, alpha: false, palette: false };
553
554 /// Predefined format for RGB24.
555 pub const RGB24_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
556 comp_info: [
557 chromaton!(packrgb; 8, 0, 0, 3),
558 chromaton!(packrgb; 8, 0, 1, 3),
559 chromaton!(packrgb; 8, 0, 2, 3),
560 None, None],
561 elem_size: 3, be: false, alpha: false, palette: false };
562
563 impl NAPixelChromaton {
564 /// Constructs a new `NAPixelChromaton` instance.
565 pub fn new(h_ss: u8, v_ss: u8, packed: bool, depth: u8, shift: u8, comp_offs: u8, next_elem: u8) -> Self {
566 Self { h_ss, v_ss, packed, depth, shift, comp_offs, next_elem }
567 }
568 /// Returns subsampling for the current component.
569 pub fn get_subsampling(self) -> (u8, u8) { (self.h_ss, self.v_ss) }
570 /// Reports whether current component is packed.
571 pub fn is_packed(self) -> bool { self.packed }
572 /// Returns bit depth of current component.
573 pub fn get_depth(self) -> u8 { self.depth }
574 /// Returns bit shift for packed component.
575 pub fn get_shift(self) -> u8 { self.shift }
576 /// Returns byte offset for packed component.
577 pub fn get_offset(self) -> u8 { self.comp_offs }
578 /// Returns byte offset to the next element of current packed component.
579 pub fn get_step(self) -> u8 { self.next_elem }
580
581 /// Calculates the width for current component from general image width.
582 pub fn get_width(self, width: usize) -> usize {
583 (width + ((1 << self.h_ss) - 1)) >> self.h_ss
584 }
585 /// Calculates the height for current component from general image height.
586 pub fn get_height(self, height: usize) -> usize {
587 (height + ((1 << self.v_ss) - 1)) >> self.v_ss
588 }
589 /// Calculates the minimal stride for current component from general image width.
590 pub fn get_linesize(self, width: usize) -> usize {
591 let d = self.depth as usize;
592 if self.packed {
593 (self.get_width(width) * d + d - 1) >> 3
594 } else {
595 self.get_width(width)
596 }
597 }
598 /// Calculates the required image size in pixels for current component from general image width.
599 pub fn get_data_size(self, width: usize, height: usize) -> usize {
600 let nh = (height + ((1 << self.v_ss) - 1)) >> self.v_ss;
601 self.get_linesize(width) * nh
602 }
603 }
604
605 impl fmt::Display for NAPixelChromaton {
606 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
607 let pfmt = if self.packed {
608 let mask = ((1 << self.depth) - 1) << self.shift;
609 format!("packed(+{},{:X}, step {})", self.comp_offs, mask, self.next_elem)
610 } else {
611 format!("planar({},{})", self.comp_offs, self.next_elem)
612 };
613 write!(f, "({}x{}, {})", self.h_ss, self.v_ss, pfmt)
614 }
615 }
616
617 impl NAPixelFormaton {
618 /// Constructs a new instance of `NAPixelFormaton`.
619 pub fn new(model: ColorModel,
620 comp1: Option<NAPixelChromaton>,
621 comp2: Option<NAPixelChromaton>,
622 comp3: Option<NAPixelChromaton>,
623 comp4: Option<NAPixelChromaton>,
624 comp5: Option<NAPixelChromaton>,
625 flags: u32, elem_size: u8) -> Self {
626 let mut chromatons: [Option<NAPixelChromaton>; MAX_CHROMATONS] = [None; MAX_CHROMATONS];
627 let mut ncomp = 0;
628 let be = (flags & FORMATON_FLAG_BE) != 0;
629 let alpha = (flags & FORMATON_FLAG_ALPHA) != 0;
630 let palette = (flags & FORMATON_FLAG_PALETTE) != 0;
631 if let Some(c) = comp1 { chromatons[0] = Some(c); ncomp += 1; }
632 if let Some(c) = comp2 { chromatons[1] = Some(c); ncomp += 1; }
633 if let Some(c) = comp3 { chromatons[2] = Some(c); ncomp += 1; }
634 if let Some(c) = comp4 { chromatons[3] = Some(c); ncomp += 1; }
635 if let Some(c) = comp5 { chromatons[4] = Some(c); ncomp += 1; }
636 NAPixelFormaton { model,
637 components: ncomp,
638 comp_info: chromatons,
639 elem_size,
640 be, alpha, palette }
641 }
642
643 /// Returns current colour model.
644 pub fn get_model(&self) -> ColorModel { self.model }
645 /// Returns the number of components.
646 pub fn get_num_comp(&self) -> usize { self.components as usize }
647 /// Returns selected component information.
648 pub fn get_chromaton(&self, idx: usize) -> Option<NAPixelChromaton> {
649 if idx < self.comp_info.len() { return self.comp_info[idx]; }
650 None
651 }
652 /// Reports whether the packing format is big-endian.
653 pub fn is_be(self) -> bool { self.be }
654 /// Reports whether colourspace has alpha component.
655 pub fn has_alpha(self) -> bool { self.alpha }
656 /// Reports whether this is paletted format.
657 pub fn is_paletted(self) -> bool { self.palette }
658 /// Returns single packed pixel size.
659 pub fn get_elem_size(self) -> u8 { self.elem_size }
660 /// Reports whether the format is not packed.
661 pub fn is_unpacked(&self) -> bool {
662 if self.palette { return false; }
663 for chr in self.comp_info.iter() {
664 if let Some(ref chromaton) = chr {
665 if chromaton.is_packed() { return false; }
666 }
667 }
668 true
669 }
670 /// Returns the maximum component bit depth.
671 pub fn get_max_depth(&self) -> u8 {
672 let mut mdepth = 0;
673 for chr in self.comp_info.iter() {
674 if let Some(ref chromaton) = chr {
675 mdepth = mdepth.max(chromaton.depth);
676 }
677 }
678 mdepth
679 }
680 /// Returns the total amount of bits needed for components.
681 pub fn get_total_depth(&self) -> u8 {
682 let mut depth = 0;
683 for chr in self.comp_info.iter() {
684 if let Some(ref chromaton) = chr {
685 depth += chromaton.depth;
686 }
687 }
688 depth
689 }
690 /// Returns the maximum component subsampling.
691 pub fn get_max_subsampling(&self) -> u8 {
692 let mut ssamp = 0;
693 for chr in self.comp_info.iter() {
694 if let Some(ref chromaton) = chr {
695 let (ss_v, ss_h) = chromaton.get_subsampling();
696 ssamp = ssamp.max(ss_v).max(ss_h);
697 }
698 }
699 ssamp
700 }
701 #[allow(clippy::cognitive_complexity)]
702 /// Returns a short string description of the format if possible.
703 pub fn to_short_string(&self) -> Option<String> {
704 match self.model {
705 ColorModel::RGB(_) => {
706 if self.is_paletted() {
707 if *self == PAL8_FORMAT {
708 return Some("pal8".to_string());
709 } else {
710 return None;
711 }
712 }
713 let mut name = [b'z'; 4];
714 let planar = self.is_unpacked();
715
716 let mut start_off = 0;
717 let mut start_shift = 0;
718 let mut use_shift = true;
719 for comp in self.comp_info.iter() {
720 if let Some(comp) = comp {
721 start_off = start_off.min(comp.comp_offs);
722 start_shift = start_shift.min(comp.shift);
723 if comp.comp_offs != 0 { use_shift = false; }
724 }
725 }
726 for component in 0..(self.components as usize) {
727 for (comp, cname) in self.comp_info.iter().zip(b"rgba".iter()) {
728 if let Some(comp) = comp {
729 if use_shift {
730 if comp.shift == start_shift {
731 name[component] = *cname;
732 start_shift += comp.depth;
733 }
734 } else if comp.comp_offs == start_off {
735 name[component] = *cname;
736 if planar {
737 start_off += 1;
738 } else {
739 start_off += (comp.depth + 7) / 8;
740 }
741 }
742 }
743 }
744 }
745
746 for (comp, cname) in self.comp_info.iter().zip(b"rgba".iter()) {
747 if let Some(comp) = comp {
748 name[comp.comp_offs as usize] = *cname;
749 } else {
750 break;
751 }
752 }
753 let mut name = String::from_utf8(name[..self.components as usize].to_vec()).unwrap();
754 let depth = self.get_total_depth();
755 if depth == 15 || depth == 16 {
756 for c in self.comp_info.iter() {
757 if let Some(comp) = c {
758 name.push((b'0' + comp.depth) as char);
759 } else {
760 break;
761 }
762 }
763 name += if self.be { "be" } else { "le" };
764 return Some(name);
765 }
766 if depth == 24 || depth != 8 * self.components {
767 name += depth.to_string().as_str();
768 }
769 if planar {
770 name.push('p');
771 }
772 if self.get_max_depth() > 8 {
773 name += if self.be { "be" } else { "le" };
774 }
775 Some(name)
776 },
777 ColorModel::YUV(_) => {
778 let max_depth = self.get_max_depth();
779 if self.get_total_depth() != max_depth * self.components {
780 return None;
781 }
782 if self.components < 3 {
783 if self.components == 1 && max_depth == 8 {
784 return Some("y8".to_string());
785 }
786 if self.components == 2 && self.alpha && max_depth == 8 {
787 return Some("y8a".to_string());
788 }
789 return None;
790 }
791 let cu = self.comp_info[1].unwrap();
792 let cv = self.comp_info[2].unwrap();
793 if cu.h_ss != cv.h_ss || cu.v_ss != cv.v_ss || cu.h_ss > 2 || cu.v_ss > 2 {
794 return None;
795 }
796 let mut name = "yuv".to_string();
797 if self.alpha {
798 name.push('a');
799 }
800 name.push('4');
801 let sch = b"421"[cu.h_ss as usize];
802 let tch = if cu.v_ss > 1 { b'0' } else { sch };
803 name.push(sch as char);
804 name.push(tch as char);
805 if self.is_unpacked() {
806 name.push('p');
807 }
808 if max_depth != 8 {
809 name += max_depth.to_string().as_str();
810 }
811 Some(name)
812 },
813 _ => None,
814 }
815 }
816 }
817
818 impl fmt::Display for NAPixelFormaton {
819 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
820 let end = if self.be { "BE" } else { "LE" };
821 let palstr = if self.palette { "palette " } else { "" };
822 let astr = if self.alpha { "alpha " } else { "" };
823 let mut string = format!("Formaton for {} ({}{}elem {} size {}): ", self.model, palstr, astr,end, self.elem_size);
824 for i in 0..self.comp_info.len() {
825 if let Some(chr) = self.comp_info[i] {
826 string = format!("{} {}", string, chr);
827 }
828 }
829 write!(f, "[{}]", string)
830 }
831 }
832
833 fn parse_rgb_format(s: &str) -> Result<NAPixelFormaton, FormatParseError> {
834 let mut order = [0; 4];
835 let mut is_be = s.ends_with("be");
836 let mut has_alpha = false;
837 let mut pstate = 0;
838 let mut bits = 0;
839 let mut bits_start = 0;
840 for (i, ch) in s.chars().enumerate() {
841 match pstate {
842 0 => {
843 if i > 4 { return Err(FormatParseError {}); }
844 match ch {
845 'R' | 'r' => { order[0] = i; },
846 'G' | 'g' => { order[1] = i; },
847 'B' | 'b' => { order[2] = i; },
848 'A' | 'a' => { order[3] = i; has_alpha = true; },
849 '0'..='9' => {
850 pstate = 1; bits_start = i;
851 bits = u32::from((ch as u8) - b'0');
852 },
853 _ => return Err(FormatParseError {}),
854 };
855 },
856 1 => {
857 if i > 4 + bits_start { return Err(FormatParseError {}); }
858 match ch {
859 '0'..='9' => {
860 bits = (bits * 10) + u32::from((ch as u8) - b'0');
861 },
862 'B' | 'b' => { pstate = 2; }
863 'L' | 'l' => { pstate = 2; is_be = false; }
864 _ => return Err(FormatParseError {}),
865 }
866 },
867 2 => {
868 if ch != 'e' && ch != 'E' { return Err(FormatParseError {}); }
869 pstate = 3;
870 },
871 _ => return Err(FormatParseError {}),
872 };
873 }
874 let components: u8 = if has_alpha { 4 } else { 3 };
875 for el in order.iter() {
876 if *el >= (components as usize) {
877 return Err(FormatParseError {});
878 }
879 }
880 if order[0] == order[1] || order[0] == order[2] || order[1] == order[2] {
881 return Err(FormatParseError {});
882 }
883 if has_alpha && order[0..3].contains(&order[3]) {
884 return Err(FormatParseError {});
885 }
886 let mut chromatons = [None; 5];
887 let elem_size = match bits {
888 0 | 24 => {
889 for (chro, ord) in chromatons.iter_mut().take(components as usize).zip(order.iter()) {
890 *chro = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: *ord as u8, next_elem: components });
891 }
892 components
893 },
894 555 => {
895 let rshift = (order[0] * 5) as u8;
896 let gshift = (order[1] * 5) as u8;
897 let bshift = (order[2] * 5) as u8;
898 chromatons[0] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: rshift, comp_offs: 0, next_elem: 2 });
899 chromatons[1] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: gshift, comp_offs: 0, next_elem: 2 });
900 chromatons[2] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: bshift, comp_offs: 0, next_elem: 2 });
901 if has_alpha { return Err(FormatParseError {}); }
902 2
903 },
904 565 => {
905 let mut offs = [0; 3];
906 for (ord, off) in order.iter().zip(offs.iter_mut()) {
907 *off = (*ord * 5) as u8;
908 }
909 match order[1] {
910 0 => { offs[0] += 1; offs[2] += 1; },
911 1 => { for el in offs.iter_mut() { if *el == 10 { *el += 1; break; } } },
912 _ => {},
913 };
914 chromatons[0] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: offs[0], comp_offs: 0, next_elem: 2 });
915 chromatons[1] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 6, shift: offs[1], comp_offs: 0, next_elem: 2 });
916 chromatons[2] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: offs[2], comp_offs: 0, next_elem: 2 });
917 if has_alpha { return Err(FormatParseError {}); }
918 2
919 },
920 5551 => {
921 let mut offs = [0; 4];
922 let depth = [ 5, 5, 5, 1 ];
923 let mut cur_off = 0;
924 for comp in 0..4 {
925 for (off, ord) in offs.iter_mut().zip(order.iter()) {
926 if *ord == comp {
927 *off = cur_off;
928 cur_off += depth[comp];
929 break;
930 }
931 }
932 }
933 chromatons[0] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: offs[0], comp_offs: 0, next_elem: 2 });
934 chromatons[1] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: offs[1], comp_offs: 0, next_elem: 2 });
935 chromatons[2] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: offs[2], comp_offs: 0, next_elem: 2 });
936 chromatons[3] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 1, shift: offs[3], comp_offs: 0, next_elem: 2 });
937 if !has_alpha { return Err(FormatParseError {}); }
938 2
939 },
940 _ => return Err(FormatParseError {}),
941 };
942 Ok(NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB),
943 components,
944 comp_info: chromatons,
945 elem_size,
946 be: is_be, alpha: has_alpha, palette: false })
947 }
948
949 fn parse_yuv_format(s: &str) -> Result<NAPixelFormaton, FormatParseError> {
950 match s {
951 "y8" | "y400" | "gray" => {
952 return Ok(NAPixelFormaton {
953 model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 1,
954 comp_info: [
955 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: false, depth: 8, shift: 0, comp_offs: 0, next_elem: 1 }),
956 None, None, None, None],
957 elem_size: 1, be: true, alpha: false, palette: false });
958 },
959 "y8a" | "y400a" | "graya" => {
960 return Ok(NAPixelFormaton {
961 model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 2,
962 comp_info: [
963 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: false, depth: 8, shift: 0, comp_offs: 0, next_elem: 2 }),
964 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: false, depth: 8, shift: 0, comp_offs: 1, next_elem: 2 }),
965 None, None, None],
966 elem_size: 1, be: true, alpha: true, palette: false });
967 },
968 "uyvy" | "y422" => {
969 return Ok(NAPixelFormaton {
970 model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 3,
971 comp_info: [
972 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 1, next_elem: 2 }),
973 Some(NAPixelChromaton{ h_ss: 1, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 4 }),
974 Some(NAPixelChromaton{ h_ss: 1, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 2, next_elem: 4 }),
975 None, None],
976 elem_size: 4, be: false, alpha: false, palette: false });
977 },
978 "yuy2" | "yuyv" | "v422" => {
979 return Ok(NAPixelFormaton {
980 model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 3,
981 comp_info: [
982 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 2 }),
983 Some(NAPixelChromaton{ h_ss: 1, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 1, next_elem: 4 }),
984 Some(NAPixelChromaton{ h_ss: 1, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 3, next_elem: 4 }),
985 None, None],
986 elem_size: 4, be: false, alpha: false, palette: false });
987 },
988 "yvyu" => {
989 return Ok(NAPixelFormaton {
990 model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 3,
991 comp_info: [
992 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 2 }),
993 Some(NAPixelChromaton{ h_ss: 1, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 3, next_elem: 4 }),
994 Some(NAPixelChromaton{ h_ss: 1, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 1, next_elem: 4 }),
995 None, None],
996 elem_size: 4, be: false, alpha: false, palette: false });
997 },
998 "vyuy" => {
999 return Ok(NAPixelFormaton {
1000 model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 3,
1001 comp_info: [
1002 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 1, next_elem: 2 }),
1003 Some(NAPixelChromaton{ h_ss: 1, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 2, next_elem: 4 }),
1004 Some(NAPixelChromaton{ h_ss: 1, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 4 }),
1005 None, None],
1006 elem_size: 4, be: false, alpha: false, palette: false });
1007 },
1008 _ => {},
1009 };
1010 if !s.starts_with("yuv") {
1011 return Err(FormatParseError {});
1012 }
1013 let has_alpha = s.starts_with("yuva");
1014 let components: u8 = if has_alpha { 4 } else { 3 };
1015 let mut is_planar = false;
1016 let mut format = 0;
1017 let mut parse_end = components as usize;
1018 for ch in s.chars().skip(components as usize) {
1019 parse_end += 1;
1020 if ('0'..='9').contains(&ch) {
1021 format = format * 10 + u32::from((ch as u8) - b'0');
1022 if format > 444 { return Err(FormatParseError {}); }
1023 } else {
1024 is_planar = ch == 'p';
1025 break;
1026 }
1027 }
1028 if format == 0 { return Err(FormatParseError {}); }
1029 let depth = if s.len() == parse_end { 8 } else {
1030 let mut val = 0;
1031 for ch in s.chars().skip(parse_end) {
1032 if ('0'..='9').contains(&ch) {
1033 val = val * 10 + ((ch as u8) - b'0');
1034 if val > 16 { return Err(FormatParseError {}); }
1035 } else {
1036 break;
1037 }
1038 }
1039 val
1040 };
1041 if depth == 0 { return Err(FormatParseError {}); }
1042 let is_be = s.ends_with("be");
1043
1044 let mut chromatons = [None; 5];
1045 let next_elem = if is_planar { (depth + 7) >> 3 } else {
1046 components * ((depth + 7) >> 3) };
1047 let subsamp: [[u8; 2]; 4] = match format {
1048 410 => [[0, 0], [2, 2], [2, 2], [0, 0]],
1049 411 => [[0, 0], [2, 0], [2, 0], [0, 0]],
1050 420 => [[0, 0], [1, 1], [1, 1], [0, 0]],
1051 422 => [[0, 0], [1, 0], [1, 0], [0, 0]],
1052 440 => [[0, 0], [0, 1], [0, 1], [0, 0]],
1053 444 => [[0, 0], [0, 0], [0, 0], [0, 0]],
1054 _ => return Err(FormatParseError {}),
1055 };
1056 for (i, (chro, ss)) in chromatons.iter_mut().take(components as usize).zip(subsamp.iter()).enumerate() {
1057 *chro = Some(NAPixelChromaton{ h_ss: ss[0], v_ss: ss[1], packed: !is_planar, depth, shift: 0, comp_offs: if is_planar { i as u8 } else { next_elem }, next_elem });
1058 }
1059 Ok(NAPixelFormaton { model: ColorModel::YUV(YUVSubmodel::YUVJ),
1060 components,
1061 comp_info: chromatons,
1062 elem_size: components,
1063 be: is_be, alpha: has_alpha, palette: false })
1064 }
1065
1066 impl FromStr for NAPixelFormaton {
1067 type Err = FormatParseError;
1068
1069 #[allow(clippy::single_match)]
1070 fn from_str(s: &str) -> Result<Self, Self::Err> {
1071 match s {
1072 "pal8" => return Ok(PAL8_FORMAT),
1073 _ => {},
1074 }
1075 let ret = parse_rgb_format(s);
1076 if ret.is_ok() {
1077 return ret;
1078 }
1079 parse_yuv_format(s)
1080 }
1081 }
1082
1083 #[cfg(test)]
1084 mod test {
1085 use super::*;
1086
1087 #[test]
1088 fn test_fmt() {
1089 println!("{}", SND_S16_FORMAT);
1090 println!("{}", SND_U8_FORMAT);
1091 println!("{}", SND_F32P_FORMAT);
1092 assert_eq!(SND_U8_FORMAT.to_short_string(), "u8");
1093 assert_eq!(SND_F32P_FORMAT.to_short_string(), "f32lep");
1094 let s16fmt = SND_S16_FORMAT.to_short_string();
1095 assert_eq!(NASoniton::from_str(s16fmt.as_str()).unwrap(), SND_S16_FORMAT);
1096 println!("formaton yuv- {}", YUV420_FORMAT);
1097 println!("formaton pal- {}", PAL8_FORMAT);
1098 println!("formaton rgb565- {}", RGB565_FORMAT);
1099
1100 let pfmt = NAPixelFormaton::from_str("rgb24").unwrap();
1101 assert!(pfmt == RGB24_FORMAT);
1102 let pfmt = "gbra";
1103 assert_eq!(pfmt, NAPixelFormaton::from_str("gbra").unwrap().to_short_string().unwrap());
1104 let pfmt = NAPixelFormaton::from_str("yuv420").unwrap();
1105 println!("parsed pfmt as {} / {:?}", pfmt, pfmt.to_short_string());
1106 let pfmt = NAPixelFormaton::from_str("yuva420p12").unwrap();
1107 println!("parsed pfmt as {} / {:?}", pfmt, pfmt.to_short_string());
1108
1109 assert_eq!(RGB565_FORMAT.to_short_string().unwrap(), "bgr565le");
1110 assert_eq!(PAL8_FORMAT.to_short_string().unwrap(), "pal8");
1111 assert_eq!(YUV420_FORMAT.to_short_string().unwrap(), "yuv422p");
1112 assert_eq!(YUVA410_FORMAT.to_short_string().unwrap(), "yuva410p");
1113 }
1114 }