@moralcode/qrcode-brightscript 0.1.0

package/src/components/qrCode/qrCode.mask.brs

@@ -0,0 +1,198 @@
+'-- Private helper methods for constructor: Codewords and masking --
+
+' Returns a new byte string representing the given data with the appropriate error correction
+' codewords appended to it, based on this object's version and error correction level.
+function _qrCode_mask_addEccAndInterleave(data as object) as object
+    ver = m.version
+    ecl = m.errorCorrectionLevel
+    if (data.count() <> m.getNumDataCodewords(ver, ecl)) then
+        throw("Invalid argument")
+    end if
+
+    ' Calculate parameter numbers
+    numBlocks = m.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver]
+    blockEccLen = m.ECC_CODEWORDS_PER_BLOCK [ecl.ordinal][ver]
+    rawCodewords = floor(m.getNumRawDataModules(ver) / 8)
+    numShortBlocks = numBlocks - rawCodewords MOD numBlocks
+    shortBlockLen = floor(rawCodewords / numBlocks)
+
+    ' Split data into blocks and append ECC to each block
+    blocks = []
+    rsDiv = m.reedSolomonComputeDivisor(blockEccLen)
+    k = 0
+    for i = 0 to numBlocks - 1
+        dat = slice(data, k, k + shortBlockLen - blockEccLen + iif(i < numShortBlocks, 0, 1))
+        k += dat.count()
+        ecc = m.reedSolomonComputeRemainder(dat, rsDiv)
+        if (i < numShortBlocks) then
+            dat.push(0)
+        end if
+        blocks.push(concat(dat, ecc))
+    next
+
+    ' Interleave (not concatenate) the bytes from every block into a single sequence
+    result = []
+    for i = 0 to blocks[0].count() - 1
+        j = 0
+        for each block in blocks
+            ' Skip the padding byte in short blocks
+            if ((i <> shortBlockLen - blockEccLen) or (j >= numShortBlocks)) then
+                result.push(block[i])
+            end if
+            j += 1
+        next
+    next
+    assert(result.count() = rawCodewords)
+    return result
+end function
+
+
+' Draws the given sequence of 8-bit codewords (data and error correction) onto the entire
+' data area of this QR Code. Function modules need to be marked off before this is called.
+function _qrCode_mask_drawCodewords(data as object)
+    if (data.count() <> floor(m.getNumRawDataModules(m.version) / 8)) then
+        throw("Invalid argument")
+    end if
+    i = 0 ' Bit index into the data
+    ' Do the funny zigzag scan
+    for right = m.size - 1 to 1 step -2' Index of right column in each column pair
+        if (right = 6) then
+            right = 5
+        end if
+        for vert = 0 to m.size - 1 ' Vertical counter
+            for j = 0 to 1
+                x = right - j ' Actual x coordinate
+                upward = ((right + 1) and 2) = 0
+                y = iif(upward, m.size - 1 - vert, vert) ' Actual y coordinate
+                if (not m.isFunction[y][x] and (i < data.count() * 8)) then
+                    m.modules[y][x] = iif(getBit(data[i >> 3], 7 - (i and 7)), 1, 0)
+                    i += 1
+                end if
+                ' If this QR Code has any remainder bits (0 to 7), they were assigned as
+                ' 0/false/light by the constructor and are left unchanged by this method
+            next
+        next
+    next
+    assert(i = data.count() * 8)
+end function
+
+
+' XORs the codeword modules in this QR Code with the given mask pattern.
+' The function modules must be marked and the codeword bits must be drawn
+' before masking. Due to the arithmetic of XOR, calling applyMask() with
+' the same mask value a second time will undo the mask. A final well-formed
+' QR Code needs exactly one (not zero, two, etc.) mask applied.
+function _qrCode_mask_applyMask(mask as integer)
+    if ((mask < 0) or (mask > 7)) then
+        throw("Mask value out of range")
+    end if
+    for y = 0 to m.size - 1
+        for x = 0 to m.size - 1
+            if (mask = 0) then
+                invert = (x + y) MOD 2 = 0
+            else if (mask = 1) then
+                invert = y MOD 2 = 0
+            else if (mask = 2) then
+                invert = x MOD 3 = 0
+            else if (mask = 3) then
+                invert = (x + y) MOD 3 = 0
+            else if (mask = 4) then
+                invert = (floor(x / 3) + floor(y / 2)) MOD 2 = 0
+            else if (mask = 5) then
+                invert = x * y MOD 2 + x * y MOD 3 = 0
+            else if (mask = 6) then
+                invert = (x * y MOD 2 + x * y MOD 3) MOD 2 = 0
+            else if (mask = 7) then
+                invert = ((x + y) MOD 2 + x * y MOD 3) MOD 2 = 0
+            else
+                throw("Unreachable")
+            end if
+            if (not m.isFunction[y][x] and invert)
+                m.modules[y][x] = abs(m.modules[y][x] - 1)
+            end if
+        next
+    next
+end function
+
+
+' Calculates and returns the penalty score based on state of this QR Code's current modules.
+' This is used by the automatic mask choice algorithm to find the mask pattern that yields the lowest score.
+function _qrCode_mask_getPenaltyScore() as integer
+    result = 0
+
+    ' Adjacent modules in row having same color, and finder-like patterns
+    for y = 0 to m.size - 1
+        runColor = 0
+        runX = 0
+        runHistory = [0, 0, 0, 0, 0, 0, 0]
+        for x = 0 to m.size - 1
+            if (m.modules[y][x] = runColor) then
+                runX += 1
+                if (runX = 5) then
+                    result += m.PENALTY_N1
+                else if (runX > 5) then
+                    result += 1
+                end if
+            else
+                m.finderPenaltyAddHistory(runX, runHistory)
+                if (runColor = 0) then
+                    result += m.finderPenaltyCountPatterns(runHistory) * m.PENALTY_N3
+                end if
+                runColor = m.modules[y][x]
+                runX = 1
+            end if
+        next
+        result += m.finderPenaltyTerminateAndCount(runColor, runX, runHistory) * m.PENALTY_N3
+    next
+    ' Adjacent modules in column having same color, and finder-like patterns
+    for x = 0 to m.size - 1
+        runColor = 0
+        runY = 0
+        runHistory = [0, 0, 0, 0, 0, 0, 0]
+        for y = 0 to m.size - 1
+            if (m.modules[y][x] = runColor) then
+                runY += 1
+                if (runY = 5) then
+                    result += m.PENALTY_N1
+                else if (runY > 5) then
+                    result += 1
+                end if
+            else
+                m.finderPenaltyAddHistory(runY, runHistory)
+                if (not runColor) then
+                    result += m.finderPenaltyCountPatterns(runHistory) * m.PENALTY_N3
+                end if
+                runColor = m.modules[y][x]
+                runY = 1
+            end if
+        next
+        result += m.finderPenaltyTerminateAndCount(runColor, runY, runHistory) * m.PENALTY_N3
+    next
+
+    ' 2*2 blocks of modules having same color
+    for y = 0 to m.size - 2
+        for x = 0 to m.size - 2
+            color = m.modules[y][x]
+            if ((color = m.modules[y][x + 1]) and (color = m.modules[y + 1][x]) and (color = m.modules[y + 1][x + 1]))
+                result += m.PENALTY_N2
+            end if
+        next
+    next
+
+    ' Balance of dark and light modules
+    dark = 0
+    for each row in m.modules
+        for each item in row
+            if item then
+                dark += 1
+            end if
+        next
+    next
+    total = m.size * m.size ' Note that size is odd, so dark/total != 1/2
+    ' Compute the smallest integer k >= 0 such that (45-5k)% <= dark/total <= (55+5k)%
+    k = ceil(abs(dark * 20 - total * 10) / total) - 1
+    assert((0 <= k) and (k <= 9))
+    result += k * m.PENALTY_N4
+    assert((0 <= result) and (result <= 2568888)) ' Non-tight upper bound based on default values of PENALTY_N1, ..., N4
+    return result
+end function

