1 //! Audio and image sample format definitions.
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.
10 /// Generic format parsing error.
11 #[derive(Clone,Copy,Debug,PartialEq)]
12 pub struct FormatParseError {}
14 /// Audio format definition.
16 /// The structure describes how audio samples are stored and what characteristics they have.
17 #[derive(Debug,Copy,Clone,PartialEq)]
18 pub struct NASoniton {
21 /// Audio format is big-endian.
23 /// Audio samples are packed (e.g. 20-bit audio samples).
25 /// Audio data is stored in planar format instead of interleaving samples for different channels.
27 /// Audio data is in floating point format.
29 /// Audio data is signed (usually only 8-bit audio is unsigned).
33 /// Flag for specifying that audio format is big-endian in `NASoniton::`[`new`]`()`. Related to [`be`] field of `NASoniton`.
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`.
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`.
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`.
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`.
55 /// [`new`]: ./struct.NASoniton.html#method.new
56 /// [`signed`]: ./struct.NASoniton.html#structfield.signed
57 pub const SONITON_FLAG_SIGNED :u32 = 0x10;
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 };
71 /// Constructs a new audio format definition using flags like [`SONITON_FLAG_BE`].
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 }
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 }
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 {
99 ((length * u64::from(self.bits) + 7) >> 3) as usize
101 (length * u64::from((self.bits + 7) >> 3)) as usize
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)
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)
123 impl FromStr for NASoniton {
124 type Err = FormatParseError;
126 fn from_str(s: &str) -> Result<Self, Self::Err> {
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{}),
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
149 /// Reports whether this is some center channel.
150 pub fn is_center(self) -> bool {
152 NAChannelType::C => true, NAChannelType::Ch => true,
153 NAChannelType::Cl => true, NAChannelType::Ov => true,
154 NAChannelType::LFE => true, NAChannelType::LFE2 => true,
155 NAChannelType::Cs => true, NAChannelType::Chs => true,
159 /// Reports whether this is some left channel.
160 pub fn is_left(self) -> bool {
162 NAChannelType::L => true, NAChannelType::Ls => true,
163 NAChannelType::Lss => true, NAChannelType::Lc => true,
164 NAChannelType::Lh => true, NAChannelType::Lw => true,
165 NAChannelType::Lhs => true, NAChannelType::Ll => true,
166 NAChannelType::Lt => true, NAChannelType::Lo => true,
170 /// Reports whether this is some right channel.
171 pub fn is_right(self) -> bool {
173 NAChannelType::R => true, NAChannelType::Rs => true,
174 NAChannelType::Rss => true, NAChannelType::Rc => true,
175 NAChannelType::Rh => true, NAChannelType::Rw => true,
176 NAChannelType::Rhs => true, NAChannelType::Rl => true,
177 NAChannelType::Rt => true, NAChannelType::Ro => true,
183 impl FromStr for NAChannelType {
184 type Err = FormatParseError;
186 fn from_str(s: &str) -> Result<Self, Self::Err> {
188 "C" => Ok(NAChannelType::C),
189 "L" => Ok(NAChannelType::L),
190 "R" => Ok(NAChannelType::R),
191 "Cs" => Ok(NAChannelType::Cs),
192 "Ls" => Ok(NAChannelType::Ls),
193 "Rs" => Ok(NAChannelType::Rs),
194 "Lss" => Ok(NAChannelType::Lss),
195 "Rss" => Ok(NAChannelType::Rss),
196 "LFE" => Ok(NAChannelType::LFE),
197 "Lc" => Ok(NAChannelType::Lc),
198 "Rc" => Ok(NAChannelType::Rc),
199 "Lh" => Ok(NAChannelType::Lh),
200 "Rh" => Ok(NAChannelType::Rh),
201 "Ch" => Ok(NAChannelType::Ch),
202 "LFE2" => Ok(NAChannelType::LFE2),
203 "Lw" => Ok(NAChannelType::Lw),
204 "Rw" => Ok(NAChannelType::Rw),
205 "Ov" => Ok(NAChannelType::Ov),
206 "Lhs" => Ok(NAChannelType::Lhs),
207 "Rhs" => Ok(NAChannelType::Rhs),
208 "Chs" => Ok(NAChannelType::Chs),
209 "Ll" => Ok(NAChannelType::Ll),
210 "Rl" => Ok(NAChannelType::Rl),
211 "Cl" => Ok(NAChannelType::Cl),
212 "Lt" => Ok(NAChannelType::Lt),
213 "Rt" => Ok(NAChannelType::Rt),
214 "Lo" => Ok(NAChannelType::Lo),
215 "Ro" => Ok(NAChannelType::Ro),
216 _ => Err(FormatParseError{}),
221 impl fmt::Display for NAChannelType {
222 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
223 let name = match *self {
224 NAChannelType::C => "C".to_string(),
225 NAChannelType::L => "L".to_string(),
226 NAChannelType::R => "R".to_string(),
227 NAChannelType::Cs => "Cs".to_string(),
228 NAChannelType::Ls => "Ls".to_string(),
229 NAChannelType::Rs => "Rs".to_string(),
230 NAChannelType::Lss => "Lss".to_string(),
231 NAChannelType::Rss => "Rss".to_string(),
232 NAChannelType::LFE => "LFE".to_string(),
233 NAChannelType::Lc => "Lc".to_string(),
234 NAChannelType::Rc => "Rc".to_string(),
235 NAChannelType::Lh => "Lh".to_string(),
236 NAChannelType::Rh => "Rh".to_string(),
237 NAChannelType::Ch => "Ch".to_string(),
238 NAChannelType::LFE2 => "LFE2".to_string(),
239 NAChannelType::Lw => "Lw".to_string(),
240 NAChannelType::Rw => "Rw".to_string(),
241 NAChannelType::Ov => "Ov".to_string(),
242 NAChannelType::Lhs => "Lhs".to_string(),
243 NAChannelType::Rhs => "Rhs".to_string(),
244 NAChannelType::Chs => "Chs".to_string(),
245 NAChannelType::Ll => "Ll".to_string(),
246 NAChannelType::Rl => "Rl".to_string(),
247 NAChannelType::Cl => "Cl".to_string(),
248 NAChannelType::Lt => "Lt".to_string(),
249 NAChannelType::Rt => "Rt".to_string(),
250 NAChannelType::Lo => "Lo".to_string(),
251 NAChannelType::Ro => "Ro".to_string(),
253 write!(f, "{}", name)
259 /// This is essentially an ordered sequence of channels.
260 #[derive(Clone,Default)]
261 pub struct NAChannelMap {
262 ids: Vec<NAChannelType>,
265 const MS_CHANNEL_MAP: [NAChannelType; 11] = [
280 /// Constructs a new `NAChannelMap` instance.
281 pub fn new() -> Self { NAChannelMap { ids: Vec::new() } }
282 /// Adds a new channel to the map.
283 pub fn add_channel(&mut self, ch: NAChannelType) {
286 /// Adds several channels to the map at once.
287 pub fn add_channels(&mut self, chs: &[NAChannelType]) {
288 for e in chs.iter() {
292 /// Returns the total number of channels.
293 pub fn num_channels(&self) -> usize {
296 /// Reports channel type for a requested index.
297 pub fn get_channel(&self, idx: usize) -> NAChannelType {
300 /// Tries to find position of the channel with requested type.
301 pub fn find_channel_id(&self, t: NAChannelType) -> Option<u8> {
302 for i in 0..self.ids.len() {
303 if self.ids[i] as i32 == t as i32 { return Some(i as u8); }
307 /// Creates a new `NAChannelMap` using the channel mapping flags from WAVE format.
308 pub fn from_ms_mapping(chmap: u32) -> Self {
309 let mut cm = NAChannelMap::new();
310 for (i, ch) in MS_CHANNEL_MAP.iter().enumerate() {
311 if ((chmap >> i) & 1) != 0 {
319 impl fmt::Display for NAChannelMap {
320 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
321 let mut map = String::new();
322 for el in self.ids.iter() {
323 if !map.is_empty() { map.push(','); }
324 map.push_str(&*el.to_string());
330 impl FromStr for NAChannelMap {
331 type Err = FormatParseError;
333 fn from_str(s: &str) -> Result<Self, Self::Err> {
334 let mut chm = NAChannelMap::new();
335 for tok in s.split(',') {
336 chm.add_channel(NAChannelType::from_str(tok)?);
342 /// A list of RGB colour model variants.
343 #[derive(Debug,Clone,Copy,PartialEq)]
344 pub enum RGBSubmodel {
349 impl fmt::Display for RGBSubmodel {
350 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
351 let name = match *self {
352 RGBSubmodel::RGB => "RGB".to_string(),
353 RGBSubmodel::SRGB => "sRGB".to_string(),
355 write!(f, "{}", name)
359 /// A list of YUV colour model variants.
360 #[derive(Debug,Clone,Copy,PartialEq)]
361 pub enum YUVSubmodel {
365 /// The YUV variant used by JPEG.
369 impl fmt::Display for YUVSubmodel {
370 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
371 let name = match *self {
372 YUVSubmodel::YCbCr => "YCbCr".to_string(),
373 YUVSubmodel::YIQ => "YIQ".to_string(),
374 YUVSubmodel::YUVJ => "YUVJ".to_string(),
376 write!(f, "{}", name)
380 /// A list of known colour models.
381 #[derive(Debug, Clone,Copy,PartialEq)]
382 pub enum ColorModel {
392 /// Returns the number of colour model components.
394 /// The actual image may have more components e.g. alpha component.
395 pub fn get_default_components(self) -> usize {
397 ColorModel::CMYK => 4,
401 /// Reports whether the current colour model is RGB.
402 pub fn is_rgb(self) -> bool {
404 ColorModel::RGB(_) => true,
408 /// Reports whether the current colour model is YUV.
409 pub fn is_yuv(self) -> bool {
411 ColorModel::YUV(_) => true,
415 /// Returns short name for the current colour mode.
416 pub fn get_short_name(self) -> &'static str {
418 ColorModel::RGB(_) => "rgb",
419 ColorModel::YUV(_) => "yuv",
420 ColorModel::CMYK => "cmyk",
421 ColorModel::HSV => "hsv",
422 ColorModel::LAB => "lab",
423 ColorModel::XYZ => "xyz",
428 impl fmt::Display for ColorModel {
429 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
430 let name = match *self {
431 ColorModel::RGB(fmt) => format!("RGB({})", fmt),
432 ColorModel::YUV(fmt) => format!("YUV({})", fmt),
433 ColorModel::CMYK => "CMYK".to_string(),
434 ColorModel::HSV => "HSV".to_string(),
435 ColorModel::LAB => "LAB".to_string(),
436 ColorModel::XYZ => "XYZ".to_string(),
438 write!(f, "{}", name)
442 /// Single colourspace component definition.
444 /// This structure defines how components of a colourspace are subsampled and where and how they are stored.
445 #[derive(Clone,Copy,PartialEq)]
446 pub struct NAPixelChromaton {
447 /// Horizontal subsampling in power of two (e.g. `0` = no subsampling, `1` = only every second value is stored).
449 /// Vertial subsampling in power of two (e.g. `0` = no subsampling, `1` = only every second value is stored).
451 /// A flag to signal that component is packed.
453 /// Bit depth of current component.
455 /// Shift for packed components.
457 /// Component offset for byte-packed components.
459 /// The distance to the next packed element in bytes.
463 /// Flag for specifying that image data is stored big-endian in `NAPixelFormaton::`[`new`]`()`. Related to its [`be`] field.
465 /// [`new`]: ./struct.NAPixelFormaton.html#method.new
466 /// [`be`]: ./struct.NAPixelFormaton.html#structfield.new
467 pub const FORMATON_FLAG_BE :u32 = 0x01;
468 /// Flag for specifying that image data has alpha plane in `NAPixelFormaton::`[`new`]`()`. Related to its [`alpha`] field.
470 /// [`new`]: ./struct.NAPixelFormaton.html#method.new
471 /// [`alpha`]: ./struct.NAPixelFormaton.html#structfield.alpha
472 pub const FORMATON_FLAG_ALPHA :u32 = 0x02;
473 /// Flag for specifying that image data is stored in paletted form for `NAPixelFormaton::`[`new`]`()`. Related to its [`palette`] field.
475 /// [`new`]: ./struct.NAPixelFormaton.html#method.new
476 /// [`palette`]: ./struct.NAPixelFormaton.html#structfield.palette
477 pub const FORMATON_FLAG_PALETTE :u32 = 0x04;
479 /// The current limit on number of components in image colourspace model (including alpha component).
480 pub const MAX_CHROMATONS: usize = 5;
482 /// Image colourspace representation.
484 /// This structure includes both definitions for each component and some common definitions.
485 /// For example the format can be paletted and then components describe the palette storage format while actual data is 8-bit palette indices.
486 #[derive(Clone,Copy,PartialEq)]
487 pub struct NAPixelFormaton {
488 /// Image colour model.
489 pub model: ColorModel,
490 /// Actual number of components present.
492 /// Format definition for each component.
493 pub comp_info: [Option<NAPixelChromaton>; MAX_CHROMATONS],
494 /// Single pixel size for packed formats.
496 /// A flag signalling that data is stored as big-endian.
498 /// A flag signalling that image has alpha component.
500 /// A flag signalling that data is paletted.
502 /// 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.
506 macro_rules! chromaton {
507 ($hs: expr, $vs: expr, $pck: expr, $d: expr, $sh: expr, $co: expr, $ne: expr) => ({
508 Some(NAPixelChromaton{ h_ss: $hs, v_ss: $vs, packed: $pck, depth: $d, shift: $sh, comp_offs: $co, next_elem: $ne })
510 (yuv8; $hs: expr, $vs: expr, $co: expr) => ({
511 Some(NAPixelChromaton{ h_ss: $hs, v_ss: $vs, packed: false, depth: 8, shift: 0, comp_offs: $co, next_elem: 1 })
513 (packrgb; $d: expr, $s: expr, $co: expr, $ne: expr) => ({
514 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: $d, shift: $s, comp_offs: $co, next_elem: $ne })
516 (pal8; $co: expr) => ({
517 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: $co, next_elem: 3 })
521 /// Predefined format for planar 8-bit YUV with 4:2:0 subsampling.
522 pub const YUV420_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 3,
524 chromaton!(0, 0, false, 8, 0, 0, 1),
525 chromaton!(yuv8; 1, 1, 1),
526 chromaton!(yuv8; 1, 1, 2),
528 elem_size: 0, be: false, alpha: false, palette: false };
530 /// Predefined format for planar 8-bit YUV with 4:1:0 subsampling.
531 pub const YUV410_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 3,
533 chromaton!(0, 0, false, 8, 0, 0, 1),
534 chromaton!(yuv8; 2, 2, 1),
535 chromaton!(yuv8; 2, 2, 2),
537 elem_size: 0, be: false, alpha: false, palette: false };
538 /// Predefined format for planar 8-bit YUV with 4:1:0 subsampling and alpha component.
539 pub const YUVA410_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 4,
541 chromaton!(0, 0, false, 8, 0, 0, 1),
542 chromaton!(yuv8; 2, 2, 1),
543 chromaton!(yuv8; 2, 2, 2),
544 chromaton!(0, 0, false, 8, 0, 3, 1),
546 elem_size: 0, be: false, alpha: true, palette: false };
548 /// Predefined format with RGB24 palette.
549 pub const PAL8_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
555 elem_size: 3, be: false, alpha: false, palette: true };
557 /// Predefined format for RGB565 packed video.
558 pub const RGB565_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
560 chromaton!(packrgb; 5, 11, 0, 2),
561 chromaton!(packrgb; 6, 5, 0, 2),
562 chromaton!(packrgb; 5, 0, 0, 2),
564 elem_size: 2, be: false, alpha: false, palette: false };
566 /// Predefined format for RGB24.
567 pub const RGB24_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
569 chromaton!(packrgb; 8, 0, 0, 3),
570 chromaton!(packrgb; 8, 0, 1, 3),
571 chromaton!(packrgb; 8, 0, 2, 3),
573 elem_size: 3, be: false, alpha: false, palette: false };
575 impl NAPixelChromaton {
576 /// Constructs a new `NAPixelChromaton` instance.
577 pub fn new(h_ss: u8, v_ss: u8, packed: bool, depth: u8, shift: u8, comp_offs: u8, next_elem: u8) -> Self {
578 Self { h_ss, v_ss, packed, depth, shift, comp_offs, next_elem }
580 /// Returns subsampling for the current component.
581 pub fn get_subsampling(self) -> (u8, u8) { (self.h_ss, self.v_ss) }
582 /// Reports whether current component is packed.
583 pub fn is_packed(self) -> bool { self.packed }
584 /// Returns bit depth of current component.
585 pub fn get_depth(self) -> u8 { self.depth }
586 /// Returns bit shift for packed component.
587 pub fn get_shift(self) -> u8 { self.shift }
588 /// Returns byte offset for packed component.
589 pub fn get_offset(self) -> u8 { self.comp_offs }
590 /// Returns byte offset to the next element of current packed component.
591 pub fn get_step(self) -> u8 { self.next_elem }
593 /// Calculates the width for current component from general image width.
594 pub fn get_width(self, width: usize) -> usize {
595 (width + ((1 << self.h_ss) - 1)) >> self.h_ss
597 /// Calculates the height for current component from general image height.
598 pub fn get_height(self, height: usize) -> usize {
599 (height + ((1 << self.v_ss) - 1)) >> self.v_ss
601 /// Calculates the minimal stride for current component from general image width.
602 pub fn get_linesize(self, width: usize) -> usize {
603 let d = self.depth as usize;
605 (self.get_width(width) * d + d - 1) >> 3
607 self.get_width(width)
610 /// Calculates the required image size in pixels for current component from general image width.
611 pub fn get_data_size(self, width: usize, height: usize) -> usize {
612 let nh = (height + ((1 << self.v_ss) - 1)) >> self.v_ss;
613 self.get_linesize(width) * nh
617 impl fmt::Display for NAPixelChromaton {
618 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
619 let pfmt = if self.packed {
620 let mask = ((1 << self.depth) - 1) << self.shift;
621 format!("packed(+{},{:X}, step {})", self.comp_offs, mask, self.next_elem)
623 format!("planar({},{})", self.comp_offs, self.next_elem)
625 write!(f, "({}x{}, {})", self.h_ss, self.v_ss, pfmt)
629 impl NAPixelFormaton {
630 /// Constructs a new instance of `NAPixelFormaton`.
631 pub fn new(model: ColorModel,
632 comp1: Option<NAPixelChromaton>,
633 comp2: Option<NAPixelChromaton>,
634 comp3: Option<NAPixelChromaton>,
635 comp4: Option<NAPixelChromaton>,
636 comp5: Option<NAPixelChromaton>,
637 flags: u32, elem_size: u8) -> Self {
638 let mut chromatons: [Option<NAPixelChromaton>; MAX_CHROMATONS] = [None; MAX_CHROMATONS];
640 let be = (flags & FORMATON_FLAG_BE) != 0;
641 let alpha = (flags & FORMATON_FLAG_ALPHA) != 0;
642 let palette = (flags & FORMATON_FLAG_PALETTE) != 0;
643 if let Some(c) = comp1 { chromatons[0] = Some(c); ncomp += 1; }
644 if let Some(c) = comp2 { chromatons[1] = Some(c); ncomp += 1; }
645 if let Some(c) = comp3 { chromatons[2] = Some(c); ncomp += 1; }
646 if let Some(c) = comp4 { chromatons[3] = Some(c); ncomp += 1; }
647 if let Some(c) = comp5 { chromatons[4] = Some(c); ncomp += 1; }
648 NAPixelFormaton { model,
650 comp_info: chromatons,
655 /// Returns current colour model.
656 pub fn get_model(&self) -> ColorModel { self.model }
657 /// Returns the number of components.
658 pub fn get_num_comp(&self) -> usize { self.components as usize }
659 /// Returns selected component information.
660 pub fn get_chromaton(&self, idx: usize) -> Option<NAPixelChromaton> {
661 if idx < self.comp_info.len() { return self.comp_info[idx]; }
664 /// Reports whether the packing format is big-endian.
665 pub fn is_be(self) -> bool { self.be }
666 /// Reports whether colourspace has alpha component.
667 pub fn has_alpha(self) -> bool { self.alpha }
668 /// Reports whether this is paletted format.
669 pub fn is_paletted(self) -> bool { self.palette }
670 /// Returns single packed pixel size.
671 pub fn get_elem_size(self) -> u8 { self.elem_size }
672 /// Reports whether the format is not packed.
673 pub fn is_unpacked(&self) -> bool {
674 if self.palette { return false; }
675 for chr in self.comp_info.iter() {
676 if let Some(ref chromaton) = chr {
677 if chromaton.is_packed() { return false; }
682 /// Returns the maximum component bit depth.
683 pub fn get_max_depth(&self) -> u8 {
685 for chr in self.comp_info.iter() {
686 if let Some(ref chromaton) = chr {
687 mdepth = mdepth.max(chromaton.depth);
692 /// Returns the total amount of bits needed for components.
693 pub fn get_total_depth(&self) -> u8 {
695 for chr in self.comp_info.iter() {
696 if let Some(ref chromaton) = chr {
697 depth += chromaton.depth;
702 /// Returns the maximum component subsampling.
703 pub fn get_max_subsampling(&self) -> u8 {
705 for chr in self.comp_info.iter() {
706 if let Some(ref chromaton) = chr {
707 let (ss_v, ss_h) = chromaton.get_subsampling();
708 ssamp = ssamp.max(ss_v).max(ss_h);
713 #[allow(clippy::cognitive_complexity)]
714 /// Returns a short string description of the format if possible.
715 pub fn to_short_string(&self) -> Option<String> {
717 ColorModel::RGB(_) => {
718 if self.is_paletted() {
719 if *self == PAL8_FORMAT {
720 return Some("pal8".to_string());
725 let mut name = [b'z'; 4];
726 let planar = self.is_unpacked();
728 let mut start_off = 0;
729 let mut start_shift = 0;
730 let mut use_shift = true;
731 for comp in self.comp_info.iter() {
732 if let Some(comp) = comp {
733 start_off = start_off.min(comp.comp_offs);
734 start_shift = start_shift.min(comp.shift);
735 if comp.comp_offs != 0 { use_shift = false; }
738 for component in 0..(self.components as usize) {
739 for (comp, cname) in self.comp_info.iter().zip(b"rgba".iter()) {
740 if let Some(comp) = comp {
742 if comp.shift == start_shift {
743 name[component] = *cname;
744 start_shift += comp.depth;
746 } else if comp.comp_offs == start_off {
747 name[component] = *cname;
751 start_off += (comp.depth + 7) / 8;
758 for (comp, cname) in self.comp_info.iter().zip(b"rgba".iter()) {
759 if let Some(comp) = comp {
760 name[comp.comp_offs as usize] = *cname;
765 let mut name = String::from_utf8(name[..self.components as usize].to_vec()).unwrap();
766 let depth = self.get_total_depth();
767 if depth == 15 || depth == 16 {
768 for c in self.comp_info.iter() {
769 if let Some(comp) = c {
770 name.push((b'0' + comp.depth) as char);
775 name += if self.be { "be" } else { "le" };
778 if depth == 24 || depth != 8 * self.components {
779 name += depth.to_string().as_str();
784 if self.get_max_depth() > 8 {
785 name += if self.be { "be" } else { "le" };
789 ColorModel::YUV(_) => {
790 let max_depth = self.get_max_depth();
791 if self.get_total_depth() != max_depth * self.components {
794 if self.components < 3 {
795 if self.components == 1 && max_depth == 8 {
796 return Some("y8".to_string());
798 if self.components == 2 && self.alpha && max_depth == 8 {
799 return Some("y8a".to_string());
803 let cu = self.comp_info[1].unwrap();
804 let cv = self.comp_info[2].unwrap();
805 if cu.h_ss != cv.h_ss || cu.v_ss != cv.v_ss || cu.h_ss > 2 || cu.v_ss > 2 {
808 let mut name = "yuv".to_string();
813 let sch = b"421"[cu.h_ss as usize];
814 let tch = if cu.v_ss > 1 { b'0' } else { sch };
815 name.push(sch as char);
816 name.push(tch as char);
817 if self.is_unpacked() {
821 name += max_depth.to_string().as_str();
830 impl fmt::Display for NAPixelFormaton {
831 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
832 let end = if self.be { "BE" } else { "LE" };
833 let palstr = if self.palette { "palette " } else { "" };
834 let astr = if self.alpha { "alpha " } else { "" };
835 let mut str = format!("Formaton for {} ({}{}elem {} size {}): ", self.model, palstr, astr,end, self.elem_size);
836 for i in 0..self.comp_info.len() {
837 if let Some(chr) = self.comp_info[i] {
838 str = format!("{} {}", str, chr);
841 write!(f, "[{}]", str)
845 fn parse_rgb_format(s: &str) -> Result<NAPixelFormaton, FormatParseError> {
846 let mut order = [0; 4];
847 let mut is_be = s.ends_with("be");
848 let mut has_alpha = false;
851 let mut bits_start = 0;
852 for (i, ch) in s.chars().enumerate() {
855 if i > 4 { return Err(FormatParseError {}); }
857 'R' | 'r' => { order[0] = i; },
858 'G' | 'g' => { order[1] = i; },
859 'B' | 'b' => { order[2] = i; },
860 'A' | 'a' => { order[3] = i; has_alpha = true; },
862 pstate = 1; bits_start = i;
863 bits = u32::from((ch as u8) - b'0');
865 _ => return Err(FormatParseError {}),
869 if i > 4 + bits_start { return Err(FormatParseError {}); }
872 bits = (bits * 10) + u32::from((ch as u8) - b'0');
874 'B' | 'b' => { pstate = 2; }
875 'L' | 'l' => { pstate = 2; is_be = false; }
876 _ => return Err(FormatParseError {}),
880 if ch != 'e' && ch != 'E' { return Err(FormatParseError {}); }
883 _ => return Err(FormatParseError {}),
886 let components: u8 = if has_alpha { 4 } else { 3 };
887 for el in order.iter() {
888 if *el >= (components as usize) {
889 return Err(FormatParseError {});
892 if order[0] == order[1] || order[0] == order[2] || order[1] == order[2] {
893 return Err(FormatParseError {});
895 if has_alpha && order[0..3].contains(&order[3]) {
896 return Err(FormatParseError {});
898 let mut chromatons = [None; 5];
899 let elem_size = match bits {
901 for (chro, ord) in chromatons.iter_mut().take(components as usize).zip(order.iter()) {
902 *chro = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: *ord as u8, next_elem: components });
907 let rshift = (order[0] * 5) as u8;
908 let gshift = (order[1] * 5) as u8;
909 let bshift = (order[2] * 5) as u8;
910 chromatons[0] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: rshift, comp_offs: 0, next_elem: 2 });
911 chromatons[1] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: gshift, comp_offs: 0, next_elem: 2 });
912 chromatons[2] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: bshift, comp_offs: 0, next_elem: 2 });
913 if has_alpha { return Err(FormatParseError {}); }
917 let mut offs = [0; 3];
918 for (ord, off) in order.iter().zip(offs.iter_mut()) {
919 *off = (*ord * 5) as u8;
922 0 => { offs[0] += 1; offs[2] += 1; },
923 1 => { for el in offs.iter_mut() { if *el == 10 { *el += 1; break; } } },
926 chromatons[0] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: offs[0], comp_offs: 0, next_elem: 2 });
927 chromatons[1] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 6, shift: offs[1], comp_offs: 0, next_elem: 2 });
928 chromatons[2] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: offs[2], comp_offs: 0, next_elem: 2 });
929 if has_alpha { return Err(FormatParseError {}); }
933 let mut offs = [0; 4];
934 let depth = [ 5, 5, 5, 1 ];
937 for (off, ord) in offs.iter_mut().zip(order.iter()) {
940 cur_off += depth[comp];
945 chromatons[0] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: offs[0], comp_offs: 0, next_elem: 2 });
946 chromatons[1] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: offs[1], comp_offs: 0, next_elem: 2 });
947 chromatons[2] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: offs[2], comp_offs: 0, next_elem: 2 });
948 chromatons[3] = Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 1, shift: offs[3], comp_offs: 0, next_elem: 2 });
949 if !has_alpha { return Err(FormatParseError {}); }
952 _ => return Err(FormatParseError {}),
954 Ok(NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB),
956 comp_info: chromatons,
958 be: is_be, alpha: has_alpha, palette: false })
961 fn parse_yuv_format(s: &str) -> Result<NAPixelFormaton, FormatParseError> {
963 "y8" | "y400" | "gray" => {
964 return Ok(NAPixelFormaton {
965 model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 1,
967 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: false, depth: 8, shift: 0, comp_offs: 0, next_elem: 1 }),
968 None, None, None, None],
969 elem_size: 1, be: true, alpha: false, palette: false });
971 "y8a" | "y400a" | "graya" => {
972 return Ok(NAPixelFormaton {
973 model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 2,
975 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: false, depth: 8, shift: 0, comp_offs: 0, next_elem: 2 }),
976 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: false, depth: 8, shift: 0, comp_offs: 1, next_elem: 2 }),
978 elem_size: 1, be: true, alpha: true, palette: false });
981 return Ok(NAPixelFormaton {
982 model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 3,
984 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 1, next_elem: 2 }),
985 Some(NAPixelChromaton{ h_ss: 1, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 4 }),
986 Some(NAPixelChromaton{ h_ss: 1, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 2, next_elem: 4 }),
988 elem_size: 4, be: false, alpha: false, palette: false });
990 "yuy2" | "yuyv" | "v422" => {
991 return Ok(NAPixelFormaton {
992 model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 3,
994 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 2 }),
995 Some(NAPixelChromaton{ h_ss: 1, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 1, next_elem: 4 }),
996 Some(NAPixelChromaton{ h_ss: 1, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 3, next_elem: 4 }),
998 elem_size: 4, be: false, alpha: false, palette: false });
1001 return Ok(NAPixelFormaton {
1002 model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 3,
1004 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 2 }),
1005 Some(NAPixelChromaton{ h_ss: 1, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 3, next_elem: 4 }),
1006 Some(NAPixelChromaton{ h_ss: 1, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 1, next_elem: 4 }),
1008 elem_size: 4, be: false, alpha: false, palette: false });
1011 return Ok(NAPixelFormaton {
1012 model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 3,
1014 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 1, next_elem: 2 }),
1015 Some(NAPixelChromaton{ h_ss: 1, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 2, next_elem: 4 }),
1016 Some(NAPixelChromaton{ h_ss: 1, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 4 }),
1018 elem_size: 4, be: false, alpha: false, palette: false });
1022 if !s.starts_with("yuv") {
1023 return Err(FormatParseError {});
1025 let has_alpha = s.starts_with("yuva");
1026 let components: u8 = if has_alpha { 4 } else { 3 };
1027 let mut is_planar = false;
1029 let mut parse_end = components as usize;
1030 for ch in s.chars().skip(components as usize) {
1032 if ch >= '0' && ch <= '9' {
1033 format = format * 10 + u32::from((ch as u8) - b'0');
1034 if format > 444 { return Err(FormatParseError {}); }
1036 is_planar = ch == 'p';
1040 if format == 0 { return Err(FormatParseError {}); }
1041 let depth = if s.len() == parse_end { 8 } else {
1043 for ch in s.chars().skip(parse_end) {
1044 if ch >= '0' && ch <= '9' {
1045 val = val * 10 + ((ch as u8) - b'0');
1046 if val > 16 { return Err(FormatParseError {}); }
1053 if depth == 0 { return Err(FormatParseError {}); }
1054 let is_be = s.ends_with("be");
1056 let mut chromatons = [None; 5];
1057 let next_elem = if is_planar { (depth + 7) >> 3 } else {
1058 components * ((depth + 7) >> 3) };
1059 let subsamp: [[u8; 2]; 4] = match format {
1060 410 => [[0, 0], [2, 2], [2, 2], [0, 0]],
1061 411 => [[0, 0], [2, 0], [2, 0], [0, 0]],
1062 420 => [[0, 0], [1, 1], [1, 1], [0, 0]],
1063 422 => [[0, 0], [1, 0], [1, 0], [0, 0]],
1064 440 => [[0, 0], [0, 1], [0, 1], [0, 0]],
1065 444 => [[0, 0], [0, 0], [0, 0], [0, 0]],
1066 _ => return Err(FormatParseError {}),
1068 for (i, (chro, ss)) in chromatons.iter_mut().take(components as usize).zip(subsamp.iter()).enumerate() {
1069 *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 });
1071 Ok(NAPixelFormaton { model: ColorModel::YUV(YUVSubmodel::YUVJ),
1073 comp_info: chromatons,
1074 elem_size: components,
1075 be: is_be, alpha: has_alpha, palette: false })
1078 impl FromStr for NAPixelFormaton {
1079 type Err = FormatParseError;
1081 #[allow(clippy::single_match)]
1082 fn from_str(s: &str) -> Result<Self, Self::Err> {
1084 "pal8" => return Ok(PAL8_FORMAT),
1087 let ret = parse_rgb_format(s);
1101 println!("{}", SND_S16_FORMAT);
1102 println!("{}", SND_U8_FORMAT);
1103 println!("{}", SND_F32P_FORMAT);
1104 assert_eq!(SND_U8_FORMAT.to_short_string(), "u8");
1105 assert_eq!(SND_F32P_FORMAT.to_short_string(), "f32lep");
1106 let s16fmt = SND_S16_FORMAT.to_short_string();
1107 assert_eq!(NASoniton::from_str(s16fmt.as_str()).unwrap(), SND_S16_FORMAT);
1108 println!("formaton yuv- {}", YUV420_FORMAT);
1109 println!("formaton pal- {}", PAL8_FORMAT);
1110 println!("formaton rgb565- {}", RGB565_FORMAT);
1112 let pfmt = NAPixelFormaton::from_str("rgb24").unwrap();
1113 assert!(pfmt == RGB24_FORMAT);
1115 assert_eq!(pfmt, NAPixelFormaton::from_str("gbra").unwrap().to_short_string().unwrap());
1116 let pfmt = NAPixelFormaton::from_str("yuv420").unwrap();
1117 println!("parsed pfmt as {} / {:?}", pfmt, pfmt.to_short_string());
1118 let pfmt = NAPixelFormaton::from_str("yuva420p12").unwrap();
1119 println!("parsed pfmt as {} / {:?}", pfmt, pfmt.to_short_string());
1121 assert_eq!(RGB565_FORMAT.to_short_string().unwrap(), "bgr565le");
1122 assert_eq!(PAL8_FORMAT.to_short_string().unwrap(), "pal8");
1123 assert_eq!(YUV420_FORMAT.to_short_string().unwrap(), "yuv422p");
1124 assert_eq!(YUVA410_FORMAT.to_short_string().unwrap(), "yuva410p");