forked from AbleOS/ableos
TheOddGarlic
9329059510
LBA28 is obsolete at this point, but we prefer to use it over LBA48 whenever we can because LBA28 is faster.
983 lines
32 KiB
Rust
983 lines
32 KiB
Rust
//! The `bits` module encodes binary data into raw bits used in a QR code.
|
||
|
||
use core::cmp::min;
|
||
|
||
#[cfg(feature = "bench")]
|
||
extern crate test;
|
||
|
||
use alloc::vec::Vec;
|
||
|
||
use crate::cast::{As, Truncate};
|
||
use crate::optimize::{total_encoded_len, Optimizer, Parser, Segment};
|
||
use crate::types::{EcLevel, Mode, QrError, QrResult, Version};
|
||
|
||
//------------------------------------------------------------------------------
|
||
//{{{ Bits
|
||
|
||
/// The `Bits` structure stores the encoded data for a QR code.
|
||
pub struct Bits {
|
||
data: Vec<u8>,
|
||
bit_offset: usize,
|
||
version: Version,
|
||
}
|
||
|
||
impl Bits {
|
||
/// Constructs a new, empty bits structure.
|
||
pub fn new(version: Version) -> Self {
|
||
Self { data: Vec::new(), bit_offset: 0, version }
|
||
}
|
||
|
||
/// Pushes an N-bit big-endian integer to the end of the bits.
|
||
///
|
||
/// Note: It is up to the developer to ensure that `number` really only is
|
||
/// `n` bit in size. Otherwise the excess bits may stomp on the existing
|
||
/// ones.
|
||
fn push_number(&mut self, n: usize, number: u16) {
|
||
debug_assert!(n == 16 || n < 16 && number < (1 << n), "{} is too big as a {}-bit number", number, n);
|
||
|
||
let b = self.bit_offset + n;
|
||
let last_index = self.data.len().wrapping_sub(1);
|
||
match (self.bit_offset, b) {
|
||
(0, 0..=8) => {
|
||
self.data.push((number << (8 - b)).truncate_as_u8());
|
||
}
|
||
(0, _) => {
|
||
self.data.push((number >> (b - 8)).truncate_as_u8());
|
||
self.data.push((number << (16 - b)).truncate_as_u8());
|
||
}
|
||
(_, 0..=8) => {
|
||
self.data[last_index] |= (number << (8 - b)).truncate_as_u8();
|
||
}
|
||
(_, 9..=16) => {
|
||
self.data[last_index] |= (number >> (b - 8)).truncate_as_u8();
|
||
self.data.push((number << (16 - b)).truncate_as_u8());
|
||
}
|
||
_ => {
|
||
self.data[last_index] |= (number >> (b - 8)).truncate_as_u8();
|
||
self.data.push((number >> (b - 16)).truncate_as_u8());
|
||
self.data.push((number << (24 - b)).truncate_as_u8());
|
||
}
|
||
}
|
||
self.bit_offset = b & 7;
|
||
}
|
||
|
||
/// Pushes an N-bit big-endian integer to the end of the bits, and check
|
||
/// that the number does not overflow the bits.
|
||
///
|
||
/// Returns `Err(QrError::DataTooLong)` on overflow.
|
||
fn push_number_checked(&mut self, n: usize, number: usize) -> QrResult<()> {
|
||
if n > 16 || number >= (1 << n) {
|
||
Err(QrError::DataTooLong)
|
||
} else {
|
||
self.push_number(n, number.as_u16());
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
/// Reserves `n` extra bits of space for pushing.
|
||
fn reserve(&mut self, n: usize) {
|
||
let extra_bytes = (n + (8 - self.bit_offset) % 8) / 8;
|
||
self.data.reserve(extra_bytes);
|
||
}
|
||
|
||
/// Convert the bits into a bytes vector.
|
||
pub fn into_bytes(self) -> Vec<u8> {
|
||
self.data
|
||
}
|
||
|
||
/// Total number of bits currently pushed.
|
||
pub fn len(&self) -> usize {
|
||
if self.bit_offset == 0 {
|
||
self.data.len() * 8
|
||
} else {
|
||
(self.data.len() - 1) * 8 + self.bit_offset
|
||
}
|
||
}
|
||
|
||
/// Whether there are any bits pushed.
|
||
pub fn is_empty(&self) -> bool {
|
||
self.data.is_empty()
|
||
}
|
||
|
||
/// The maximum number of bits allowed by the provided QR code version and
|
||
/// error correction level.
|
||
///
|
||
/// # Errors
|
||
///
|
||
/// Returns `Err(QrError::InvalidVersion)` if it is not valid to use the
|
||
/// `ec_level` for the given version (e.g. `Version::Micro(1)` with
|
||
/// `EcLevel::H`).
|
||
pub fn max_len(&self, ec_level: EcLevel) -> QrResult<usize> {
|
||
self.version.fetch(ec_level, &DATA_LENGTHS)
|
||
}
|
||
|
||
/// Version of the QR code.
|
||
pub fn version(&self) -> Version {
|
||
self.version
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn test_push_number() {
|
||
let mut bits = Bits::new(Version::Normal(1));
|
||
|
||
bits.push_number(3, 0b010); // 0:0 .. 0:3
|
||
bits.push_number(3, 0b110); // 0:3 .. 0:6
|
||
bits.push_number(3, 0b101); // 0:6 .. 1:1
|
||
bits.push_number(7, 0b001_1010); // 1:1 .. 2:0
|
||
bits.push_number(4, 0b1100); // 2:0 .. 2:4
|
||
bits.push_number(12, 0b1011_0110_1101); // 2:4 .. 4:0
|
||
bits.push_number(10, 0b01_1001_0001); // 4:0 .. 5:2
|
||
bits.push_number(15, 0b111_0010_1110_0011); // 5:2 .. 7:1
|
||
|
||
let bytes = bits.into_bytes();
|
||
|
||
assert_eq!(
|
||
bytes,
|
||
vec![
|
||
0b0101_1010, // 90
|
||
0b1001_1010, // 154
|
||
0b1100_1011, // 203
|
||
0b0110_1101, // 109
|
||
0b01_1001_00, // 100
|
||
0b0111_1001, // 121
|
||
0b0111_0001, // 113
|
||
0b1000_0000, // 128
|
||
]
|
||
);
|
||
}
|
||
|
||
#[cfg(feature = "bench")]
|
||
#[bench]
|
||
fn bench_push_splitted_bytes(bencher: &mut test::Bencher) {
|
||
bencher.iter(|| {
|
||
let mut bits = Bits::new(Version::Normal(40));
|
||
bits.push_number(4, 0b0101);
|
||
for _ in 0..1024 {
|
||
bits.push_number(8, 0b10101010);
|
||
}
|
||
bits.into_bytes()
|
||
});
|
||
}
|
||
|
||
//}}}
|
||
//------------------------------------------------------------------------------
|
||
//{{{ Mode indicator
|
||
|
||
/// An "extended" mode indicator, includes all indicators supported by QR code
|
||
/// beyond those bearing data.
|
||
#[derive(Copy, Clone)]
|
||
pub enum ExtendedMode {
|
||
/// ECI mode indicator, to introduce an ECI designator.
|
||
Eci,
|
||
|
||
/// The normal mode to introduce data.
|
||
Data(Mode),
|
||
|
||
/// FNC-1 mode in the first position.
|
||
Fnc1First,
|
||
|
||
/// FNC-1 mode in the second position.
|
||
Fnc1Second,
|
||
|
||
/// Structured append.
|
||
StructuredAppend,
|
||
}
|
||
|
||
impl Bits {
|
||
/// Push the mode indicator to the end of the bits.
|
||
///
|
||
/// # Errors
|
||
///
|
||
/// If the mode is not supported in the provided version, this method
|
||
/// returns `Err(QrError::UnsupportedCharacterSet)`.
|
||
pub fn push_mode_indicator(&mut self, mode: ExtendedMode) -> QrResult<()> {
|
||
#[allow(clippy::match_same_arms)]
|
||
let number = match (self.version, mode) {
|
||
(Version::Micro(1), ExtendedMode::Data(Mode::Numeric)) => return Ok(()),
|
||
(Version::Micro(_), ExtendedMode::Data(Mode::Numeric)) => 0,
|
||
(Version::Micro(_), ExtendedMode::Data(Mode::Alphanumeric)) => 1,
|
||
(Version::Micro(_), ExtendedMode::Data(Mode::Byte)) => 0b10,
|
||
(Version::Micro(_), ExtendedMode::Data(Mode::Kanji)) => 0b11,
|
||
(Version::Micro(_), _) => return Err(QrError::UnsupportedCharacterSet),
|
||
(_, ExtendedMode::Data(Mode::Numeric)) => 0b0001,
|
||
(_, ExtendedMode::Data(Mode::Alphanumeric)) => 0b0010,
|
||
(_, ExtendedMode::Data(Mode::Byte)) => 0b0100,
|
||
(_, ExtendedMode::Data(Mode::Kanji)) => 0b1000,
|
||
(_, ExtendedMode::Eci) => 0b0111,
|
||
(_, ExtendedMode::Fnc1First) => 0b0101,
|
||
(_, ExtendedMode::Fnc1Second) => 0b1001,
|
||
(_, ExtendedMode::StructuredAppend) => 0b0011,
|
||
};
|
||
let bits = self.version.mode_bits_count();
|
||
self.push_number_checked(bits, number).or(Err(QrError::UnsupportedCharacterSet))
|
||
}
|
||
}
|
||
|
||
//}}}
|
||
//------------------------------------------------------------------------------
|
||
//{{{ ECI
|
||
|
||
impl Bits {
|
||
/// Push an ECI (Extended Channel Interpretation) designator to the bits.
|
||
///
|
||
/// An ECI designator is a 6-digit number to specify the character set of
|
||
/// the following binary data. After calling this method, one could call
|
||
/// `.push_byte_data()` or similar methods to insert the actual data, e.g.
|
||
///
|
||
/// #![allow(unused_must_use)]
|
||
///
|
||
/// use qrcode::bits::Bits;
|
||
/// use qrcode::types::Version;
|
||
///
|
||
/// let mut bits = Bits::new(Version::Normal(1));
|
||
/// bits.push_eci_designator(9); // 9 = ISO-8859-7 (Greek).
|
||
/// bits.push_byte_data(b"\xa1\xa2\xa3\xa4\xa5"); // ΑΒΓΔΕ
|
||
///
|
||
///
|
||
/// The full list of ECI designator values can be found from
|
||
/// <http://strokescribe.com/en/ECI.html>. Some example values are:
|
||
///
|
||
/// ECI # | Character set
|
||
/// ------|-------------------------------------
|
||
/// 3 | ISO-8859-1 (Western European)
|
||
/// 20 | Shift JIS (Japanese)
|
||
/// 23 | Windows 1252 (Latin 1) (Western European)
|
||
/// 25 | UTF-16 Big Endian
|
||
/// 26 | UTF-8
|
||
/// 28 | Big 5 (Traditional Chinese)
|
||
/// 29 | GB-18030 (Simplified Chinese)
|
||
/// 30 | EUC-KR (Korean)
|
||
///
|
||
/// # Errors
|
||
///
|
||
/// If the QR code version does not support ECI, this method will return
|
||
/// `Err(QrError::UnsupportedCharacterSet)`.
|
||
///
|
||
/// If the designator is outside of the expected range, this method will
|
||
/// return `Err(QrError::InvalidECIDesignator)`.
|
||
pub fn push_eci_designator(&mut self, eci_designator: u32) -> QrResult<()> {
|
||
self.reserve(12); // assume the common case that eci_designator <= 127.
|
||
self.push_mode_indicator(ExtendedMode::Eci)?;
|
||
match eci_designator {
|
||
0..=127 => {
|
||
self.push_number(8, eci_designator.as_u16());
|
||
}
|
||
128..=16383 => {
|
||
self.push_number(2, 0b10);
|
||
self.push_number(14, eci_designator.as_u16());
|
||
}
|
||
16384..=999_999 => {
|
||
self.push_number(3, 0b110);
|
||
self.push_number(5, (eci_designator >> 16).as_u16());
|
||
self.push_number(16, (eci_designator & 0xffff).as_u16());
|
||
}
|
||
_ => return Err(QrError::InvalidEciDesignator),
|
||
}
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod eci_tests {
|
||
use crate::bits::Bits;
|
||
use crate::types::{QrError, Version};
|
||
|
||
#[test]
|
||
fn test_9() {
|
||
let mut bits = Bits::new(Version::Normal(1));
|
||
assert_eq!(bits.push_eci_designator(9), Ok(()));
|
||
assert_eq!(bits.into_bytes(), vec![0b0111_0000, 0b1001_0000]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_899() {
|
||
let mut bits = Bits::new(Version::Normal(1));
|
||
assert_eq!(bits.push_eci_designator(899), Ok(()));
|
||
assert_eq!(bits.into_bytes(), vec![0b0111_1000, 0b00111000, 0b0011_0000]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_999999() {
|
||
let mut bits = Bits::new(Version::Normal(1));
|
||
assert_eq!(bits.push_eci_designator(999999), Ok(()));
|
||
assert_eq!(bits.into_bytes(), vec![0b0111_1100, 0b11110100, 0b00100011, 0b1111_0000]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_invalid_designator() {
|
||
let mut bits = Bits::new(Version::Normal(1));
|
||
assert_eq!(bits.push_eci_designator(1000000), Err(QrError::InvalidEciDesignator));
|
||
}
|
||
|
||
#[test]
|
||
fn test_unsupported_character_set() {
|
||
let mut bits = Bits::new(Version::Micro(4));
|
||
assert_eq!(bits.push_eci_designator(9), Err(QrError::UnsupportedCharacterSet));
|
||
}
|
||
}
|
||
|
||
//}}}
|
||
//------------------------------------------------------------------------------
|
||
//{{{ Mode::Numeric mode
|
||
|
||
impl Bits {
|
||
fn push_header(&mut self, mode: Mode, raw_data_len: usize) -> QrResult<()> {
|
||
let length_bits = mode.length_bits_count(self.version);
|
||
self.reserve(length_bits + 4 + mode.data_bits_count(raw_data_len));
|
||
self.push_mode_indicator(ExtendedMode::Data(mode))?;
|
||
self.push_number_checked(length_bits, raw_data_len)?;
|
||
Ok(())
|
||
}
|
||
|
||
/// Encodes a numeric string to the bits.
|
||
///
|
||
/// The data should only contain the characters 0 to 9.
|
||
///
|
||
/// # Errors
|
||
///
|
||
/// Returns `Err(QrError::DataTooLong)` on overflow.
|
||
pub fn push_numeric_data(&mut self, data: &[u8]) -> QrResult<()> {
|
||
self.push_header(Mode::Numeric, data.len())?;
|
||
for chunk in data.chunks(3) {
|
||
let number = chunk.iter().map(|b| u16::from(*b - b'0')).fold(0, |a, b| a * 10 + b);
|
||
let length = chunk.len() * 3 + 1;
|
||
self.push_number(length, number);
|
||
}
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod numeric_tests {
|
||
use crate::bits::Bits;
|
||
use crate::types::{QrError, Version};
|
||
|
||
#[test]
|
||
fn test_iso_18004_2006_example_1() {
|
||
let mut bits = Bits::new(Version::Normal(1));
|
||
assert_eq!(bits.push_numeric_data(b"01234567"), Ok(()));
|
||
assert_eq!(bits.into_bytes(), vec![0b0001_0000, 0b001000_00, 0b00001100, 0b01010110, 0b0110_0001, 0b1000_0000]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_iso_18004_2000_example_2() {
|
||
let mut bits = Bits::new(Version::Normal(1));
|
||
assert_eq!(bits.push_numeric_data(b"0123456789012345"), Ok(()));
|
||
assert_eq!(
|
||
bits.into_bytes(),
|
||
vec![
|
||
0b0001_0000,
|
||
0b010000_00,
|
||
0b00001100,
|
||
0b01010110,
|
||
0b0110_1010,
|
||
0b0110_1110,
|
||
0b000101_00,
|
||
0b11101010,
|
||
0b0101_0000,
|
||
]
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn test_iso_18004_2006_example_2() {
|
||
let mut bits = Bits::new(Version::Micro(3));
|
||
assert_eq!(bits.push_numeric_data(b"0123456789012345"), Ok(()));
|
||
assert_eq!(
|
||
bits.into_bytes(),
|
||
vec![0b0010_0000, 0b00000110, 0b0010_1011, 0b0011_0101, 0b0011_0111, 0b0000_1010, 0b01110101, 0b0010_1000,]
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn test_data_too_long_error() {
|
||
let mut bits = Bits::new(Version::Micro(1));
|
||
assert_eq!(bits.push_numeric_data(b"12345678"), Err(QrError::DataTooLong));
|
||
}
|
||
}
|
||
|
||
//}}}
|
||
//------------------------------------------------------------------------------
|
||
//{{{ Mode::Alphanumeric mode
|
||
|
||
/// In QR code `Mode::Alphanumeric` mode, a pair of alphanumeric characters will
|
||
/// be encoded as a base-45 integer. `alphanumeric_digit` converts each
|
||
/// character into its corresponding base-45 digit.
|
||
///
|
||
/// The conversion is specified in ISO/IEC 18004:2006, §8.4.3, Table 5.
|
||
#[inline]
|
||
fn alphanumeric_digit(character: u8) -> u16 {
|
||
match character {
|
||
b'0'..=b'9' => u16::from(character - b'0'),
|
||
b'A'..=b'Z' => u16::from(character - b'A') + 10,
|
||
b' ' => 36,
|
||
b'$' => 37,
|
||
b'%' => 38,
|
||
b'*' => 39,
|
||
b'+' => 40,
|
||
b'-' => 41,
|
||
b'.' => 42,
|
||
b'/' => 43,
|
||
b':' => 44,
|
||
_ => 0,
|
||
}
|
||
}
|
||
|
||
impl Bits {
|
||
/// Encodes an alphanumeric string to the bits.
|
||
///
|
||
/// The data should only contain the charaters A to Z (excluding lowercase),
|
||
/// 0 to 9, space, `$`, `%`, `*`, `+`, `-`, `.`, `/` or `:`.
|
||
///
|
||
/// # Errors
|
||
///
|
||
/// Returns `Err(QrError::DataTooLong)` on overflow.
|
||
pub fn push_alphanumeric_data(&mut self, data: &[u8]) -> QrResult<()> {
|
||
self.push_header(Mode::Alphanumeric, data.len())?;
|
||
for chunk in data.chunks(2) {
|
||
let number = chunk.iter().map(|b| alphanumeric_digit(*b)).fold(0, |a, b| a * 45 + b);
|
||
let length = chunk.len() * 5 + 1;
|
||
self.push_number(length, number);
|
||
}
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod alphanumeric_tests {
|
||
use crate::bits::Bits;
|
||
use crate::types::{QrError, Version};
|
||
|
||
#[test]
|
||
fn test_iso_18004_2006_example() {
|
||
let mut bits = Bits::new(Version::Normal(1));
|
||
assert_eq!(bits.push_alphanumeric_data(b"AC-42"), Ok(()));
|
||
assert_eq!(bits.into_bytes(), vec![0b0010_0000, 0b0010_1001, 0b11001110, 0b11100111, 0b0010_0001, 0b0000_0000]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_micro_qr_unsupported() {
|
||
let mut bits = Bits::new(Version::Micro(1));
|
||
assert_eq!(bits.push_alphanumeric_data(b"A"), Err(QrError::UnsupportedCharacterSet));
|
||
}
|
||
|
||
#[test]
|
||
fn test_data_too_long() {
|
||
let mut bits = Bits::new(Version::Micro(2));
|
||
assert_eq!(bits.push_alphanumeric_data(b"ABCDEFGH"), Err(QrError::DataTooLong));
|
||
}
|
||
}
|
||
|
||
//}}}
|
||
//------------------------------------------------------------------------------
|
||
//{{{ Mode::Byte mode
|
||
|
||
impl Bits {
|
||
/// Encodes 8-bit byte data to the bits.
|
||
///
|
||
/// # Errors
|
||
///
|
||
/// Returns `Err(QrError::DataTooLong)` on overflow.
|
||
pub fn push_byte_data(&mut self, data: &[u8]) -> QrResult<()> {
|
||
self.push_header(Mode::Byte, data.len())?;
|
||
for b in data {
|
||
self.push_number(8, u16::from(*b));
|
||
}
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod byte_tests {
|
||
use crate::bits::Bits;
|
||
use crate::types::{QrError, Version};
|
||
|
||
#[test]
|
||
fn test() {
|
||
let mut bits = Bits::new(Version::Normal(1));
|
||
assert_eq!(bits.push_byte_data(b"\x12\x34\x56\x78\x9a\xbc\xde\xf0"), Ok(()));
|
||
assert_eq!(
|
||
bits.into_bytes(),
|
||
vec![
|
||
0b0100_0000,
|
||
0b1000_0001,
|
||
0b0010_0011,
|
||
0b0100_0101,
|
||
0b0110_0111,
|
||
0b1000_1001,
|
||
0b1010_1011,
|
||
0b1100_1101,
|
||
0b1110_1111,
|
||
0b0000_0000,
|
||
]
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn test_micro_qr_unsupported() {
|
||
let mut bits = Bits::new(Version::Micro(2));
|
||
assert_eq!(bits.push_byte_data(b"?"), Err(QrError::UnsupportedCharacterSet));
|
||
}
|
||
|
||
#[test]
|
||
fn test_data_too_long() {
|
||
let mut bits = Bits::new(Version::Micro(3));
|
||
assert_eq!(bits.push_byte_data(b"0123456701234567"), Err(QrError::DataTooLong));
|
||
}
|
||
}
|
||
|
||
//}}}
|
||
//------------------------------------------------------------------------------
|
||
//{{{ Mode::Kanji mode
|
||
|
||
impl Bits {
|
||
/// Encodes Shift JIS double-byte data to the bits.
|
||
///
|
||
/// # Errors
|
||
///
|
||
/// Returns `Err(QrError::DataTooLong)` on overflow.
|
||
///
|
||
/// Returns `Err(QrError::InvalidCharacter)` if the data is not Shift JIS
|
||
/// double-byte data (e.g. if the length of data is not an even number).
|
||
pub fn push_kanji_data(&mut self, data: &[u8]) -> QrResult<()> {
|
||
self.push_header(Mode::Kanji, data.len() / 2)?;
|
||
for kanji in data.chunks(2) {
|
||
if kanji.len() != 2 {
|
||
return Err(QrError::InvalidCharacter);
|
||
}
|
||
let cp = u16::from(kanji[0]) * 256 + u16::from(kanji[1]);
|
||
let bytes = if cp < 0xe040 { cp - 0x8140 } else { cp - 0xc140 };
|
||
let number = (bytes >> 8) * 0xc0 + (bytes & 0xff);
|
||
self.push_number(13, number);
|
||
}
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod kanji_tests {
|
||
use crate::bits::Bits;
|
||
use crate::types::{QrError, Version};
|
||
|
||
#[test]
|
||
fn test_iso_18004_example() {
|
||
let mut bits = Bits::new(Version::Normal(1));
|
||
assert_eq!(bits.push_kanji_data(b"\x93\x5f\xe4\xaa"), Ok(()));
|
||
assert_eq!(bits.into_bytes(), vec![0b1000_0000, 0b0010_0110, 0b11001111, 0b1110_1010, 0b1010_1000]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_micro_qr_unsupported() {
|
||
let mut bits = Bits::new(Version::Micro(2));
|
||
assert_eq!(bits.push_kanji_data(b"?"), Err(QrError::UnsupportedCharacterSet));
|
||
}
|
||
|
||
#[test]
|
||
fn test_data_too_long() {
|
||
let mut bits = Bits::new(Version::Micro(3));
|
||
assert_eq!(bits.push_kanji_data(b"\x93_\x93_\x93_\x93_\x93_\x93_\x93_\x93_"), Err(QrError::DataTooLong));
|
||
}
|
||
}
|
||
|
||
//}}}
|
||
//------------------------------------------------------------------------------
|
||
//{{{ FNC1 mode
|
||
|
||
impl Bits {
|
||
/// Encodes an indicator that the following data are formatted according to
|
||
/// the UCC/EAN Application Identifiers standard.
|
||
///
|
||
/// #![allow(unused_must_use)]
|
||
///
|
||
/// use qrcode::bits::Bits;
|
||
/// use qrcode::types::Version;
|
||
///
|
||
/// let mut bits = Bits::new(Version::Normal(1));
|
||
/// bits.push_fnc1_first_position();
|
||
/// bits.push_numeric_data(b"01049123451234591597033130128");
|
||
/// bits.push_alphanumeric_data(b"%10ABC123");
|
||
///
|
||
/// In QR code, the character `%` is used as the data field separator (0x1D).
|
||
///
|
||
/// # Errors
|
||
///
|
||
/// If the mode is not supported in the provided version, this method
|
||
/// returns `Err(QrError::UnsupportedCharacterSet)`.
|
||
pub fn push_fnc1_first_position(&mut self) -> QrResult<()> {
|
||
self.push_mode_indicator(ExtendedMode::Fnc1First)
|
||
}
|
||
|
||
/// Encodes an indicator that the following data are formatted in accordance
|
||
/// with specific industry or application specifications previously agreed
|
||
/// with AIM International.
|
||
///
|
||
/// #![allow(unused_must_use)]
|
||
///
|
||
/// use qrcode::bits::Bits;
|
||
/// use qrcode::types::Version;
|
||
///
|
||
/// let mut bits = Bits::new(Version::Normal(1));
|
||
/// bits.push_fnc1_second_position(37);
|
||
/// bits.push_alphanumeric_data(b"AA1234BBB112");
|
||
/// bits.push_byte_data(b"text text text text\r");
|
||
///
|
||
/// If the application indicator is a single Latin alphabet (a–z / A–Z),
|
||
/// please pass in its ASCII value + 100:
|
||
///
|
||
/// ```ignore
|
||
/// bits.push_fnc1_second_position(b'A' + 100);
|
||
/// ```
|
||
///
|
||
/// # Errors
|
||
///
|
||
/// If the mode is not supported in the provided version, this method
|
||
/// returns `Err(QrError::UnsupportedCharacterSet)`.
|
||
pub fn push_fnc1_second_position(&mut self, application_indicator: u8) -> QrResult<()> {
|
||
self.push_mode_indicator(ExtendedMode::Fnc1Second)?;
|
||
self.push_number(8, u16::from(application_indicator));
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
//}}}
|
||
//------------------------------------------------------------------------------
|
||
//{{{ Finish
|
||
|
||
// This table is copied from ISO/IEC 18004:2006 §6.4.10, Table 7.
|
||
static DATA_LENGTHS: [[usize; 4]; 44] = [
|
||
// Normal versions
|
||
[152, 128, 104, 72],
|
||
[272, 224, 176, 128],
|
||
[440, 352, 272, 208],
|
||
[640, 512, 384, 288],
|
||
[864, 688, 496, 368],
|
||
[1088, 864, 608, 480],
|
||
[1248, 992, 704, 528],
|
||
[1552, 1232, 880, 688],
|
||
[1856, 1456, 1056, 800],
|
||
[2192, 1728, 1232, 976],
|
||
[2592, 2032, 1440, 1120],
|
||
[2960, 2320, 1648, 1264],
|
||
[3424, 2672, 1952, 1440],
|
||
[3688, 2920, 2088, 1576],
|
||
[4184, 3320, 2360, 1784],
|
||
[4712, 3624, 2600, 2024],
|
||
[5176, 4056, 2936, 2264],
|
||
[5768, 4504, 3176, 2504],
|
||
[6360, 5016, 3560, 2728],
|
||
[6888, 5352, 3880, 3080],
|
||
[7456, 5712, 4096, 3248],
|
||
[8048, 6256, 4544, 3536],
|
||
[8752, 6880, 4912, 3712],
|
||
[9392, 7312, 5312, 4112],
|
||
[10208, 8000, 5744, 4304],
|
||
[10960, 8496, 6032, 4768],
|
||
[11744, 9024, 6464, 5024],
|
||
[12248, 9544, 6968, 5288],
|
||
[13048, 10136, 7288, 5608],
|
||
[13880, 10984, 7880, 5960],
|
||
[14744, 11640, 8264, 6344],
|
||
[15640, 12328, 8920, 6760],
|
||
[16568, 13048, 9368, 7208],
|
||
[17528, 13800, 9848, 7688],
|
||
[18448, 14496, 10288, 7888],
|
||
[19472, 15312, 10832, 8432],
|
||
[20528, 15936, 11408, 8768],
|
||
[21616, 16816, 12016, 9136],
|
||
[22496, 17728, 12656, 9776],
|
||
[23648, 18672, 13328, 10208],
|
||
// Micro versions
|
||
[20, 0, 0, 0],
|
||
[40, 32, 0, 0],
|
||
[84, 68, 0, 0],
|
||
[128, 112, 80, 0],
|
||
];
|
||
|
||
impl Bits {
|
||
/// Pushes the ending bits to indicate no more data.
|
||
///
|
||
/// # Errors
|
||
///
|
||
/// Returns `Err(QrError::DataTooLong)` on overflow.
|
||
///
|
||
/// Returns `Err(QrError::InvalidVersion)` if it is not valid to use the
|
||
/// `ec_level` for the given version (e.g. `Version::Micro(1)` with
|
||
/// `EcLevel::H`).
|
||
pub fn push_terminator(&mut self, ec_level: EcLevel) -> QrResult<()> {
|
||
let terminator_size = match self.version {
|
||
Version::Micro(a) => a.as_usize() * 2 + 1,
|
||
_ => 4,
|
||
};
|
||
|
||
let cur_length = self.len();
|
||
let data_length = self.max_len(ec_level)?;
|
||
if cur_length > data_length {
|
||
return Err(QrError::DataTooLong);
|
||
}
|
||
|
||
let terminator_size = min(terminator_size, data_length - cur_length);
|
||
if terminator_size > 0 {
|
||
self.push_number(terminator_size, 0);
|
||
}
|
||
|
||
if self.len() < data_length {
|
||
const PADDING_BYTES: &[u8] = &[0b1110_1100, 0b0001_0001];
|
||
|
||
self.bit_offset = 0;
|
||
let data_bytes_length = data_length / 8;
|
||
let padding_bytes_count = data_bytes_length - self.data.len();
|
||
let padding = PADDING_BYTES.iter().cloned().cycle().take(padding_bytes_count);
|
||
self.data.extend(padding);
|
||
}
|
||
|
||
if self.len() < data_length {
|
||
self.data.push(0);
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod finish_tests {
|
||
use crate::bits::Bits;
|
||
use crate::types::{EcLevel, QrError, Version};
|
||
|
||
#[test]
|
||
fn test_hello_world() {
|
||
let mut bits = Bits::new(Version::Normal(1));
|
||
assert_eq!(bits.push_alphanumeric_data(b"HELLO WORLD"), Ok(()));
|
||
assert_eq!(bits.push_terminator(EcLevel::Q), Ok(()));
|
||
assert_eq!(
|
||
bits.into_bytes(),
|
||
vec![
|
||
0b00100000, 0b01011011, 0b00001011, 0b01111000, 0b11010001, 0b01110010, 0b11011100, 0b01001101,
|
||
0b01000011, 0b01000000, 0b11101100, 0b00010001, 0b11101100,
|
||
]
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn test_too_long() {
|
||
let mut bits = Bits::new(Version::Micro(1));
|
||
assert_eq!(bits.push_numeric_data(b"9999999"), Ok(()));
|
||
assert_eq!(bits.push_terminator(EcLevel::L), Err(QrError::DataTooLong));
|
||
}
|
||
|
||
#[test]
|
||
fn test_no_terminator() {
|
||
let mut bits = Bits::new(Version::Micro(1));
|
||
assert_eq!(bits.push_numeric_data(b"99999"), Ok(()));
|
||
assert_eq!(bits.push_terminator(EcLevel::L), Ok(()));
|
||
assert_eq!(bits.into_bytes(), vec![0b1011_1111, 0b0011_1110, 0b0011_0000]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_no_padding() {
|
||
let mut bits = Bits::new(Version::Micro(1));
|
||
assert_eq!(bits.push_numeric_data(b"9999"), Ok(()));
|
||
assert_eq!(bits.push_terminator(EcLevel::L), Ok(()));
|
||
assert_eq!(bits.into_bytes(), vec![0b1001_1111, 0b0011_1100, 0b1000_0000]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_micro_version_1_half_byte_padding() {
|
||
let mut bits = Bits::new(Version::Micro(1));
|
||
assert_eq!(bits.push_numeric_data(b"999"), Ok(()));
|
||
assert_eq!(bits.push_terminator(EcLevel::L), Ok(()));
|
||
assert_eq!(bits.into_bytes(), vec![0b0111_1111, 0b0011_1000, 0b0000_0000]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_micro_version_1_full_byte_padding() {
|
||
let mut bits = Bits::new(Version::Micro(1));
|
||
assert_eq!(bits.push_numeric_data(b""), Ok(()));
|
||
assert_eq!(bits.push_terminator(EcLevel::L), Ok(()));
|
||
assert_eq!(bits.into_bytes(), vec![0b0000_0000, 0b11101100, 0]);
|
||
}
|
||
}
|
||
|
||
//}}}
|
||
//------------------------------------------------------------------------------
|
||
//{{{ Front end.
|
||
|
||
impl Bits {
|
||
/// Push a segmented data to the bits, and then terminate it.
|
||
///
|
||
/// # Errors
|
||
///
|
||
/// Returns `Err(QrError::DataTooLong)` on overflow.
|
||
///
|
||
/// Returns `Err(QrError::InvalidData)` if the segment refers to incorrectly
|
||
/// encoded byte sequence.
|
||
pub fn push_segments<I>(&mut self, data: &[u8], segments_iter: I) -> QrResult<()>
|
||
where
|
||
I: Iterator<Item = Segment>,
|
||
{
|
||
for segment in segments_iter {
|
||
let slice = &data[segment.begin..segment.end];
|
||
match segment.mode {
|
||
Mode::Numeric => self.push_numeric_data(slice),
|
||
Mode::Alphanumeric => self.push_alphanumeric_data(slice),
|
||
Mode::Byte => self.push_byte_data(slice),
|
||
Mode::Kanji => self.push_kanji_data(slice),
|
||
}?;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// Pushes the data the bits, using the optimal encoding.
|
||
///
|
||
/// # Errors
|
||
///
|
||
/// Returns `Err(QrError::DataTooLong)` on overflow.
|
||
pub fn push_optimal_data(&mut self, data: &[u8]) -> QrResult<()> {
|
||
let segments = Parser::new(data).optimize(self.version);
|
||
self.push_segments(data, segments)
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod encode_tests {
|
||
use alloc::vec::Vec;
|
||
|
||
use crate::bits::Bits;
|
||
use crate::types::{EcLevel, QrError, QrResult, Version};
|
||
|
||
fn encode(data: &[u8], version: Version, ec_level: EcLevel) -> QrResult<Vec<u8>> {
|
||
let mut bits = Bits::new(version);
|
||
bits.push_optimal_data(data)?;
|
||
bits.push_terminator(ec_level)?;
|
||
Ok(bits.into_bytes())
|
||
}
|
||
|
||
#[test]
|
||
fn test_alphanumeric() {
|
||
let res = encode(b"HELLO WORLD", Version::Normal(1), EcLevel::Q);
|
||
assert_eq!(
|
||
res,
|
||
Ok(vec![
|
||
0b00100000, 0b01011011, 0b00001011, 0b01111000, 0b11010001, 0b01110010, 0b11011100, 0b01001101,
|
||
0b01000011, 0b01000000, 0b11101100, 0b00010001, 0b11101100,
|
||
])
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn test_auto_mode_switch() {
|
||
let res = encode(b"123A", Version::Micro(2), EcLevel::L);
|
||
assert_eq!(res, Ok(vec![0b0001_1000, 0b1111_0111, 0b0010_0101, 0b0000_0000, 0b11101100]));
|
||
}
|
||
|
||
#[test]
|
||
fn test_too_long() {
|
||
let res = encode(b">>>>>>>>", Version::Normal(1), EcLevel::H);
|
||
assert_eq!(res, Err(QrError::DataTooLong));
|
||
}
|
||
}
|
||
|
||
//}}}
|
||
//------------------------------------------------------------------------------
|
||
//{{{ Auto version minimization
|
||
|
||
/// Automatically determines the minimum version to store the data, and encode
|
||
/// the result.
|
||
///
|
||
/// This method will not consider any Micro QR code versions.
|
||
///
|
||
/// # Errors
|
||
///
|
||
/// Returns `Err(QrError::DataTooLong)` if the data is too long to fit even the
|
||
/// highest QR code version.
|
||
pub fn encode_auto(data: &[u8], ec_level: EcLevel) -> QrResult<Bits> {
|
||
let segments = Parser::new(data).collect::<Vec<Segment>>();
|
||
for version in &[Version::Normal(9), Version::Normal(26), Version::Normal(40)] {
|
||
let opt_segments = Optimizer::new(segments.iter().cloned(), *version).collect::<Vec<_>>();
|
||
let total_len = total_encoded_len(&opt_segments, *version);
|
||
let data_capacity = version.fetch(ec_level, &DATA_LENGTHS).expect("invalid DATA_LENGTHS");
|
||
if total_len <= data_capacity {
|
||
let min_version = find_min_version(total_len, ec_level);
|
||
let mut bits = Bits::new(min_version);
|
||
bits.reserve(total_len);
|
||
bits.push_segments(data, opt_segments.into_iter())?;
|
||
bits.push_terminator(ec_level)?;
|
||
return Ok(bits);
|
||
}
|
||
}
|
||
Err(QrError::DataTooLong)
|
||
}
|
||
|
||
/// Finds the smallest version (QR code only) that can store N bits of data
|
||
/// in the given error correction level.
|
||
fn find_min_version(length: usize, ec_level: EcLevel) -> Version {
|
||
let mut base = 0_usize;
|
||
let mut size = 39;
|
||
while size > 1 {
|
||
let half = size / 2;
|
||
let mid = base + half;
|
||
// mid is always in [0, size).
|
||
// mid >= 0: by definition
|
||
// mid < size: mid = size / 2 + size / 4 + size / 8 ...
|
||
base = if DATA_LENGTHS[mid][ec_level as usize] > length { base } else { mid };
|
||
size -= half;
|
||
}
|
||
// base is always in [0, mid) because base <= mid.
|
||
base = if DATA_LENGTHS[base][ec_level as usize] >= length { base } else { base + 1 };
|
||
Version::Normal((base + 1).as_i16())
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod encode_auto_tests {
|
||
use crate::bits::{encode_auto, find_min_version};
|
||
use crate::types::{EcLevel, Version};
|
||
|
||
#[test]
|
||
fn test_find_min_version() {
|
||
assert_eq!(find_min_version(60, EcLevel::L), Version::Normal(1));
|
||
assert_eq!(find_min_version(200, EcLevel::L), Version::Normal(2));
|
||
assert_eq!(find_min_version(200, EcLevel::H), Version::Normal(3));
|
||
assert_eq!(find_min_version(20000, EcLevel::L), Version::Normal(37));
|
||
assert_eq!(find_min_version(640, EcLevel::L), Version::Normal(4));
|
||
assert_eq!(find_min_version(641, EcLevel::L), Version::Normal(5));
|
||
assert_eq!(find_min_version(999999, EcLevel::H), Version::Normal(40));
|
||
}
|
||
|
||
#[test]
|
||
fn test_alpha_q() {
|
||
let bits = encode_auto(b"HELLO WORLD", EcLevel::Q).unwrap();
|
||
assert_eq!(bits.version(), Version::Normal(1));
|
||
}
|
||
|
||
#[test]
|
||
fn test_alpha_h() {
|
||
let bits = encode_auto(b"HELLO WORLD", EcLevel::H).unwrap();
|
||
assert_eq!(bits.version(), Version::Normal(2));
|
||
}
|
||
|
||
#[test]
|
||
fn test_mixed() {
|
||
let bits = encode_auto(b"This is a mixed data test. 1234567890", EcLevel::H).unwrap();
|
||
assert_eq!(bits.version(), Version::Normal(4));
|
||
}
|
||
}
|
||
|
||
#[cfg(feature = "bench")]
|
||
#[bench]
|
||
fn bench_find_min_version(bencher: &mut test::Bencher) {
|
||
use test::black_box;
|
||
|
||
bencher.iter(|| {
|
||
black_box(find_min_version(60, EcLevel::L));
|
||
black_box(find_min_version(200, EcLevel::L));
|
||
black_box(find_min_version(200, EcLevel::H));
|
||
black_box(find_min_version(20000, EcLevel::L));
|
||
black_box(find_min_version(640, EcLevel::L));
|
||
black_box(find_min_version(641, EcLevel::L));
|
||
black_box(find_min_version(999999, EcLevel::H));
|
||
})
|
||
}
|
||
|
||
//}}}
|
||
//------------------------------------------------------------------------------
|