package/src/components/qrCode/qrCode.mid.brs

@@ -0,0 +1,76 @@
+'-- Static factory functions (mid level) --
+
+' Returns a QR Code representing the given segments with the given encoding parameters.
+' The smallest possible QR Code version within the given range is automatically
+' chosen for the output. Iff boostEcl is true, then the ECC level of the result
+' may be higher than the ecl argument if it can be done without increasing the
+' version. The mask number is either between 0 to 7 (inclusive) to force that
+' mask, or -1 to automatically choose an appropriate mask (which may be slow).
+' This function allows the user to create a custom sequence of segments that switches
+' between modes (such as alphanumeric and byte) to encode text in less space.
+' This is a mid-level API; the high-level API is encodeText() and encodeBinary().
+function _qrCode_mid_encodeSegments(segs as object, ecl as object, minVersion = 1 as integer, maxVersion = 40 as integer, mask = -1 as integer, boostEcl = true as boolean) as object
+    if (not ((m.MIN_VERSION <= minVersion) and (minVersion <= maxVersion) and (maxVersion <= m.MAX_VERSION)) or (mask < -1) or (mask > 7)) then
+        throw("Invalid value")
+    end if
+
+    ' Find the minimal version number to use
+    for version = minVersion to maxVersion
+        dataCapacityBits = m.getNumDataCodewords(version, ecl) * 8 ' Number of data bits available
+        usedBits = m.QrSegment.getTotalBits(segs, version)
+        if (usedBits <= dataCapacityBits) then
+            dataUsedBits = usedBits
+            exit for ' This version number is found to be suitable
+        end if
+        if (version = maxVersion) then ' All versions in the range could not fit the given data
+            throw("Data too long")
+        end if
+    next
+
+    ' Increase the error correction level while the data still fits in the current version number
+    for each newEcl in m.Ecc ' From low to high
+        if (boostEcl and (dataUsedBits <= m.getNumDataCodewords(version, newEcl) * 8)) then
+            ecl = newEcl
+        end if
+    next
+
+    ' Concatenate all segments to create the data bit string
+    bb = []
+    for each seg in segs
+        appendBits(seg.mode.modeBits, 4, bb)
+        appendBits(seg.numChars, seg.mode.callFunc("numCharCountBits", version), bb)
+        for each b in seg.getData()
+            bb.push(b)
+        next
+    next
+    assert(bb.count() = dataUsedBits)
+
+    ' Add terminator and pad up to a byte if applicable
+    dataCapacityBits = m.getNumDataCodewords(version, ecl) * 8
+    assert(bb.count() <= dataCapacityBits)
+    appendBits(0, min(4, dataCapacityBits - bb.count()), bb)
+    appendBits(0, (8 - bb.count() MOD 8) MOD 8, bb)
+    assert(bb.count() MOD 8 = 0)
+
+    ' Pad with alternating bytes until data capacity is reached
+    padByte = &hEC
+    while(bb.count() < dataCapacityBits)
+        appendBits(padByte, 8, bb)
+        padByte = xor(padByte, xor(&hEC, &h11))
+    end while
+
+    ' Pack bits into bytes in big endian
+    dataCodewords = []
+    while (dataCodewords.count() * 8 < bb.count())
+        dataCodewords.push(0)
+    end while
+
+    for x = 0 to bb.count() - 1
+        b = bb[x]
+        i = x
+        dataCodewords[i >> 3] = dataCodewords[i >> 3] or (b << (7 - (i and 7)))
+    next
+
+    ' Create the QR Code object
+    return m.constructor(version, ecl, dataCodewords, mask)
+end function

