496 lines
15 KiB
JavaScript
496 lines
15 KiB
JavaScript
const Utils = require('./utils')
|
|
const ECLevel = require('./error-correction-level')
|
|
const BitBuffer = require('./bit-buffer')
|
|
const BitMatrix = require('./bit-matrix')
|
|
const AlignmentPattern = require('./alignment-pattern')
|
|
const FinderPattern = require('./finder-pattern')
|
|
const MaskPattern = require('./mask-pattern')
|
|
const ECCode = require('./error-correction-code')
|
|
const ReedSolomonEncoder = require('./reed-solomon-encoder')
|
|
const Version = require('./version')
|
|
const FormatInfo = require('./format-info')
|
|
const Mode = require('./mode')
|
|
const Segments = require('./segments')
|
|
|
|
/**
|
|
* QRCode for JavaScript
|
|
*
|
|
* modified by Ryan Day for nodejs support
|
|
* Copyright (c) 2011 Ryan Day
|
|
*
|
|
* Licensed under the MIT license:
|
|
* http://www.opensource.org/licenses/mit-license.php
|
|
*
|
|
//---------------------------------------------------------------------
|
|
// QRCode for JavaScript
|
|
//
|
|
// Copyright (c) 2009 Kazuhiko Arase
|
|
//
|
|
// URL: http://www.d-project.com/
|
|
//
|
|
// Licensed under the MIT license:
|
|
// http://www.opensource.org/licenses/mit-license.php
|
|
//
|
|
// The word "QR Code" is registered trademark of
|
|
// DENSO WAVE INCORPORATED
|
|
// http://www.denso-wave.com/qrcode/faqpatent-e.html
|
|
//
|
|
//---------------------------------------------------------------------
|
|
*/
|
|
|
|
/**
|
|
* Add finder patterns bits to matrix
|
|
*
|
|
* @param {BitMatrix} matrix Modules matrix
|
|
* @param {Number} version QR Code version
|
|
*/
|
|
function setupFinderPattern (matrix, version) {
|
|
const size = matrix.size
|
|
const pos = FinderPattern.getPositions(version)
|
|
|
|
for (let i = 0; i < pos.length; i++) {
|
|
const row = pos[i][0]
|
|
const col = pos[i][1]
|
|
|
|
for (let r = -1; r <= 7; r++) {
|
|
if (row + r <= -1 || size <= row + r) continue
|
|
|
|
for (let c = -1; c <= 7; c++) {
|
|
if (col + c <= -1 || size <= col + c) continue
|
|
|
|
if ((r >= 0 && r <= 6 && (c === 0 || c === 6)) ||
|
|
(c >= 0 && c <= 6 && (r === 0 || r === 6)) ||
|
|
(r >= 2 && r <= 4 && c >= 2 && c <= 4)) {
|
|
matrix.set(row + r, col + c, true, true)
|
|
} else {
|
|
matrix.set(row + r, col + c, false, true)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add timing pattern bits to matrix
|
|
*
|
|
* Note: this function must be called before {@link setupAlignmentPattern}
|
|
*
|
|
* @param {BitMatrix} matrix Modules matrix
|
|
*/
|
|
function setupTimingPattern (matrix) {
|
|
const size = matrix.size
|
|
|
|
for (let r = 8; r < size - 8; r++) {
|
|
const value = r % 2 === 0
|
|
matrix.set(r, 6, value, true)
|
|
matrix.set(6, r, value, true)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add alignment patterns bits to matrix
|
|
*
|
|
* Note: this function must be called after {@link setupTimingPattern}
|
|
*
|
|
* @param {BitMatrix} matrix Modules matrix
|
|
* @param {Number} version QR Code version
|
|
*/
|
|
function setupAlignmentPattern (matrix, version) {
|
|
const pos = AlignmentPattern.getPositions(version)
|
|
|
|
for (let i = 0; i < pos.length; i++) {
|
|
const row = pos[i][0]
|
|
const col = pos[i][1]
|
|
|
|
for (let r = -2; r <= 2; r++) {
|
|
for (let c = -2; c <= 2; c++) {
|
|
if (r === -2 || r === 2 || c === -2 || c === 2 ||
|
|
(r === 0 && c === 0)) {
|
|
matrix.set(row + r, col + c, true, true)
|
|
} else {
|
|
matrix.set(row + r, col + c, false, true)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add version info bits to matrix
|
|
*
|
|
* @param {BitMatrix} matrix Modules matrix
|
|
* @param {Number} version QR Code version
|
|
*/
|
|
function setupVersionInfo (matrix, version) {
|
|
const size = matrix.size
|
|
const bits = Version.getEncodedBits(version)
|
|
let row, col, mod
|
|
|
|
for (let i = 0; i < 18; i++) {
|
|
row = Math.floor(i / 3)
|
|
col = i % 3 + size - 8 - 3
|
|
mod = ((bits >> i) & 1) === 1
|
|
|
|
matrix.set(row, col, mod, true)
|
|
matrix.set(col, row, mod, true)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add format info bits to matrix
|
|
*
|
|
* @param {BitMatrix} matrix Modules matrix
|
|
* @param {ErrorCorrectionLevel} errorCorrectionLevel Error correction level
|
|
* @param {Number} maskPattern Mask pattern reference value
|
|
*/
|
|
function setupFormatInfo (matrix, errorCorrectionLevel, maskPattern) {
|
|
const size = matrix.size
|
|
const bits = FormatInfo.getEncodedBits(errorCorrectionLevel, maskPattern)
|
|
let i, mod
|
|
|
|
for (i = 0; i < 15; i++) {
|
|
mod = ((bits >> i) & 1) === 1
|
|
|
|
// vertical
|
|
if (i < 6) {
|
|
matrix.set(i, 8, mod, true)
|
|
} else if (i < 8) {
|
|
matrix.set(i + 1, 8, mod, true)
|
|
} else {
|
|
matrix.set(size - 15 + i, 8, mod, true)
|
|
}
|
|
|
|
// horizontal
|
|
if (i < 8) {
|
|
matrix.set(8, size - i - 1, mod, true)
|
|
} else if (i < 9) {
|
|
matrix.set(8, 15 - i - 1 + 1, mod, true)
|
|
} else {
|
|
matrix.set(8, 15 - i - 1, mod, true)
|
|
}
|
|
}
|
|
|
|
// fixed module
|
|
matrix.set(size - 8, 8, 1, true)
|
|
}
|
|
|
|
/**
|
|
* Add encoded data bits to matrix
|
|
*
|
|
* @param {BitMatrix} matrix Modules matrix
|
|
* @param {Uint8Array} data Data codewords
|
|
*/
|
|
function setupData (matrix, data) {
|
|
const size = matrix.size
|
|
let inc = -1
|
|
let row = size - 1
|
|
let bitIndex = 7
|
|
let byteIndex = 0
|
|
|
|
for (let col = size - 1; col > 0; col -= 2) {
|
|
if (col === 6) col--
|
|
|
|
while (true) {
|
|
for (let c = 0; c < 2; c++) {
|
|
if (!matrix.isReserved(row, col - c)) {
|
|
let dark = false
|
|
|
|
if (byteIndex < data.length) {
|
|
dark = (((data[byteIndex] >>> bitIndex) & 1) === 1)
|
|
}
|
|
|
|
matrix.set(row, col - c, dark)
|
|
bitIndex--
|
|
|
|
if (bitIndex === -1) {
|
|
byteIndex++
|
|
bitIndex = 7
|
|
}
|
|
}
|
|
}
|
|
|
|
row += inc
|
|
|
|
if (row < 0 || size <= row) {
|
|
row -= inc
|
|
inc = -inc
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create encoded codewords from data input
|
|
*
|
|
* @param {Number} version QR Code version
|
|
* @param {ErrorCorrectionLevel} errorCorrectionLevel Error correction level
|
|
* @param {ByteData} data Data input
|
|
* @return {Uint8Array} Buffer containing encoded codewords
|
|
*/
|
|
function createData (version, errorCorrectionLevel, segments) {
|
|
// Prepare data buffer
|
|
const buffer = new BitBuffer()
|
|
|
|
segments.forEach(function (data) {
|
|
// prefix data with mode indicator (4 bits)
|
|
buffer.put(data.mode.bit, 4)
|
|
|
|
// Prefix data with character count indicator.
|
|
// The character count indicator is a string of bits that represents the
|
|
// number of characters that are being encoded.
|
|
// The character count indicator must be placed after the mode indicator
|
|
// and must be a certain number of bits long, depending on the QR version
|
|
// and data mode
|
|
// @see {@link Mode.getCharCountIndicator}.
|
|
buffer.put(data.getLength(), Mode.getCharCountIndicator(data.mode, version))
|
|
|
|
// add binary data sequence to buffer
|
|
data.write(buffer)
|
|
})
|
|
|
|
// Calculate required number of bits
|
|
const totalCodewords = Utils.getSymbolTotalCodewords(version)
|
|
const ecTotalCodewords = ECCode.getTotalCodewordsCount(version, errorCorrectionLevel)
|
|
const dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8
|
|
|
|
// Add a terminator.
|
|
// If the bit string is shorter than the total number of required bits,
|
|
// a terminator of up to four 0s must be added to the right side of the string.
|
|
// If the bit string is more than four bits shorter than the required number of bits,
|
|
// add four 0s to the end.
|
|
if (buffer.getLengthInBits() + 4 <= dataTotalCodewordsBits) {
|
|
buffer.put(0, 4)
|
|
}
|
|
|
|
// If the bit string is fewer than four bits shorter, add only the number of 0s that
|
|
// are needed to reach the required number of bits.
|
|
|
|
// After adding the terminator, if the number of bits in the string is not a multiple of 8,
|
|
// pad the string on the right with 0s to make the string's length a multiple of 8.
|
|
while (buffer.getLengthInBits() % 8 !== 0) {
|
|
buffer.putBit(0)
|
|
}
|
|
|
|
// Add pad bytes if the string is still shorter than the total number of required bits.
|
|
// Extend the buffer to fill the data capacity of the symbol corresponding to
|
|
// the Version and Error Correction Level by adding the Pad Codewords 11101100 (0xEC)
|
|
// and 00010001 (0x11) alternately.
|
|
const remainingByte = (dataTotalCodewordsBits - buffer.getLengthInBits()) / 8
|
|
for (let i = 0; i < remainingByte; i++) {
|
|
buffer.put(i % 2 ? 0x11 : 0xEC, 8)
|
|
}
|
|
|
|
return createCodewords(buffer, version, errorCorrectionLevel)
|
|
}
|
|
|
|
/**
|
|
* Encode input data with Reed-Solomon and return codewords with
|
|
* relative error correction bits
|
|
*
|
|
* @param {BitBuffer} bitBuffer Data to encode
|
|
* @param {Number} version QR Code version
|
|
* @param {ErrorCorrectionLevel} errorCorrectionLevel Error correction level
|
|
* @return {Uint8Array} Buffer containing encoded codewords
|
|
*/
|
|
function createCodewords (bitBuffer, version, errorCorrectionLevel) {
|
|
// Total codewords for this QR code version (Data + Error correction)
|
|
const totalCodewords = Utils.getSymbolTotalCodewords(version)
|
|
|
|
// Total number of error correction codewords
|
|
const ecTotalCodewords = ECCode.getTotalCodewordsCount(version, errorCorrectionLevel)
|
|
|
|
// Total number of data codewords
|
|
const dataTotalCodewords = totalCodewords - ecTotalCodewords
|
|
|
|
// Total number of blocks
|
|
const ecTotalBlocks = ECCode.getBlocksCount(version, errorCorrectionLevel)
|
|
|
|
// Calculate how many blocks each group should contain
|
|
const blocksInGroup2 = totalCodewords % ecTotalBlocks
|
|
const blocksInGroup1 = ecTotalBlocks - blocksInGroup2
|
|
|
|
const totalCodewordsInGroup1 = Math.floor(totalCodewords / ecTotalBlocks)
|
|
|
|
const dataCodewordsInGroup1 = Math.floor(dataTotalCodewords / ecTotalBlocks)
|
|
const dataCodewordsInGroup2 = dataCodewordsInGroup1 + 1
|
|
|
|
// Number of EC codewords is the same for both groups
|
|
const ecCount = totalCodewordsInGroup1 - dataCodewordsInGroup1
|
|
|
|
// Initialize a Reed-Solomon encoder with a generator polynomial of degree ecCount
|
|
const rs = new ReedSolomonEncoder(ecCount)
|
|
|
|
let offset = 0
|
|
const dcData = new Array(ecTotalBlocks)
|
|
const ecData = new Array(ecTotalBlocks)
|
|
let maxDataSize = 0
|
|
const buffer = new Uint8Array(bitBuffer.buffer)
|
|
|
|
// Divide the buffer into the required number of blocks
|
|
for (let b = 0; b < ecTotalBlocks; b++) {
|
|
const dataSize = b < blocksInGroup1 ? dataCodewordsInGroup1 : dataCodewordsInGroup2
|
|
|
|
// extract a block of data from buffer
|
|
dcData[b] = buffer.slice(offset, offset + dataSize)
|
|
|
|
// Calculate EC codewords for this data block
|
|
ecData[b] = rs.encode(dcData[b])
|
|
|
|
offset += dataSize
|
|
maxDataSize = Math.max(maxDataSize, dataSize)
|
|
}
|
|
|
|
// Create final data
|
|
// Interleave the data and error correction codewords from each block
|
|
const data = new Uint8Array(totalCodewords)
|
|
let index = 0
|
|
let i, r
|
|
|
|
// Add data codewords
|
|
for (i = 0; i < maxDataSize; i++) {
|
|
for (r = 0; r < ecTotalBlocks; r++) {
|
|
if (i < dcData[r].length) {
|
|
data[index++] = dcData[r][i]
|
|
}
|
|
}
|
|
}
|
|
|
|
// Apped EC codewords
|
|
for (i = 0; i < ecCount; i++) {
|
|
for (r = 0; r < ecTotalBlocks; r++) {
|
|
data[index++] = ecData[r][i]
|
|
}
|
|
}
|
|
|
|
return data
|
|
}
|
|
|
|
/**
|
|
* Build QR Code symbol
|
|
*
|
|
* @param {String} data Input string
|
|
* @param {Number} version QR Code version
|
|
* @param {ErrorCorretionLevel} errorCorrectionLevel Error level
|
|
* @param {MaskPattern} maskPattern Mask pattern
|
|
* @return {Object} Object containing symbol data
|
|
*/
|
|
function createSymbol (data, version, errorCorrectionLevel, maskPattern) {
|
|
let segments
|
|
|
|
if (Array.isArray(data)) {
|
|
segments = Segments.fromArray(data)
|
|
} else if (typeof data === 'string') {
|
|
let estimatedVersion = version
|
|
|
|
if (!estimatedVersion) {
|
|
const rawSegments = Segments.rawSplit(data)
|
|
|
|
// Estimate best version that can contain raw splitted segments
|
|
estimatedVersion = Version.getBestVersionForData(rawSegments, errorCorrectionLevel)
|
|
}
|
|
|
|
// Build optimized segments
|
|
// If estimated version is undefined, try with the highest version
|
|
segments = Segments.fromString(data, estimatedVersion || 40)
|
|
} else {
|
|
throw new Error('Invalid data')
|
|
}
|
|
|
|
// Get the min version that can contain data
|
|
const bestVersion = Version.getBestVersionForData(segments, errorCorrectionLevel)
|
|
|
|
// If no version is found, data cannot be stored
|
|
if (!bestVersion) {
|
|
throw new Error('The amount of data is too big to be stored in a QR Code')
|
|
}
|
|
|
|
// If not specified, use min version as default
|
|
if (!version) {
|
|
version = bestVersion
|
|
|
|
// Check if the specified version can contain the data
|
|
} else if (version < bestVersion) {
|
|
throw new Error('\n' +
|
|
'The chosen QR Code version cannot contain this amount of data.\n' +
|
|
'Minimum version required to store current data is: ' + bestVersion + '.\n'
|
|
)
|
|
}
|
|
|
|
const dataBits = createData(version, errorCorrectionLevel, segments)
|
|
|
|
// Allocate matrix buffer
|
|
const moduleCount = Utils.getSymbolSize(version)
|
|
const modules = new BitMatrix(moduleCount)
|
|
|
|
// Add function modules
|
|
setupFinderPattern(modules, version)
|
|
setupTimingPattern(modules)
|
|
setupAlignmentPattern(modules, version)
|
|
|
|
// Add temporary dummy bits for format info just to set them as reserved.
|
|
// This is needed to prevent these bits from being masked by {@link MaskPattern.applyMask}
|
|
// since the masking operation must be performed only on the encoding region.
|
|
// These blocks will be replaced with correct values later in code.
|
|
setupFormatInfo(modules, errorCorrectionLevel, 0)
|
|
|
|
if (version >= 7) {
|
|
setupVersionInfo(modules, version)
|
|
}
|
|
|
|
// Add data codewords
|
|
setupData(modules, dataBits)
|
|
|
|
if (isNaN(maskPattern)) {
|
|
// Find best mask pattern
|
|
maskPattern = MaskPattern.getBestMask(modules,
|
|
setupFormatInfo.bind(null, modules, errorCorrectionLevel))
|
|
}
|
|
|
|
// Apply mask pattern
|
|
MaskPattern.applyMask(maskPattern, modules)
|
|
|
|
// Replace format info bits with correct values
|
|
setupFormatInfo(modules, errorCorrectionLevel, maskPattern)
|
|
|
|
return {
|
|
modules: modules,
|
|
version: version,
|
|
errorCorrectionLevel: errorCorrectionLevel,
|
|
maskPattern: maskPattern,
|
|
segments: segments
|
|
}
|
|
}
|
|
|
|
/**
|
|
* QR Code
|
|
*
|
|
* @param {String | Array} data Input data
|
|
* @param {Object} options Optional configurations
|
|
* @param {Number} options.version QR Code version
|
|
* @param {String} options.errorCorrectionLevel Error correction level
|
|
* @param {Function} options.toSJISFunc Helper func to convert utf8 to sjis
|
|
*/
|
|
exports.create = function create (data, options) {
|
|
if (typeof data === 'undefined' || data === '') {
|
|
throw new Error('No input text')
|
|
}
|
|
|
|
let errorCorrectionLevel = ECLevel.M
|
|
let version
|
|
let mask
|
|
|
|
if (typeof options !== 'undefined') {
|
|
// Use higher error correction level as default
|
|
errorCorrectionLevel = ECLevel.from(options.errorCorrectionLevel, ECLevel.M)
|
|
version = Version.from(options.version)
|
|
mask = MaskPattern.from(options.maskPattern)
|
|
|
|
if (options.toSJISFunc) {
|
|
Utils.setToSJISFunction(options.toSJISFunc)
|
|
}
|
|
}
|
|
|
|
return createSymbol(data, version, errorCorrectionLevel, mask)
|
|
}
|