Skip to main content

rqrr/
decode.rs

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/// Version of a QR Code which determines its size
15#[derive(Debug, Clone, Copy, Eq, PartialEq)]
16pub struct Version(pub usize);
17
18impl Version {
19    /// Given the grid size, determine the likely grid size
20    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    /// Return the size of a grid of the given version
31    pub fn to_size(&self) -> usize {
32        self.0 * 4 + 17
33    }
34}
35
36/// MetaData for a QR grid
37///
38/// Stores information about the size/version of given grid. Also contains
39/// information about the error correction level and bit mask used.
40#[derive(Debug, Clone, Copy)]
41pub struct MetaData {
42    /// The version/size of the grid
43    pub version: Version,
44    /// the error correction leven, between 0 and 3
45    pub ecc_level: u16,
46    /// The mask that was used, value between 0 and 7
47    pub mask: u16,
48}
49
50/// The bit stream contained in the QR Code
51#[derive(Clone)]
52pub struct RawData {
53    /// The bits of the QR Code
54    pub data: [u8; MAX_PAYLOAD_SIZE],
55    /// Length of the bit stream in bits.
56    pub len: usize,
57}
58
59impl RawData {
60    /// Push a new bit into the bit stream
61    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
104/// Given a grid try to decode and write it to the output writer
105///
106/// This tries to read the bit patterns from a [Grid](trait.Grid.html), correct
107/// errors and/or missing bits and write the result to the output. If successful
108/// also returns [MetaData](struct.MetaData.html) of the read grid.
109pub 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
130/// Return extracted metadata and the raw, uncorrected bit stream.
131///
132/// Optionally, you can keep the stream masked, so the data appears as it was in the image.
133pub 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            /* bytes are in the range 0x8140 to 0x9FFC */
204            (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    // Calculate syndromes. If all 0 there is nothing to do.
383    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    /* Compute derivative of sigma */
390    for i in (1..64).step_by(2) {
391        sigma_deriv[i - 1] = sigma[i];
392    }
393
394    /* Compute error evaluator polynomial */
395    let omega = eloc_poly(&s, &sigma, npar - 1);
396
397    /* Find error locations and magnitudes */
398    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}
416/* ***********************************************************************
417 * Code stream error correction
418 *
419 * Generator polynomial for GF(2^8) is x^8 + x^4 + x^3 + x^2 + 1
420 */
421fn 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}
468/* ***********************************************************************
469 * Berlekamp-Massey algorithm for finding error locator polynomials.
470 */
471fn 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        // Calculate in GF(p):
488        // d = s[n] + \Sum_{i=1}^{l} c[i] * s[n - i]
489        for i in 1..=l {
490            d += cs[i] * s[n - i];
491        }
492        // Pre-calculate d * b^-1 in GF(p)
493        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}
511/* ***********************************************************************
512 * Polynomial operations
513 */
514fn 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
533/// Reads the code in the "zigzag" pattern, optionally removing the mask
534fn 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
575// The read_bit() function can optionally consider the mask.
576// This allows bits to be read as they appear "physically" in the QR code or with the mask removed, reflecting the actual code.
577fn 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    /* Finder + format: top left */
605    if i < 9 && j < 9 {
606        return true;
607    }
608
609    /* Finder + format: bottom left */
610    if i + 8 >= size && j < 9 {
611        return true;
612    }
613
614    /* Finder + format: top right */
615    if i < 9 && j + 8 >= size {
616        return true;
617    }
618
619    /* Exclude timing patterns */
620    if i == 6 || j == 6 {
621        return true;
622    }
623
624    /* Exclude version info, if it exists. Version info sits adjacent to
625     * the top-right and bottom-left finders in three rows, bounded by
626     * the timing pattern.
627     */
628    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    /* Exclude alignment patterns */
638    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    /* Evaluate U (received codeword) at each of alpha_1 .. alpha_6
662     * to get S_1 .. S_6 (but we index them from 0).
663     */
664    if let Err(s) = format_syndromes(word) {
665        let sigma = berlekamp_massey(&s, 6);
666
667        /* Now, find the roots of the polynomial */
668        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        // Double CHECK syndromes
675        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    // Try first location
684    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    // Check format, try other location if needed
692    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}
715/* ***********************************************************************
716 * Format value error correction
717 *
718 * Generator polynomial for GF(2^4) is x^4 + x + 1
719 */
720fn 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}