package/src/components/qrCode/qrCode.utils.brs

@@ -0,0 +1,110 @@
+' Appends the given number of low-order bits of the given value
+' to the given buffer. Requires 0 <= len <= 31 and 0 <= val < 2^len.
+function appendBits(value as integer, length as integer, bb as object)
+    if ((length < 0) or (length > 31) or (value >> length <> 0)) then
+        throw("Value out of range")
+    end if
+    for i = length - 1 to 0 step -1 ' Append bit by bit
+        bb.push((value >> i) and 1)
+    next
+end function
+
+
+' Returns true iff the i'th bit of x is set to 1.
+function getBit(x as integer, i as integer) as boolean
+    return ((x >> i) and 1) <> 0
+end function
+
+
+' Throws an exception if the given condition is false.
+function assert(condition as boolean)
+    if (not condition) then
+        throw("Assertion error")
+    end if
+end function
+
+
+'Since Brightscript doesn't have a XOR operator, we use this function to calculate it.
+function xor(x, y)
+    if type(x) = "roInvalid" then x = 0
+    if type(y) = "roInvalid" then y = 0
+    return (x or y) - (x and y)
+end function
+
+
+function iif(check as boolean, yes as dynamic, no as dynamic) as dynamic
+    if check then
+        return yes
+    end if
+    return no
+end function
+
+function floor(f as float) as integer
+    return int(f)
+end function
+
+function ceil(f as float) as integer
+    return int(f + 0.999)
+end function
+
+function min(a, b)
+    if a < b then return a
+    return b
+end function
+
+function max(a, b)
+    if a > b then return a
+    return b
+end function
+
+function slice(array as object, start = 0 as integer, finish = 0 as integer) as object
+    size = array.count() - 1
+    if (start < 0) then
+        start += size
+    end if
+    if (finish = 0 or finish >= size) then
+        finish = size + 1
+    else if (finish < 0) then
+        finish += size
+    end if
+    new = []
+    for x = start to finish - 1
+        new.push(array[x])
+    next
+    return new
+end function
+
+function concat(array1 as object, array2 as object) as object
+    new = []
+    new.append(array1)
+    new.append(array2)
+    return new
+end function
+
+function infinity()
+    return 999999
+end function
+
+function joinNums(array as object, sep = ", " as string) as string
+    ret = ""
+    for each item in array
+        if ret <> "" then
+            ret += sep
+        end if
+        if type(item) = "Invalid" then
+            ret += "invalid"
+        else
+            ret += item.toStr()
+        end if
+    next
+    return ret
+end function
+
+function isNullOrEmpty(obj as object) as boolean
+    if type(obj) = "Invalid" or type(obj) = "roInvalid" then
+        return true
+    else if obj = "" then
+        return true
+    end if
+    return false
+end function

