Commit | Line | Data |
---|---|---|
32ce974d | 1 | use std::str::FromStr; |
fba6f8e4 KS |
2 | use std::string::*; |
3 | use std::fmt; | |
4 | ||
b68ff5ae | 5 | #[derive(Debug,Copy,Clone,PartialEq)] |
fba6f8e4 KS |
6 | pub struct NASoniton { |
7 | bits: u8, | |
8 | be: bool, | |
9 | packed: bool, | |
10 | planar: bool, | |
11 | float: bool, | |
12 | signed: bool, | |
13 | } | |
14 | ||
9e9a3af1 KS |
15 | pub const SONITON_FLAG_BE :u32 = 0x01; |
16 | pub const SONITON_FLAG_PACKED :u32 = 0x02; | |
17 | pub const SONITON_FLAG_PLANAR :u32 = 0x04; | |
18 | pub const SONITON_FLAG_FLOAT :u32 = 0x08; | |
19 | pub const SONITON_FLAG_SIGNED :u32 = 0x10; | |
fba6f8e4 KS |
20 | |
21 | pub const SND_U8_FORMAT: NASoniton = NASoniton { bits: 8, be: false, packed: false, planar: false, float: false, signed: false }; | |
22 | pub const SND_S16_FORMAT: NASoniton = NASoniton { bits: 16, be: false, packed: false, planar: false, float: false, signed: true }; | |
126b7eb8 | 23 | pub const SND_F32P_FORMAT: NASoniton = NASoniton { bits: 32, be: false, packed: false, planar: true, float: true, signed: true }; |
fba6f8e4 KS |
24 | |
25 | impl NASoniton { | |
9e9a3af1 KS |
26 | pub fn new(bits: u8, flags: u32) -> Self { |
27 | let is_be = (flags & SONITON_FLAG_BE) != 0; | |
28 | let is_pk = (flags & SONITON_FLAG_PACKED) != 0; | |
29 | let is_pl = (flags & SONITON_FLAG_PLANAR) != 0; | |
30 | let is_fl = (flags & SONITON_FLAG_FLOAT) != 0; | |
31 | let is_sg = (flags & SONITON_FLAG_SIGNED) != 0; | |
fba6f8e4 KS |
32 | NASoniton { bits: bits, be: is_be, packed: is_pk, planar: is_pl, float: is_fl, signed: is_sg } |
33 | } | |
34 | ||
35 | pub fn get_bits(&self) -> u8 { self.bits } | |
36 | pub fn is_be(&self) -> bool { self.be } | |
37 | pub fn is_packed(&self) -> bool { self.packed } | |
38 | pub fn is_planar(&self) -> bool { self.planar } | |
39 | pub fn is_float(&self) -> bool { self.float } | |
40 | pub fn is_signed(&self) -> bool { self.signed } | |
15e41b31 KS |
41 | |
42 | pub fn get_audio_size(&self, length: u64) -> usize { | |
43 | if self.packed { | |
44 | ((length * (self.bits as u64) + 7) >> 3) as usize | |
45 | } else { | |
46 | (length * (((self.bits + 7) >> 3) as u64)) as usize | |
47 | } | |
48 | } | |
fba6f8e4 KS |
49 | } |
50 | ||
51 | impl fmt::Display for NASoniton { | |
52 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { | |
53 | let fmt = if self.float { "float" } else if self.signed { "int" } else { "uint" }; | |
54 | let end = if self.be { "BE" } else { "LE" }; | |
55 | write!(f, "({} bps, {} planar: {} packed: {} {})", self.bits, end, self.packed, self.planar, fmt) | |
56 | } | |
57 | } | |
58 | ||
10a00d52 | 59 | #[derive(Debug,Clone,Copy,PartialEq)] |
fba6f8e4 KS |
60 | pub enum NAChannelType { |
61 | 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 | |
62 | } | |
63 | ||
64 | impl NAChannelType { | |
65 | pub fn is_center(&self) -> bool { | |
66 | match *self { | |
67 | NAChannelType::C => true, NAChannelType::Ch => true, | |
68 | NAChannelType::Cl => true, NAChannelType::Ov => true, | |
69 | NAChannelType::LFE => true, NAChannelType::LFE2 => true, | |
70 | NAChannelType::Cs => true, NAChannelType::Chs => true, | |
71 | _ => false, | |
72 | } | |
73 | } | |
74 | pub fn is_left(&self) -> bool { | |
75 | match *self { | |
76 | NAChannelType::L => true, NAChannelType::Ls => true, | |
77 | NAChannelType::Lss => true, NAChannelType::Lc => true, | |
78 | NAChannelType::Lh => true, NAChannelType::Lw => true, | |
79 | NAChannelType::Lhs => true, NAChannelType::Ll => true, | |
80 | NAChannelType::Lt => true, NAChannelType::Lo => true, | |
81 | _ => false, | |
82 | } | |
83 | } | |
84 | pub fn is_right(&self) -> bool { | |
85 | match *self { | |
86 | NAChannelType::R => true, NAChannelType::Rs => true, | |
87 | NAChannelType::Rss => true, NAChannelType::Rc => true, | |
88 | NAChannelType::Rh => true, NAChannelType::Rw => true, | |
89 | NAChannelType::Rhs => true, NAChannelType::Rl => true, | |
90 | NAChannelType::Rt => true, NAChannelType::Ro => true, | |
91 | _ => false, | |
92 | } | |
93 | } | |
94 | } | |
95 | ||
32ce974d KS |
96 | #[derive(Clone,Copy,Debug,PartialEq)] |
97 | pub struct ChannelParseError {} | |
98 | ||
99 | impl FromStr for NAChannelType { | |
100 | type Err = ChannelParseError; | |
101 | ||
102 | fn from_str(s: &str) -> Result<Self, Self::Err> { | |
103 | match s { | |
104 | "C" => Ok(NAChannelType::C), | |
105 | "L" => Ok(NAChannelType::L), | |
106 | "R" => Ok(NAChannelType::R), | |
107 | "Cs" => Ok(NAChannelType::Cs), | |
108 | "Ls" => Ok(NAChannelType::Ls), | |
109 | "Rs" => Ok(NAChannelType::Rs), | |
110 | "Lss" => Ok(NAChannelType::Lss), | |
111 | "Rss" => Ok(NAChannelType::Rss), | |
112 | "LFE" => Ok(NAChannelType::LFE), | |
113 | "Lc" => Ok(NAChannelType::Lc), | |
114 | "Rc" => Ok(NAChannelType::Rc), | |
115 | "Lh" => Ok(NAChannelType::Lh), | |
116 | "Rh" => Ok(NAChannelType::Rh), | |
117 | "Ch" => Ok(NAChannelType::Ch), | |
118 | "LFE2" => Ok(NAChannelType::LFE2), | |
119 | "Lw" => Ok(NAChannelType::Lw), | |
120 | "Rw" => Ok(NAChannelType::Rw), | |
121 | "Ov" => Ok(NAChannelType::Ov), | |
122 | "Lhs" => Ok(NAChannelType::Lhs), | |
123 | "Rhs" => Ok(NAChannelType::Rhs), | |
124 | "Chs" => Ok(NAChannelType::Chs), | |
125 | "Ll" => Ok(NAChannelType::Ll), | |
126 | "Rl" => Ok(NAChannelType::Rl), | |
127 | "Cl" => Ok(NAChannelType::Cl), | |
128 | "Lt" => Ok(NAChannelType::Lt), | |
129 | "Rt" => Ok(NAChannelType::Rt), | |
130 | "Lo" => Ok(NAChannelType::Lo), | |
131 | "Ro" => Ok(NAChannelType::Ro), | |
132 | _ => Err(ChannelParseError{}), | |
133 | } | |
134 | } | |
135 | } | |
136 | ||
fba6f8e4 KS |
137 | impl fmt::Display for NAChannelType { |
138 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { | |
139 | let name = match *self { | |
140 | NAChannelType::C => "C".to_string(), | |
141 | NAChannelType::L => "L".to_string(), | |
142 | NAChannelType::R => "R".to_string(), | |
143 | NAChannelType::Cs => "Cs".to_string(), | |
144 | NAChannelType::Ls => "Ls".to_string(), | |
145 | NAChannelType::Rs => "Rs".to_string(), | |
146 | NAChannelType::Lss => "Lss".to_string(), | |
147 | NAChannelType::Rss => "Rss".to_string(), | |
148 | NAChannelType::LFE => "LFE".to_string(), | |
149 | NAChannelType::Lc => "Lc".to_string(), | |
150 | NAChannelType::Rc => "Rc".to_string(), | |
151 | NAChannelType::Lh => "Lh".to_string(), | |
152 | NAChannelType::Rh => "Rh".to_string(), | |
153 | NAChannelType::Ch => "Ch".to_string(), | |
154 | NAChannelType::LFE2 => "LFE2".to_string(), | |
155 | NAChannelType::Lw => "Lw".to_string(), | |
156 | NAChannelType::Rw => "Rw".to_string(), | |
157 | NAChannelType::Ov => "Ov".to_string(), | |
158 | NAChannelType::Lhs => "Lhs".to_string(), | |
159 | NAChannelType::Rhs => "Rhs".to_string(), | |
160 | NAChannelType::Chs => "Chs".to_string(), | |
161 | NAChannelType::Ll => "Ll".to_string(), | |
162 | NAChannelType::Rl => "Rl".to_string(), | |
163 | NAChannelType::Cl => "Cl".to_string(), | |
164 | NAChannelType::Lt => "Lt".to_string(), | |
165 | NAChannelType::Rt => "Rt".to_string(), | |
166 | NAChannelType::Lo => "Lo".to_string(), | |
167 | NAChannelType::Ro => "Ro".to_string(), | |
168 | }; | |
169 | write!(f, "{}", name) | |
170 | } | |
171 | } | |
172 | ||
15e41b31 | 173 | #[derive(Clone)] |
fba6f8e4 KS |
174 | pub struct NAChannelMap { |
175 | ids: Vec<NAChannelType>, | |
176 | } | |
177 | ||
62b33487 KS |
178 | const MS_CHANNEL_MAP: [NAChannelType; 11] = [ |
179 | NAChannelType::L, | |
180 | NAChannelType::R, | |
181 | NAChannelType::C, | |
182 | NAChannelType::LFE, | |
183 | NAChannelType::Ls, | |
184 | NAChannelType::Rs, | |
185 | NAChannelType::Lss, | |
186 | NAChannelType::Rss, | |
187 | NAChannelType::Cs, | |
188 | NAChannelType::Lc, | |
189 | NAChannelType::Rc, | |
190 | ]; | |
191 | ||
fba6f8e4 KS |
192 | impl NAChannelMap { |
193 | pub fn new() -> Self { NAChannelMap { ids: Vec::new() } } | |
194 | pub fn add_channel(&mut self, ch: NAChannelType) { | |
195 | self.ids.push(ch); | |
196 | } | |
10a00d52 KS |
197 | pub fn add_channels(&mut self, chs: &[NAChannelType]) { |
198 | for i in 0..chs.len() { | |
199 | self.ids.push(chs[i]); | |
200 | } | |
201 | } | |
fba6f8e4 KS |
202 | pub fn num_channels(&self) -> usize { |
203 | self.ids.len() | |
204 | } | |
205 | pub fn get_channel(&self, idx: usize) -> NAChannelType { | |
206 | self.ids[idx] | |
207 | } | |
208 | pub fn find_channel_id(&self, t: NAChannelType) -> Option<u8> { | |
209 | for i in 0..self.ids.len() { | |
210 | if self.ids[i] as i32 == t as i32 { return Some(i as u8); } | |
211 | } | |
212 | None | |
213 | } | |
62b33487 KS |
214 | pub fn from_ms_mapping(chmap: u32) -> Self { |
215 | let mut cm = NAChannelMap::new(); | |
216 | for i in 0..MS_CHANNEL_MAP.len() { | |
217 | if ((chmap >> i) & 1) != 0 { | |
218 | cm.add_channel(MS_CHANNEL_MAP[i]); | |
219 | } | |
220 | } | |
221 | cm | |
222 | } | |
fba6f8e4 KS |
223 | } |
224 | ||
32ce974d KS |
225 | impl fmt::Display for NAChannelMap { |
226 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { | |
227 | let mut map = String::new(); | |
228 | for el in self.ids.iter() { | |
229 | if map.len() > 0 { map.push(','); } | |
230 | map.push_str(&*el.to_string()); | |
231 | } | |
232 | write!(f, "{}", map) | |
233 | } | |
234 | } | |
235 | ||
236 | impl FromStr for NAChannelMap { | |
237 | type Err = ChannelParseError; | |
238 | ||
239 | fn from_str(s: &str) -> Result<Self, Self::Err> { | |
240 | let mut chm = NAChannelMap::new(); | |
241 | for tok in s.split(',') { | |
242 | chm.add_channel(NAChannelType::from_str(tok)?); | |
243 | } | |
244 | Ok(chm) | |
245 | } | |
246 | } | |
247 | ||
b68ff5ae | 248 | #[derive(Debug,Clone,Copy,PartialEq)] |
fba6f8e4 KS |
249 | pub enum RGBSubmodel { |
250 | RGB, | |
251 | SRGB, | |
252 | } | |
253 | ||
254 | impl fmt::Display for RGBSubmodel { | |
255 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { | |
256 | let name = match *self { | |
257 | RGBSubmodel::RGB => "RGB".to_string(), | |
258 | RGBSubmodel::SRGB => "sRGB".to_string(), | |
259 | }; | |
260 | write!(f, "{}", name) | |
261 | } | |
262 | } | |
263 | ||
b68ff5ae | 264 | #[derive(Debug,Clone,Copy,PartialEq)] |
fba6f8e4 KS |
265 | pub enum YUVSubmodel { |
266 | YCbCr, | |
267 | YIQ, | |
268 | YUVJ, | |
269 | } | |
270 | ||
271 | impl fmt::Display for YUVSubmodel { | |
272 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { | |
273 | let name = match *self { | |
274 | YUVSubmodel::YCbCr => "YCbCr".to_string(), | |
275 | YUVSubmodel::YIQ => "YIQ".to_string(), | |
276 | YUVSubmodel::YUVJ => "YUVJ".to_string(), | |
277 | }; | |
278 | write!(f, "{}", name) | |
279 | } | |
280 | } | |
281 | ||
b68ff5ae | 282 | #[derive(Debug, Clone,Copy,PartialEq)] |
fba6f8e4 KS |
283 | pub enum ColorModel { |
284 | RGB(RGBSubmodel), | |
285 | YUV(YUVSubmodel), | |
286 | CMYK, | |
287 | HSV, | |
288 | LAB, | |
289 | XYZ, | |
290 | } | |
291 | ||
292 | impl ColorModel { | |
293 | pub fn get_default_components(&self) -> usize { | |
294 | match *self { | |
295 | ColorModel::CMYK => 4, | |
296 | _ => 3, | |
297 | } | |
298 | } | |
299 | } | |
300 | ||
301 | impl fmt::Display for ColorModel { | |
302 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { | |
303 | let name = match *self { | |
304 | ColorModel::RGB(fmt) => format!("RGB({})", fmt).to_string(), | |
305 | ColorModel::YUV(fmt) => format!("YUV({})", fmt).to_string(), | |
306 | ColorModel::CMYK => "CMYK".to_string(), | |
307 | ColorModel::HSV => "HSV".to_string(), | |
308 | ColorModel::LAB => "LAB".to_string(), | |
309 | ColorModel::XYZ => "XYZ".to_string(), | |
310 | }; | |
311 | write!(f, "{}", name) | |
312 | } | |
313 | } | |
314 | ||
b68ff5ae | 315 | #[derive(Clone,Copy,PartialEq)] |
fba6f8e4 KS |
316 | pub struct NAPixelChromaton { |
317 | h_ss: u8, | |
318 | v_ss: u8, | |
319 | packed: bool, | |
320 | depth: u8, | |
321 | shift: u8, | |
322 | comp_offs: u8, | |
323 | next_elem: u8, | |
324 | } | |
325 | ||
9e9a3af1 KS |
326 | pub const FORMATON_FLAG_BE :u32 = 0x01; |
327 | pub const FORMATON_FLAG_ALPHA :u32 = 0x02; | |
328 | pub const FORMATON_FLAG_PALETTE :u32 = 0x04; | |
fba6f8e4 KS |
329 | |
330 | ||
b68ff5ae | 331 | #[derive(Clone,Copy,PartialEq)] |
fba6f8e4 KS |
332 | pub struct NAPixelFormaton { |
333 | model: ColorModel, | |
334 | components: u8, | |
335 | comp_info: [Option<NAPixelChromaton>; 5], | |
336 | elem_size: u8, | |
337 | be: bool, | |
338 | alpha: bool, | |
339 | palette: bool, | |
340 | } | |
341 | ||
342 | macro_rules! chromaton { | |
343 | ($hs: expr, $vs: expr, $pck: expr, $d: expr, $sh: expr, $co: expr, $ne: expr) => ({ | |
344 | Some(NAPixelChromaton{ h_ss: $hs, v_ss: $vs, packed: $pck, depth: $d, shift: $sh, comp_offs: $co, next_elem: $ne }) | |
345 | }); | |
346 | (yuv8; $hs: expr, $vs: expr, $co: expr) => ({ | |
347 | Some(NAPixelChromaton{ h_ss: $hs, v_ss: $vs, packed: false, depth: 8, shift: 0, comp_offs: $co, next_elem: 1 }) | |
348 | }); | |
349 | (packrgb; $d: expr, $s: expr, $co: expr, $ne: expr) => ({ | |
350 | Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: $d, shift: $s, comp_offs: $co, next_elem: $ne }) | |
351 | }); | |
352 | (pal8; $co: expr) => ({ | |
353 | Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: $co, next_elem: 3 }) | |
354 | }); | |
355 | } | |
356 | ||
357 | pub const YUV420_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 3, | |
358 | comp_info: [ | |
359 | chromaton!(0, 0, false, 8, 0, 0, 1), | |
360 | chromaton!(yuv8; 1, 1, 1), | |
361 | chromaton!(yuv8; 1, 1, 2), | |
362 | None, None], | |
363 | elem_size: 0, be: false, alpha: false, palette: false }; | |
364 | ||
b68ff5ae KS |
365 | pub const YUV410_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 3, |
366 | comp_info: [ | |
367 | chromaton!(0, 0, false, 8, 0, 0, 1), | |
368 | chromaton!(yuv8; 2, 2, 1), | |
369 | chromaton!(yuv8; 2, 2, 2), | |
370 | None, None], | |
371 | elem_size: 0, be: false, alpha: false, palette: false }; | |
a2a9732a KS |
372 | pub const YUVA410_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 4, |
373 | comp_info: [ | |
374 | chromaton!(0, 0, false, 8, 0, 0, 1), | |
375 | chromaton!(yuv8; 2, 2, 1), | |
376 | chromaton!(yuv8; 2, 2, 2), | |
377 | chromaton!(0, 0, false, 8, 0, 3, 1), | |
378 | None], | |
379 | elem_size: 0, be: false, alpha: true, palette: false }; | |
b68ff5ae | 380 | |
fba6f8e4 KS |
381 | pub const PAL8_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3, |
382 | comp_info: [ | |
383 | chromaton!(pal8; 0), | |
384 | chromaton!(pal8; 1), | |
385 | chromaton!(pal8; 2), | |
386 | None, None], | |
387 | elem_size: 3, be: false, alpha: false, palette: true }; | |
388 | ||
389 | pub const RGB565_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3, | |
390 | comp_info: [ | |
391 | chromaton!(packrgb; 5, 11, 0, 2), | |
392 | chromaton!(packrgb; 6, 5, 0, 2), | |
393 | chromaton!(packrgb; 5, 0, 0, 2), | |
394 | None, None], | |
395 | elem_size: 2, be: false, alpha: false, palette: false }; | |
396 | ||
653e5afd KS |
397 | pub const RGB24_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3, |
398 | comp_info: [ | |
399 | chromaton!(packrgb; 8, 0, 2, 3), | |
400 | chromaton!(packrgb; 8, 0, 1, 3), | |
401 | chromaton!(packrgb; 8, 0, 0, 3), | |
402 | None, None], | |
403 | elem_size: 3, be: false, alpha: false, palette: false }; | |
404 | ||
fba6f8e4 KS |
405 | impl NAPixelChromaton { |
406 | pub fn get_subsampling(&self) -> (u8, u8) { (self.h_ss, self.v_ss) } | |
407 | pub fn is_packed(&self) -> bool { self.packed } | |
408 | pub fn get_depth(&self) -> u8 { self.depth } | |
409 | pub fn get_shift(&self) -> u8 { self.shift } | |
410 | pub fn get_offset(&self) -> u8 { self.comp_offs } | |
411 | pub fn get_step(&self) -> u8 { self.next_elem } | |
b68ff5ae | 412 | |
15e41b31 KS |
413 | pub fn get_width(&self, width: usize) -> usize { |
414 | (width + ((1 << self.h_ss) - 1)) >> self.h_ss | |
415 | } | |
416 | pub fn get_height(&self, height: usize) -> usize { | |
417 | (height + ((1 << self.v_ss) - 1)) >> self.v_ss | |
418 | } | |
b68ff5ae | 419 | pub fn get_linesize(&self, width: usize) -> usize { |
b68ff5ae | 420 | let d = self.depth as usize; |
6c8e5c40 KS |
421 | if self.packed { |
422 | (self.get_width(width) * d + d - 1) >> 3 | |
423 | } else { | |
424 | self.get_width(width) | |
425 | } | |
b68ff5ae KS |
426 | } |
427 | pub fn get_data_size(&self, width: usize, height: usize) -> usize { | |
428 | let nh = (height + ((1 << self.v_ss) - 1)) >> self.v_ss; | |
429 | self.get_linesize(width) * nh | |
430 | } | |
fba6f8e4 KS |
431 | } |
432 | ||
433 | impl fmt::Display for NAPixelChromaton { | |
434 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { | |
435 | let pfmt = if self.packed { | |
436 | let mask = ((1 << self.depth) - 1) << self.shift; | |
437 | format!("packed(+{},{:X}, step {})", self.comp_offs, mask, self.next_elem) | |
438 | } else { | |
439 | format!("planar({},{})", self.comp_offs, self.next_elem) | |
440 | }; | |
441 | write!(f, "({}x{}, {})", self.h_ss, self.v_ss, pfmt) | |
442 | } | |
443 | } | |
444 | ||
445 | impl NAPixelFormaton { | |
446 | pub fn new(model: ColorModel, | |
447 | comp1: Option<NAPixelChromaton>, | |
448 | comp2: Option<NAPixelChromaton>, | |
449 | comp3: Option<NAPixelChromaton>, | |
450 | comp4: Option<NAPixelChromaton>, | |
451 | comp5: Option<NAPixelChromaton>, | |
9e9a3af1 | 452 | flags: u32, elem_size: u8) -> Self { |
fba6f8e4 KS |
453 | let mut chromatons: [Option<NAPixelChromaton>; 5] = [None; 5]; |
454 | let mut ncomp = 0; | |
9e9a3af1 KS |
455 | let be = (flags & FORMATON_FLAG_BE) != 0; |
456 | let alpha = (flags & FORMATON_FLAG_ALPHA) != 0; | |
457 | let palette = (flags & FORMATON_FLAG_PALETTE) != 0; | |
fba6f8e4 KS |
458 | if let Some(c) = comp1 { chromatons[0] = Some(c); ncomp += 1; } |
459 | if let Some(c) = comp2 { chromatons[1] = Some(c); ncomp += 1; } | |
460 | if let Some(c) = comp3 { chromatons[2] = Some(c); ncomp += 1; } | |
461 | if let Some(c) = comp4 { chromatons[3] = Some(c); ncomp += 1; } | |
462 | if let Some(c) = comp5 { chromatons[4] = Some(c); ncomp += 1; } | |
463 | NAPixelFormaton { model: model, | |
464 | components: ncomp, | |
465 | comp_info: chromatons, | |
466 | elem_size: elem_size, | |
467 | be: be, alpha: alpha, palette: palette } | |
468 | } | |
469 | ||
470 | pub fn get_model(&self) -> ColorModel { self.model } | |
b68ff5ae | 471 | pub fn get_num_comp(&self) -> usize { self.components as usize } |
fba6f8e4 KS |
472 | pub fn get_chromaton(&self, idx: usize) -> Option<NAPixelChromaton> { |
473 | if idx < self.comp_info.len() { return self.comp_info[idx]; } | |
474 | None | |
475 | } | |
476 | pub fn is_be(&self) -> bool { self.be } | |
477 | pub fn has_alpha(&self) -> bool { self.alpha } | |
478 | pub fn is_paletted(&self) -> bool { self.palette } | |
479 | pub fn get_elem_size(&self) -> u8 { self.elem_size } | |
480 | } | |
481 | ||
482 | impl fmt::Display for NAPixelFormaton { | |
483 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { | |
484 | let end = if self.be { "BE" } else { "LE" }; | |
485 | let palstr = if self.palette { "palette " } else { "" }; | |
486 | let astr = if self.alpha { "alpha " } else { "" }; | |
487 | let mut str = format!("Formaton for {} ({}{}elem {} size {}): ", self.model, palstr, astr,end, self.elem_size); | |
488 | for i in 0..self.comp_info.len() { | |
489 | if let Some(chr) = self.comp_info[i] { | |
490 | str = format!("{} {}", str, chr); | |
491 | } | |
492 | } | |
493 | write!(f, "[{}]", str) | |
494 | } | |
495 | } | |
496 | ||
497 | #[cfg(test)] | |
498 | mod test { | |
499 | use super::*; | |
500 | ||
501 | #[test] | |
502 | fn test_fmt() { | |
503 | println!("{}", SND_S16_FORMAT); | |
504 | println!("{}", SND_U8_FORMAT); | |
126b7eb8 | 505 | println!("{}", SND_F32P_FORMAT); |
fba6f8e4 KS |
506 | println!("formaton yuv- {}", YUV420_FORMAT); |
507 | println!("formaton pal- {}", PAL8_FORMAT); | |
508 | println!("formaton rgb565- {}", RGB565_FORMAT); | |
509 | } | |
510 | } |