1use std::io::Write;
2use std::mem;
3
4use g2p::{g2p, GaloisField};
5
6use crate::version_db::{RSParameters, VERSION_DATA_BASE};
7use crate::{BitGrid, DeQRError, DeQRResult};
8
9g2p!(GF16, 4, modulus: 0b1_0011);
10g2p!(GF256, 8, modulus: 0b1_0001_1101);
11
12pub const MAX_PAYLOAD_SIZE: usize = 8896;
13
14#[derive(Debug, Clone, Copy, Eq, PartialEq)]
16pub struct Version(pub usize);
17
18impl Version {
19 pub fn from_size(b: usize) -> DeQRResult<Self> {
21 let computed_version = b.saturating_sub(17) / 4;
22
23 if computed_version > 0 && computed_version <= 40 {
24 Ok(Version(computed_version))
25 } else {
26 Err(DeQRError::InvalidVersion)
27 }
28 }
29
30 pub fn to_size(&self) -> usize {
32 self.0 * 4 + 17
33 }
34}
35
36#[derive(Debug, Clone, Copy)]
41pub struct MetaData {
42 pub version: Version,
44 pub ecc_level: u16,
46 pub mask: u16,
48}
49
50#[derive(Clone)]
52pub struct RawData {
53 pub data: [u8; MAX_PAYLOAD_SIZE],
55 pub len: usize,
57}
58
59impl RawData {
60 pub fn push(&mut self, bit: bool) {
62 assert!((self.len / 8) < MAX_PAYLOAD_SIZE);
63 let bitpos = (self.len & 7) as u8;
64 let bytepos = self.len >> 3;
65
66 if bit {
67 self.data[bytepos] |= 0x80_u8 >> bitpos;
68 }
69 self.len += 1;
70 }
71}
72
73#[derive(Clone)]
74pub struct CorrectedDataStream {
75 data: [u8; MAX_PAYLOAD_SIZE],
76 ptr: usize,
77 bit_len: usize,
78}
79
80impl CorrectedDataStream {
81 pub fn bits_remaining(&self) -> usize {
82 assert!(self.bit_len >= self.ptr);
83 self.bit_len - self.ptr
84 }
85
86 pub fn take_bits(&mut self, nbits: usize) -> usize {
87 let mut ret = 0;
88 let max_len = ::std::cmp::min(self.bits_remaining(), nbits);
89 assert!(max_len <= mem::size_of::<usize>() * 8);
90 for _ in 0..max_len {
91 let b = self.data[self.ptr >> 3];
92 let bitpos = self.ptr & 7;
93 ret <<= 1;
94 if 0 != (b << bitpos) & 0x80 {
95 ret |= 1
96 }
97 self.ptr += 1;
98 }
99
100 ret
101 }
102}
103
104pub fn decode<W>(code: &dyn BitGrid, writer: W) -> DeQRResult<MetaData>
110where
111 W: Write,
112{
113 fn _decode(c: &dyn BitGrid) -> DeQRResult<(MetaData, CorrectedDataStream)> {
114 let (meta, raw) = get_raw(c, true)?;
115 let stream = codestream_ecc(&meta, raw)?;
116 Ok((meta, stream))
117 }
118 let (meta, stream) = match _decode(code) {
119 Ok((meta, stream)) => (meta, stream),
120 Err(original) => match _decode(&crate::MirroredGrid(code)) {
121 Ok((meta, stream)) => (meta, stream),
122 Err(_) => return Err(original),
123 },
124 };
125
126 decode_payload(&meta, stream, writer)?;
127 Ok(meta)
128}
129
130pub fn get_raw(code: &dyn BitGrid, remove_masked: bool) -> DeQRResult<(MetaData, RawData)> {
134 let meta = read_format(code)?;
135 let raw = read_data(code, &meta, remove_masked);
136 Ok((meta, raw))
137}
138
139fn decode_payload<W>(meta: &MetaData, mut ds: CorrectedDataStream, mut writer: W) -> DeQRResult<()>
140where
141 W: Write,
142{
143 while ds.bits_remaining() >= 4 {
144 let ty = ds.take_bits(4);
145 match ty {
146 0 => break,
147 1 => decode_numeric(meta, &mut ds, &mut writer),
148 2 => decode_alpha(meta, &mut ds, &mut writer),
149 4 => decode_byte(meta, &mut ds, &mut writer),
150 8 => decode_kanji(meta, &mut ds, &mut writer),
151 7 => decode_eci(meta, &mut ds, &mut writer),
152 _ => Err(DeQRError::UnknownDataType)?,
153 }?;
154 }
155 Ok(())
156}
157
158fn decode_eci<W>(_meta: &MetaData, ds: &mut CorrectedDataStream, mut _writer: W) -> DeQRResult<()>
159where
160 W: Write,
161{
162 if ds.bits_remaining() < 8 {
163 Err(DeQRError::DataUnderflow)?
164 }
165
166 let mut _eci = ds.take_bits(8) as u32;
167 if _eci & 0xc0 == 0x80 {
168 if ds.bits_remaining() < 8 {
169 Err(DeQRError::DataUnderflow)?
170 }
171 _eci = (_eci << 8) | (ds.take_bits(8) as u32)
172 } else if _eci & 0xe0 == 0xc0 {
173 if ds.bits_remaining() < 16 {
174 Err(DeQRError::DataUnderflow)?
175 }
176
177 _eci = (_eci << 16) | (ds.take_bits(16) as u32)
178 }
179 Ok(())
180}
181
182fn decode_kanji<W>(meta: &MetaData, ds: &mut CorrectedDataStream, mut writer: W) -> DeQRResult<()>
183where
184 W: Write,
185{
186 let nbits = match meta.version {
187 Version(0..=9) => 8,
188 Version(10..=26) => 10,
189 _ => 12,
190 };
191
192 let count = ds.take_bits(nbits);
193 if ds.bits_remaining() < count * 13 {
194 Err(DeQRError::DataUnderflow)?
195 }
196
197 for _ in 0..count {
198 let d = ds.take_bits(13);
199 let ms_b = d / 0xc0;
200 let ls_b = d % 0xc0;
201 let intermediate = (ms_b << 8) | ls_b;
202 let sjw = if intermediate + 0x8140 <= 0x9ffc {
203 (intermediate + 0x8140) as u16
205 } else {
206 (intermediate + 0xc140) as u16
207 };
208 writer
209 .write_all(&[(sjw >> 8) as u8, (sjw & 0xff) as u8])
210 .map_err(|_| DeQRError::IoError)?;
211 }
212 Ok(())
213}
214
215fn decode_byte<W>(meta: &MetaData, ds: &mut CorrectedDataStream, mut writer: W) -> DeQRResult<()>
216where
217 W: Write,
218{
219 let nbits = match meta.version {
220 Version(0..=9) => 8,
221 _ => 16,
222 };
223
224 let count = ds.take_bits(nbits);
225 if ds.bits_remaining() < count * 8 {
226 Err(DeQRError::DataUnderflow)?;
227 }
228
229 for _ in 0..count {
230 let buf = &[ds.take_bits(8) as u8];
231 writer.write_all(buf).map_err(|_| DeQRError::IoError)?;
232 }
233 Ok(())
234}
235
236fn decode_alpha<W>(meta: &MetaData, ds: &mut CorrectedDataStream, mut writer: W) -> DeQRResult<()>
237where
238 W: Write,
239{
240 let nbits = match meta.version {
241 Version(0..=9) => 9,
242 Version(10..=26) => 11,
243 _ => 13,
244 };
245 let mut count = ds.take_bits(nbits);
246 let mut buf = [0; 2];
247
248 while count >= 2 {
249 alpha_tuple(&mut buf, ds, 11, 2)?;
250 writer.write_all(&buf[..]).map_err(|_| DeQRError::IoError)?;
251 count -= 2;
252 }
253
254 if count == 1 {
255 alpha_tuple(&mut buf, ds, 6, 1)?;
256 writer
257 .write_all(&buf[..1])
258 .map_err(|_| DeQRError::IoError)?;
259 }
260
261 Ok(())
262}
263
264fn alpha_tuple(
265 buf: &mut [u8; 2],
266 ds: &mut CorrectedDataStream,
267 nbits: usize,
268 digits: usize,
269) -> DeQRResult<()> {
270 if ds.bits_remaining() < nbits {
271 Err(DeQRError::DataUnderflow)
272 } else {
273 let mut tuple = ds.take_bits(nbits);
274 for i in (0..digits).rev() {
275 const ALPHA_MAP: &[u8; 46] = b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:\x00";
276 buf[i] = ALPHA_MAP[tuple % 45];
277 tuple /= 45;
278 }
279 Ok(())
280 }
281}
282
283fn decode_numeric<W>(meta: &MetaData, ds: &mut CorrectedDataStream, mut writer: W) -> DeQRResult<()>
284where
285 W: Write,
286{
287 let nbits = match meta.version {
288 Version(0..=9) => 10,
289 Version(10..=26) => 12,
290 _ => 14,
291 };
292
293 let mut count = ds.take_bits(nbits);
294 let mut buf = [0; 3];
295 while count >= 3 {
296 numeric_tuple(&mut buf, ds, 10, 3)?;
297 writer.write_all(&buf[..]).map_err(|_| DeQRError::IoError)?;
298 count -= 3;
299 }
300
301 if count == 2 {
302 numeric_tuple(&mut buf, ds, 7, 2)?;
303 writer
304 .write_all(&buf[..2])
305 .map_err(|_| DeQRError::IoError)?;
306 count -= 2;
307 }
308 if count == 1 {
309 numeric_tuple(&mut buf, ds, 4, 1)?;
310 writer
311 .write_all(&buf[..1])
312 .map_err(|_| DeQRError::IoError)?;
313 }
314
315 Ok(())
316}
317
318fn numeric_tuple(
319 buf: &mut [u8; 3],
320 ds: &mut CorrectedDataStream,
321 nbits: usize,
322 digits: usize,
323) -> DeQRResult<()> {
324 if ds.bits_remaining() < nbits {
325 Err(DeQRError::DataUnderflow)
326 } else {
327 let mut tuple = ds.take_bits(nbits);
328 for i in (0..digits).rev() {
329 buf[i] = (tuple % 10) as u8 + b'0';
330 tuple /= 10;
331 }
332 Ok(())
333 }
334}
335
336fn codestream_ecc(meta: &MetaData, ds: RawData) -> DeQRResult<CorrectedDataStream> {
337 let mut out = CorrectedDataStream {
338 data: [0; MAX_PAYLOAD_SIZE],
339 ptr: 0,
340 bit_len: 0,
341 };
342
343 let ver = &VERSION_DATA_BASE[meta.version.0];
344 let sb_ecc = &ver.ecc[meta.ecc_level as usize];
345 let lb_ecc = RSParameters {
346 bs: sb_ecc.bs + 1,
347 dw: sb_ecc.dw + 1,
348 ns: sb_ecc.ns,
349 };
350
351 let lb_count = (ver.data_bytes - sb_ecc.bs * sb_ecc.ns) / (sb_ecc.bs + 1);
352 let bc = lb_count + sb_ecc.ns;
353 let ecc_offset = sb_ecc.dw * bc + lb_count;
354
355 let mut dst_offset = 0;
356 for i in 0..bc {
357 let ecc = if i < sb_ecc.ns { sb_ecc } else { &lb_ecc };
358 let dst = &mut out.data[dst_offset..(dst_offset + ecc.bs)];
359 let num_ec = ecc.bs - ecc.dw;
360 #[allow(clippy::needless_range_loop)]
361 for j in 0..ecc.dw {
362 dst[j] = ds.data[j * bc + i];
363 }
364 for j in 0..num_ec {
365 dst[ecc.dw + j] = ds.data[ecc_offset + j * bc + i];
366 }
367 correct_block(dst, ecc)?;
368
369 dst_offset += ecc.dw;
370 }
371
372 out.bit_len = dst_offset * 8;
373 Ok(out)
374}
375
376fn correct_block(block: &mut [u8], ecc: &RSParameters) -> DeQRResult<()> {
377 assert!(ecc.bs > ecc.dw);
378
379 let npar = ecc.bs - ecc.dw;
380 let mut sigma_deriv = [GF256::ZERO; 64];
381
382 let s = match block_syndromes(&block[..ecc.bs], npar) {
384 Ok(_) => return Ok(()),
385 Err(s) => s,
386 };
387
388 let sigma = berlekamp_massey(&s, npar);
389 for i in (1..64).step_by(2) {
391 sigma_deriv[i - 1] = sigma[i];
392 }
393
394 let omega = eloc_poly(&s, &sigma, npar - 1);
396
397 for i in 0..ecc.bs {
399 let xinv = GF256::GENERATOR.pow(255 - i);
400 if poly_eval(&sigma, xinv) == GF256::ZERO {
401 let sd_x = poly_eval(&sigma_deriv, xinv);
402 let omega_x = poly_eval(&omega, xinv);
403 if sd_x == GF256::ZERO {
404 return Err(DeQRError::DataEcc);
405 }
406 let error = omega_x / sd_x;
407 block[ecc.bs - i - 1] = (GF256(block[ecc.bs - i - 1]) + error).0;
408 }
409 }
410
411 match block_syndromes(&block[..ecc.bs], npar) {
412 Ok(_) => Ok(()),
413 Err(_) => Err(DeQRError::DataEcc),
414 }
415}
416fn block_syndromes(block: &[u8], npar: usize) -> Result<[GF256; 64], [GF256; 64]> {
422 let mut nonzero: bool = false;
423 let mut s = [GF256::ZERO; 64];
424
425 #[allow(clippy::needless_range_loop)]
426 for i in 0..npar {
427 for j in 0..block.len() {
428 let c = GF256(block[block.len() - 1 - j]);
429 s[i] += c * GF256::GENERATOR.pow(i * j);
430 }
431 if s[i] != GF256::ZERO {
432 nonzero = true;
433 }
434 }
435 if nonzero {
436 Err(s)
437 } else {
438 Ok(s)
439 }
440}
441
442fn poly_eval<G>(s: &[G; 64], x: G) -> G
443where
444 G: GaloisField,
445{
446 let mut sum = G::ZERO;
447 let mut x_pow = G::ONE;
448
449 #[allow(clippy::needless_range_loop)]
450 for i in 0..64 {
451 sum += s[i] * x_pow;
452 x_pow *= x;
453 }
454 sum
455}
456
457fn eloc_poly(s: &[GF256; 64], sigma: &[GF256; 64], npar: usize) -> [GF256; 64] {
458 let mut omega = [GF256::ZERO; 64];
459 for i in 0..npar {
460 let a = sigma[i];
461 for j in 0..(npar - i) {
462 let b = s[j + 1];
463 omega[i + j] += a * b;
464 }
465 }
466 omega
467}
468fn berlekamp_massey<G>(s: &[G; 64], n: usize) -> [G; 64]
472where
473 G: GaloisField,
474{
475 let mut ts: [G; 64] = [G::ZERO; 64];
476 let mut cs: [G; 64] = [G::ZERO; 64];
477 let mut bs: [G; 64] = [G::ZERO; 64];
478 let mut l: usize = 0;
479 let mut m: usize = 1;
480 let mut b = G::ONE;
481 bs[0] = G::ONE;
482 cs[0] = G::ONE;
483
484 for n in 0..n {
485 let mut d = s[n];
486
487 for i in 1..=l {
490 d += cs[i] * s[n - i];
491 }
492 let mult = d / b;
494
495 if d == G::ZERO {
496 m += 1
497 } else if l * 2 <= n {
498 ts.copy_from_slice(&cs);
499 poly_add(&mut cs, &bs, mult, m);
500 bs.copy_from_slice(&ts);
501 l = n + 1 - l;
502 b = d;
503 m = 1
504 } else {
505 poly_add(&mut cs, &bs, mult, m);
506 m += 1
507 }
508 }
509 cs
510}
511fn poly_add<G>(dst: &mut [G; 64], src: &[G; 64], c: G, shift: usize)
515where
516 G: GaloisField,
517{
518 if c == G::ZERO {
519 return;
520 }
521
522 #[allow(clippy::needless_range_loop)]
523 for i in 0..64 {
524 let p = i + shift;
525 if p >= 64 {
526 break;
527 }
528 let v = src[i];
529 dst[p] += v * c;
530 }
531}
532
533fn read_data(code: &dyn BitGrid, meta: &MetaData, remove_mask: bool) -> RawData {
535 let mut ds = RawData {
536 data: [0; MAX_PAYLOAD_SIZE],
537 len: 0,
538 };
539
540 let mut y = code.size() - 1;
541 let mut x = code.size() - 1;
542 let mut neg_dir = true;
543
544 while x > 0 {
545 if x == 6 {
546 x -= 1;
547 }
548 if !reserved_cell(meta.version, y, x) {
549 ds.push(read_bit(code, meta, y, x, remove_mask));
550 }
551 if !reserved_cell(meta.version, y, x - 1) {
552 ds.push(read_bit(code, meta, y, x - 1, remove_mask));
553 }
554
555 let (new_y, new_neg_dir) = match (y, neg_dir) {
556 (0, true) => {
557 x = x.saturating_sub(2);
558 (0, false)
559 }
560 (y, false) if y == code.size() - 1 => {
561 x = x.saturating_sub(2);
562 (code.size() - 1, true)
563 }
564 (y, true) => (y - 1, true),
565 (y, false) => (y + 1, false),
566 };
567
568 y = new_y;
569 neg_dir = new_neg_dir;
570 }
571
572 ds
573}
574
575fn read_bit(code: &dyn BitGrid, meta: &MetaData, y: usize, x: usize, remove_mask: bool) -> bool {
578 let mut v = code.bit(y, x) as u8;
579 if remove_mask && mask_bit(meta.mask, y, x) {
580 v ^= 1
581 }
582
583 v != 0
584}
585
586fn mask_bit(mask: u16, y: usize, x: usize) -> bool {
587 match mask {
588 0 => 0 == (y + x) % 2,
589 1 => 0 == y % 2,
590 2 => 0 == x % 3,
591 3 => 0 == (y + x) % 3,
592 4 => 0 == ((y / 2) + (x / 3)) % 2,
593 5 => 0 == ((y * x) % 2 + (y * x) % 3),
594 6 => 0 == ((y * x) % 2 + (y * x) % 3) % 2,
595 7 => 0 == ((y * x) % 3 + (y + x) % 2) % 2,
596 _ => panic!("Unknown mask value"),
597 }
598}
599
600fn reserved_cell(version: Version, i: usize, j: usize) -> bool {
601 let ver = &VERSION_DATA_BASE[version.0];
602 let size = version.0 * 4 + 17;
603
604 if i < 9 && j < 9 {
606 return true;
607 }
608
609 if i + 8 >= size && j < 9 {
611 return true;
612 }
613
614 if i < 9 && j + 8 >= size {
616 return true;
617 }
618
619 if i == 6 || j == 6 {
621 return true;
622 }
623
624 if version.0 >= 7 {
629 #[allow(clippy::if_same_then_else)]
630 if i < 6 && j + 11 >= size {
631 return true;
632 } else if i + 11 >= size && j < 6 {
633 return true;
634 }
635 }
636
637 let mut ai = None;
639 let mut aj = None;
640
641 let mut len = 0;
642 for (a, &pattern) in ver.apat.iter().take_while(|&&x| x != 0).enumerate() {
643 len = a;
644 if pattern.abs_diff(i) < 3 {
645 ai = Some(a)
646 }
647 if pattern.abs_diff(j) < 3 {
648 aj = Some(a)
649 }
650 }
651
652 match (ai, aj) {
653 (Some(x), Some(y)) if x == len && y == len => true,
654 (Some(x), Some(_)) if 0 < x && x < len => true,
655 (Some(_), Some(x)) if 0 < x && x < len => true,
656 _ => false,
657 }
658}
659
660fn correct_format(mut word: u16) -> DeQRResult<u16> {
661 if let Err(s) = format_syndromes(word) {
665 let sigma = berlekamp_massey(&s, 6);
666
667 for i in 0..15 {
669 if poly_eval(&sigma, GF16::GENERATOR.pow(15 - i)) == GF16::ZERO {
670 word ^= 1 << i;
671 }
672 }
673
674 format_syndromes(word).map_err(|_| DeQRError::FormatEcc)?;
676 }
677 Ok(word)
678}
679
680fn read_format(code: &dyn BitGrid) -> DeQRResult<MetaData> {
681 let mut format = 0;
682
683 const XS: [usize; 15] = [8, 8, 8, 8, 8, 8, 8, 8, 7, 5, 4, 3, 2, 1, 0];
685 const YS: [usize; 15] = [0, 1, 2, 3, 4, 5, 7, 8, 8, 8, 8, 8, 8, 8, 8];
686 for i in (0..15).rev() {
687 format = (format << 1) | code.bit(YS[i], XS[i]) as u16;
688 }
689 format ^= 0x5412;
690
691 let verified_format = correct_format(format).or_else(|_| {
693 let mut format = 0;
694 for i in 0..7 {
695 format = (format << 1) | code.bit(code.size() - 1 - i, 8) as u16;
696 }
697 for i in 0..8 {
698 format = (format << 1) | code.bit(8, code.size() - 8 + i) as u16;
699 }
700 format ^= 0x5412;
701 correct_format(format)
702 })?;
703
704 let fdata = verified_format >> 10;
705 let ecc_level = fdata >> 3;
706 let mask = fdata & 7;
707 let version = Version::from_size(code.size())?;
708
709 Ok(MetaData {
710 version,
711 ecc_level,
712 mask,
713 })
714}
715fn format_syndromes(u: u16) -> Result<[GF16; 64], [GF16; 64]> {
721 let mut result = [GF16(0); 64];
722 let mut nonzero = false;
723
724 #[allow(clippy::needless_range_loop)]
725 for i in 0..6 {
726 for j in 0..15 {
727 if u & (1 << j) != 0 {
728 result[i] += GF16::GENERATOR.pow((i + 1) * j);
729 }
730 }
731 if result[i].0 != 0 {
732 nonzero = true;
733 }
734 }
735
736 if nonzero {
737 Err(result)
738 } else {
739 Ok(result)
740 }
741}
742
743#[cfg(test)]
744mod tests {
745 use super::*;
746
747 #[test]
748 fn test_mask_0() {
749 let test = [
750 [1, 0, 1, 0, 1, 0, 1],
751 [0, 1, 0, 1, 0, 1, 0],
752 [1, 0, 1, 0, 1, 0, 1],
753 [0, 1, 0, 1, 0, 1, 0],
754 [1, 0, 1, 0, 1, 0, 1],
755 [0, 1, 0, 1, 0, 1, 0],
756 [1, 0, 1, 0, 1, 0, 1],
757 ];
758
759 for x in 0..7 {
760 for y in 0..7 {
761 assert_eq!(test[y][x] != 0, mask_bit(0, y, x));
762 }
763 }
764 }
765
766 #[test]
767 fn test_mask_1() {
768 let test = [
769 [1, 1, 1, 1, 1, 1, 1],
770 [0, 0, 0, 0, 0, 0, 0],
771 [1, 1, 1, 1, 1, 1, 1],
772 [0, 0, 0, 0, 0, 0, 0],
773 [1, 1, 1, 1, 1, 1, 1],
774 [0, 0, 0, 0, 0, 0, 0],
775 [1, 1, 1, 1, 1, 1, 1],
776 ];
777
778 for x in 0..7 {
779 for y in 0..7 {
780 assert_eq!(test[y][x] != 0, mask_bit(1, y, x));
781 }
782 }
783 }
784
785 #[test]
786 fn test_mask_2() {
787 let test = [
788 [1, 0, 0, 1, 0, 0, 1],
789 [1, 0, 0, 1, 0, 0, 1],
790 [1, 0, 0, 1, 0, 0, 1],
791 [1, 0, 0, 1, 0, 0, 1],
792 [1, 0, 0, 1, 0, 0, 1],
793 [1, 0, 0, 1, 0, 0, 1],
794 [1, 0, 0, 1, 0, 0, 1],
795 ];
796
797 for x in 0..7 {
798 for y in 0..7 {
799 assert_eq!(test[y][x] != 0, mask_bit(2, y, x));
800 }
801 }
802 }
803
804 #[test]
805 fn test_mask_3() {
806 let test = [
807 [1, 0, 0, 1, 0, 0, 1],
808 [0, 0, 1, 0, 0, 1, 0],
809 [0, 1, 0, 0, 1, 0, 0],
810 [1, 0, 0, 1, 0, 0, 1],
811 [0, 0, 1, 0, 0, 1, 0],
812 [0, 1, 0, 0, 1, 0, 0],
813 [1, 0, 0, 1, 0, 0, 1],
814 ];
815
816 for x in 0..7 {
817 for y in 0..7 {
818 assert_eq!(test[y][x] != 0, mask_bit(3, y, x));
819 }
820 }
821 }
822
823 #[test]
824 fn test_mask_4() {
825 let test = [
826 [1, 1, 1, 0, 0, 0, 1],
827 [1, 1, 1, 0, 0, 0, 1],
828 [0, 0, 0, 1, 1, 1, 0],
829 [0, 0, 0, 1, 1, 1, 0],
830 [1, 1, 1, 0, 0, 0, 1],
831 [1, 1, 1, 0, 0, 0, 1],
832 [0, 0, 0, 1, 1, 1, 0],
833 ];
834
835 for x in 0..7 {
836 for y in 0..7 {
837 assert_eq!(test[y][x] != 0, mask_bit(4, y, x));
838 }
839 }
840 }
841
842 #[test]
843 fn test_mask_5() {
844 let test = [
845 [1, 1, 1, 1, 1, 1, 1],
846 [1, 0, 0, 0, 0, 0, 1],
847 [1, 0, 0, 1, 0, 0, 1],
848 [1, 0, 1, 0, 1, 0, 1],
849 [1, 0, 0, 1, 0, 0, 1],
850 [1, 0, 0, 0, 0, 0, 1],
851 [1, 1, 1, 1, 1, 1, 1],
852 ];
853
854 for x in 0..7 {
855 for y in 0..7 {
856 assert_eq!(test[y][x] != 0, mask_bit(5, y, x));
857 }
858 }
859 }
860
861 #[test]
862 fn test_mask_6() {
863 let test = [
864 [1, 1, 1, 1, 1, 1, 1],
865 [1, 1, 1, 0, 0, 0, 1],
866 [1, 1, 0, 1, 1, 0, 1],
867 [1, 0, 1, 0, 1, 0, 1],
868 [1, 0, 1, 1, 0, 1, 1],
869 [1, 0, 0, 0, 1, 1, 1],
870 [1, 1, 1, 1, 1, 1, 1],
871 ];
872
873 for x in 0..7 {
874 for y in 0..7 {
875 assert_eq!(test[y][x] != 0, mask_bit(6, y, x));
876 }
877 }
878 }
879
880 #[test]
881 fn test_mask_7() {
882 let test = [
883 [1, 0, 1, 0, 1, 0, 1],
884 [0, 0, 0, 1, 1, 1, 0],
885 [1, 0, 0, 0, 1, 1, 1],
886 [0, 1, 0, 1, 0, 1, 0],
887 [1, 1, 1, 0, 0, 0, 1],
888 [0, 1, 1, 1, 0, 0, 0],
889 [1, 0, 1, 0, 1, 0, 1],
890 ];
891
892 for x in 0..7 {
893 for y in 0..7 {
894 assert_eq!(test[y][x] != 0, mask_bit(7, y, x));
895 }
896 }
897 }
898}