package/src/components/qrCode/qrCode.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<component name="QRCode" extends="Poster">
+    <script type="text/brightscript" uri="./qrCode.brs" />
+    <script type="text/brightscript" uri="./qrCode.high.brs" />
+    <script type="text/brightscript" uri="./qrCode.mid.brs" />
+    <script type="text/brightscript" uri="./qrCode.low.brs" />
+    <script type="text/brightscript" uri="./qrCode.draw.brs" />
+    <script type="text/brightscript" uri="./qrCode.mask.brs" />
+    <script type="text/brightscript" uri="./qrCode.help.brs" />
+    <script type="text/brightscript" uri="./qrSegment.brs" />
+    <script type="text/brightscript" uri="./qrCode.utils.brs" />
+    <interface>
+        <field id="text" type="string" onChange="onTextChanged" />
+        <!-- <field id="binary" type="string" onChange="onBinaryChanged" /> -->
+        <field id="ecl" type="string" value="LOW" />
+        <field id="border" type="integer" value="4" />
+        <field id="pixel" type="integer" value="8" />
+        <field id="lightColor" type="color" value="0xFFFFFFFF" />
+        <field id="darkColor" type="color" value="0x000000FF" />
+        <field id="minVersion" type="integer" value="1" />
+        <field id="maxVersion" type="integer" value="40" />
+        <field id="mask" type="integer" value="-1" />
+        <field id="boost" type="boolean" value="true" />
+    </interface>
+</component>

package/src/components/qrCode/qrEcc.brs

@@ -0,0 +1,23 @@
+function onLevelChanged(nodeEvent)
+    level = nodeEvent.getData()
+
+    if level = "LOW" then
+        constructor(0, 1) ' The QR Code can tolerate about 7% erroneous codewords
+    else if level = "MEDIUM" then
+        constructor(1, 0) ' The QR Code can tolerate about 15% erroneous codewords
+    else if level = "QUARTILE" then
+        constructor(2, 3) ' The QR Code can tolerate about 25% erroneous codewords
+    else if level = "HIGH" then
+        constructor(3, 2) ' The QR Code can tolerate about 30% erroneous codewords
+    else
+        throw("Unknown Level")
+    end if
+end function
+
+'-- Constructor and fields --
+function constructor(ordinal as integer, formatBits as integer)
+    ' In the range 0 to 3 (unsigned 2-bit integer).
+    m.top.ordinal = ordinal
+    ' (Package-private) In the range 0 to 3 (unsigned 2-bit integer).
+    m.top.formatBits = formatBits
+end function

package/src/components/qrCode/qrEcc.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<component name="QREcc" extends="Node">
+    <script type="text/brightscript" uri="./qrEcc.brs" />
+    <script type="text/brightscript" uri="./qrCode.utils.brs" />
+    <interface>
+        <field id="level" type="string" onChange="onLevelChanged" />
+        <field id="ordinal" type="integer" />
+        <field id="formatBits" type="integer" />
+    </interface>
+</component>

package/src/components/qrCode/qrMode.brs

@@ -0,0 +1,37 @@
+function onModeChanged(nodeEvent)
+    mode = nodeEvent.getData()
+
+    if mode = "NUMERIC" then
+        constructor(&h1, [10, 12, 14])
+    else if mode = "ALPHANUMERIC" then
+        constructor(&h2, [9, 11, 13])
+    else if mode = "BYTE" then
+        constructor(&h4, [8, 16, 16])
+    else if mode = "KANJI" then
+        constructor(&h8, [8, 10, 12])
+    else if mode = "ECI" then
+        constructor(&h7, [0, 0, 0])
+    else
+        throw("Unknown Mode")
+    end if
+end function
+
+'-- Constructor and fields --
+function constructor(modeBits as integer, numBitsCharCount as object)
+    ' The mode indicator bits, which is a uint4 value (range 0 to 15).
+    m.top.modeBits = modeBits
+    ' Number of character count bits for three different version ranges.
+    m.top.numBitsCharCount = numBitsCharCount
+end function
+
+'-- Method --
+' (Package-private) Returns the bit width of the character count field for a segment in
+' this mode in a QR Code at the given version number. The result is in the range [0, 16].
+function numCharCountBits(version as integer) as integer
+    return m.top.numBitsCharCount[floor((version + 7) / 17)]
+end function
+
+function onVersionChanged(nodeEvent)
+    version = nodeEvent.getData()
+    m.top.numCharCountBits = m.top.numBitsCharCount[floor((version + 7) / 17)]
+end function

package/src/components/qrCode/qrMode.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<component name="QRMode" extends="Node">
+    <script type="text/brightscript" uri="./qrMode.brs" />
+    <script type="text/brightscript" uri="./qrCode.utils.brs" />
+    <interface>
+        <field id="mode" type="string" onChange="onModeChanged" />
+        <field id="modeBits" type="integer" />
+        <field id="numBitsCharCount" type="array" />
+        <function name="numCharCountBits" />
+    </interface>
+</component>