devbox
小桥流水78
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

微信小程序之生成条形码和二维码_小程序生成条形码

作者：小桥流水78 | 2024-07-30 21:06:02

赞

踩

小程序生成条形码

需求描述：商家用扫描枪扫用户条形码或二维码实现支付。

效果图：

说明：微信小程序、支付宝小程序的条形码和二维码都可以由一串数字通过 barcode.js 和 qrcode.js 插件绘制在页面的 Canvas 元素上。

两个插件的内容我贴在文章末尾

下面我总结一下基于微信小程序的整个实现流程：

（支付宝小程序类似，只要在微信小程序的基础上稍微改一下就行了）

1. 从后台获取要转换成条形码和二维码的一串数字 code

2. 分别用 barcode.js 和 qrcode.js 把数字绘制成页面canvas里的条形码和二维码

wxml: 

  1. <view>
  2.      <canvas canvas-id="barcode" />
  3.      <view>{{codeStr}}</view>
  4.      <canvas canvas-id="qrcode" />
  5. </view>

utils.js

  1. import qrcode from './qrcode';
  2. import barcode from './barcode';
  3.  
  4. // 插件内部是根据width, height参数的rpx值来进行绘画
  5. // 把数字转换成条形码
  6. function toBarcode (canvasId, code, width, height) {
  7.     barcode.code128(wx.createCanvasContext(canvasId), code, width, height);
  8. }
  9.  
  10. // 把数字转换成二维码
  11. function toQrcode (canvasId, code, width, height) {
  12.     qrcode.api.draw(code, {
  13.         ctx: wx.createCanvasContext(canvasId),
  14.         width,
  15.         height
  16.     })
  17. }
  18.  
  19. export {
  20.     toBarcode,
  21.     toQrcode
  22. }

// 使用 api

  1. const code = '1221334122546765342';
  2.  
  3. toBarcode('barcode', code, 680, 200);
  4. toQrcode('qrcode', code, 420, 420);
  5. const codeStr = `${code.slice(0, 4)}****${code.slice(20)}`;

3. 轮询请求后台，查看是否已被扫码（其实就是判断后台返回的 code 状态）

  1.         getStatus(code);
  2.  
  3.         function getStatus (code) {
  4.             wx.request({
  5.                 url: '/api/xxx',
  6.                 method: 'GET',
  7.                 data: {code},
  8.                 success: (res) => {
  9.                     if (res.isSuccess) {
  10.                         // 支付成功后的操作
  11.                     } else {
  12.                         // 还未支付并且允许轮训的话就继续轮训
  13.                         if (this.state.caninterval) {
  14.                             setTimeout(() => {
  15.                                 getStatus(code);
  16.                             }, 1500)
  17.                         }
  18.                     }
  19.                 }
  20.             })
  21.         }

完整代码：

  1. import { toBarcode, toQrcode } from '../utils';
  2.  
  3. Page({
  4.     data: {
  5.         canInterval: true, //判断能不能轮询，作用是控制小程序切换到后台时不进行轮训
  6.         code: '', // 转换成条形码、二维码的数字
  7.         codeStr: ''
  8.     },
  9.  
  10.     onLoad () {
  11.         wx.request({
  12.             url: '/api/xxx',
  13.             method: 'GET',
  14.             success: (res) => {
  15.                 const { code } = res.data;
  16.                 toBarcode('barcode', code , 680, 200);
  17.                 toQrcode('qrcode', code, 420, 420);
  18.                 const codeStr = `${code.slice(0, 4)}****${code.slice(20)}`;
  19.  
  20.                 this.setData({
  21.                     code,
  22.                     codeStr
  23.                 })
  24.  
  25.                 this.getStatus(code);
  26.             }
  27.         })
  28.     },
  29.  
  30.     onShow () {
  31.         const {code} = this.data;
  32.  
  33.         this.setData({
  34.             canInterval: true
  35.         });
  36.  
  37.         code && this.getStatus(code);
  38.     },
  39.  
  40.     getStatus (code) {
  41.         wx.request({
  42.             url: '',
  43.             method: 'GET',
  44.             data: {code},
  45.             success: (res) => {
  46.                 if (res.isSuccess) {
  47.                     // 支付成功后的操作
  48.                 } else {
  49.                     // 还未支付并且允许轮训的话就继续轮训
  50.                     if (this.state.canInterval) {
  51.                         setTimeout(() => {
  52.                             this.getStatus(code);
  53.                         }, 1000)
  54.                     }
  55.                 }
  56.             }
  57.         })
  58.     },
  59.  
  60.     onHide () {
  61.         this.setData({
  62.             canInterval: false
  63.         })
  64.     },
  65.  
  66.     onUnload () {
  67.         this.setData({
  68.             canInterval: false
  69.         })
  70.     }
  71. })

附赠两个插件

barcode.js

  1. /** 
  2. // https://github.com/alsey/wxbarcode
  3. // 最后一位显示 _ 问题
  4. // https://github.com/alsey/wxbarcode/issues/2
  5. // //ok some type of shift is nessecary if (shifter != -1) { result.push(shifter); result.push(codeValue(chr1));//把这里的chr2改成chr1即可。 }
  6. **/
  7.  
  8. !(function(){
  9. var CHAR_TILDE = 126;
  10. var CODE_FNC1 = 102;
  11.  
  12. var SET_STARTA = 103;
  13. var SET_STARTB = 104;
  14. var SET_STARTC = 105;
  15. var SET_SHIFT = 98;
  16. var SET_CODEA = 101;
  17. var SET_CODEB = 100;
  18. var SET_STOP = 106;
  19.  
  20.  
  21. var REPLACE_CODES = {
  22.     CHAR_TILDE: CODE_FNC1 //~ corresponds to FNC1 in GS1-128 standard
  23. }
  24.  
  25. var CODESET = {
  26.     ANY: 1,
  27.     AB: 2,
  28.     A: 3,
  29.     B: 4,
  30.     C: 5
  31. };
  32.  
  33. function getBytes(str) {
  34.     var bytes = [];
  35.     for (var i = 0; i < str.length; i++) {
  36.         bytes.push(str.charCodeAt(i));
  37.     }
  38.     return bytes;
  39. }
  40.  
  41. exports.code128 = function (ctx, text, width, height) {
  42.  
  43.     width = parseInt(width);
  44.  
  45.     height = parseInt(height);
  46.  
  47.     var codes = stringToCode128(text);
  48.  
  49.     var g = new Graphics(ctx, width, height);
  50.  
  51.     var barWeight = g.area.width / ((codes.length - 3) * 11 + 35);
  52.  
  53.     var x = g.area.left;
  54.     var y = g.area.top;
  55.     for (var i = 0; i < codes.length; i++) {
  56.         var c = codes[i];
  57.         //two bars at a time: 1 black and 1 white
  58.         for (var bar = 0; bar < 8; bar += 2) {
  59.             var barW = PATTERNS[c][bar] * barWeight;
  60.             // var barH = height - y - this.border;
  61.             var barH = height - y;
  62.             var spcW = PATTERNS[c][bar + 1] * barWeight;
  63.  
  64.             //no need to draw if 0 width
  65.             if (barW > 0) {
  66.                 g.fillFgRect(x, y, barW, barH);
  67.             }
  68.  
  69.             x += barW + spcW;
  70.         }
  71.     }
  72.  
  73.     ctx.draw();
  74. }
  75.  
  76.  
  77. function stringToCode128(text) {
  78.  
  79.     var barc = {
  80.         currcs: CODESET.C
  81.     };
  82.  
  83.     var bytes = getBytes(text);
  84.     //decide starting codeset
  85.     var index = bytes[0] == CHAR_TILDE ? 1 : 0;
  86.  
  87.     var csa1 = bytes.length > 0 ? codeSetAllowedFor(bytes[index++]) : CODESET.AB;
  88.     var csa2 = bytes.length > 0 ? codeSetAllowedFor(bytes[index++]) : CODESET.AB;
  89.     barc.currcs = getBestStartSet(csa1, csa2);
  90.     barc.currcs = perhapsCodeC(bytes, barc.currcs);
  91.  
  92.     //if no codeset changes this will end up with bytes.length+3
  93.     //start, checksum and stop
  94.     var codes = new Array();
  95.  
  96.     switch (barc.currcs) {
  97.         case CODESET.A:
  98.             codes.push(SET_STARTA);
  99.             break;
  100.         case CODESET.B:
  101.             codes.push(SET_STARTB);
  102.             break;
  103.         default:
  104.             codes.push(SET_STARTC);
  105.             break;
  106.     }
  107.  
  108.  
  109.     for (var i = 0; i < bytes.length; i++) {
  110.         var b1 = bytes[i]; //get the first of a pair
  111.         //should we translate/replace
  112.         if (b1 in REPLACE_CODES) {
  113.             codes.push(REPLACE_CODES[b1]);
  114.             i++ //jump to next
  115.             b1 = bytes[i];
  116.         }
  117.  
  118.         //get the next in the pair if possible
  119.         var b2 = bytes.length > (i + 1) ? bytes[i + 1] : -1;
  120.  
  121.         codes = codes.concat(codesForChar(b1, b2, barc.currcs));
  122.         //code C takes 2 chars each time
  123.         if (barc.currcs == CODESET.C) i++;
  124.     }
  125.  
  126.     //calculate checksum according to Code 128 standards
  127.     var checksum = codes[0];
  128.     for (var weight = 1; weight < codes.length; weight++) {
  129.         checksum += (weight * codes[weight]);
  130.     }
  131.     codes.push(checksum % 103);
  132.  
  133.     codes.push(SET_STOP);
  134.  
  135.     //encoding should now be complete
  136.     return codes;
  137.  
  138.     function getBestStartSet(csa1, csa2) {
  139.         //tries to figure out the best codeset
  140.         //to start with to get the most compact code
  141.         var vote = 0;
  142.         vote += csa1 == CODESET.A ? 1 : 0;
  143.         vote += csa1 == CODESET.B ? -1 : 0;
  144.         vote += csa2 == CODESET.A ? 1 : 0;
  145.         vote += csa2 == CODESET.B ? -1 : 0;
  146.         //tie goes to B due to my own predudices
  147.         return vote > 0 ? CODESET.A : CODESET.B;
  148.     }
  149.  
  150.     function perhapsCodeC(bytes, codeset) {
  151.         for (var i = 0; i < bytes.length; i++) {
  152.             var b = bytes[i]
  153.             if ((b < 48 || b > 57) && b != CHAR_TILDE)
  154.                 return codeset;
  155.         }
  156.         return CODESET.C;
  157.     }
  158.  
  159.     //chr1 is current byte
  160.     //chr2 is the next byte to process. looks ahead.
  161.     function codesForChar(chr1, chr2, currcs) {
  162.         var result = [];
  163.         var shifter = -1;
  164.  
  165.         if (charCompatible(chr1, currcs)) {
  166.             if (currcs == CODESET.C) {
  167.                 if (chr2 == -1) {
  168.                     shifter = SET_CODEB;
  169.                     currcs = CODESET.B;
  170.                 }
  171.                 else if ((chr2 != -1) && !charCompatible(chr2, currcs)) {
  172.                     //need to check ahead as well
  173.                     if (charCompatible(chr2, CODESET.A)) {
  174.                         shifter = SET_CODEA;
  175.                         currcs = CODESET.A;
  176.                     }
  177.                     else {
  178.                         shifter = SET_CODEB;
  179.                         currcs = CODESET.B;
  180.                     }
  181.                 }
  182.             }
  183.         }
  184.         else {
  185.             //if there is a next char AND that next char is also not compatible
  186.             if ((chr2 != -1) && !charCompatible(chr2, currcs)) {
  187.                 //need to switch code sets
  188.                 switch (currcs) {
  189.                     case CODESET.A:
  190.                         shifter = SET_CODEB;
  191.                         currcs = CODESET.B;
  192.                         break;
  193.                     case CODESET.B:
  194.                         shifter = SET_CODEA;
  195.                         currcs = CODESET.A;
  196.                         break;
  197.                 }
  198.             }
  199.             else {
  200.                 //no need to shift code sets, a temporary SHIFT will suffice
  201.                 shifter = SET_SHIFT;
  202.             }
  203.         }
  204.  
  205.         //ok some type of shift is nessecary
  206.         if (shifter != -1) {
  207.             result.push(shifter);
  208.             result.push(codeValue(chr1));
  209.         }
  210.         else {
  211.             if (currcs == CODESET.C) {
  212.                 //include next as well
  213.                 result.push(codeValue(chr1, chr2));
  214.             }
  215.             else {
  216.                 result.push(codeValue(chr1));
  217.             }
  218.         }
  219.         barc.currcs = currcs;
  220.  
  221.         return result;
  222.     }
  223. }
  224.  
  225. //reduce the ascii code to fit into the Code128 char table
  226. function codeValue(chr1, chr2) {
  227.     if (typeof chr2 == "undefined") {
  228.         return chr1 >= 32 ? chr1 - 32 : chr1 + 64;
  229.     }
  230.     else {
  231.         return parseInt(String.fromCharCode(chr1) + String.fromCharCode(chr2));
  232.     }
  233. }
  234.  
  235. function charCompatible(chr, codeset) {
  236.     var csa = codeSetAllowedFor(chr);
  237.     if (csa == CODESET.ANY) return true;
  238.     //if we need to change from current
  239.     if (csa == CODESET.AB) return true;
  240.     if (csa == CODESET.A && codeset == CODESET.A) return true;
  241.     if (csa == CODESET.B && codeset == CODESET.B) return true;
  242.     return false;
  243. }
  244.  
  245. function codeSetAllowedFor(chr) {
  246.     if (chr >= 48 && chr <= 57) {
  247.         //0-9
  248.         return CODESET.ANY;
  249.     }
  250.     else if (chr >= 32 && chr <= 95) {
  251.         //0-9 A-Z
  252.         return CODESET.AB;
  253.     }
  254.     else {
  255.         //if non printable
  256.         return chr < 32 ? CODESET.A : CODESET.B;
  257.     }
  258. }
  259.  
  260. var Graphics = function(ctx, width, height) {
  261.  
  262.     this.width = width;
  263.     this.height = height;
  264.     this.quiet = Math.round(this.width / 40);
  265.  
  266.     this.border_size   = 0;
  267.     this.padding_width = 0;
  268.  
  269.     this.area = {
  270.         width : width - this.padding_width * 2 - this.quiet * 2,
  271.         height: height - this.border_size * 2,
  272.         top   : this.border_size - 4,
  273.         left  : this.padding_width + this.quiet
  274.     };
  275.  
  276.     this.ctx = ctx;
  277.     this.fg = "#000000";
  278.     this.bg = "#ffffff";
  279.  
  280.     // fill background
  281.     this.fillBgRect(0,0, width, height);
  282.  
  283.     // fill center to create border
  284.     this.fillBgRect(0, this.border_size, width, height - this.border_size * 2);
  285. }
  286.  
  287. //use native color
  288. Graphics.prototype._fillRect = function(x, y, width, height, color) {
  289.     this.ctx.setFillStyle(color)
  290.     this.ctx.fillRect(x, y, width, height)
  291. }
  292.  
  293. Graphics.prototype.fillFgRect = function(x,y, width, height) {
  294.     this._fillRect(x, y, width, height, this.fg);
  295. }
  296.  
  297. Graphics.prototype.fillBgRect = function(x,y, width, height) {
  298.     this._fillRect(x, y, width, height, this.bg);
  299. }
  300.  
  301. var PATTERNS = [
  302.     [2, 1, 2, 2, 2, 2, 0, 0],  // 0
  303.     [2, 2, 2, 1, 2, 2, 0, 0],  // 1
  304.     [2, 2, 2, 2, 2, 1, 0, 0],  // 2
  305.     [1, 2, 1, 2, 2, 3, 0, 0],  // 3
  306.     [1, 2, 1, 3, 2, 2, 0, 0],  // 4
  307.     [1, 3, 1, 2, 2, 2, 0, 0],  // 5
  308.     [1, 2, 2, 2, 1, 3, 0, 0],  // 6
  309.     [1, 2, 2, 3, 1, 2, 0, 0],  // 7
  310.     [1, 3, 2, 2, 1, 2, 0, 0],  // 8
  311.     [2, 2, 1, 2, 1, 3, 0, 0],  // 9
  312.     [2, 2, 1, 3, 1, 2, 0, 0],  // 10
  313.     [2, 3, 1, 2, 1, 2, 0, 0],  // 11
  314.     [1, 1, 2, 2, 3, 2, 0, 0],  // 12
  315.     [1, 2, 2, 1, 3, 2, 0, 0],  // 13
  316.     [1, 2, 2, 2, 3, 1, 0, 0],  // 14
  317.     [1, 1, 3, 2, 2, 2, 0, 0],  // 15
  318.     [1, 2, 3, 1, 2, 2, 0, 0],  // 16
  319.     [1, 2, 3, 2, 2, 1, 0, 0],  // 17
  320.     [2, 2, 3, 2, 1, 1, 0, 0],  // 18
  321.     [2, 2, 1, 1, 3, 2, 0, 0],  // 19
  322.     [2, 2, 1, 2, 3, 1, 0, 0],  // 20
  323.     [2, 1, 3, 2, 1, 2, 0, 0],  // 21
  324.     [2, 2, 3, 1, 1, 2, 0, 0],  // 22
  325.     [3, 1, 2, 1, 3, 1, 0, 0],  // 23
  326.     [3, 1, 1, 2, 2, 2, 0, 0],  // 24
  327.     [3, 2, 1, 1, 2, 2, 0, 0],  // 25
  328.     [3, 2, 1, 2, 2, 1, 0, 0],  // 26
  329.     [3, 1, 2, 2, 1, 2, 0, 0],  // 27
  330.     [3, 2, 2, 1, 1, 2, 0, 0],  // 28
  331.     [3, 2, 2, 2, 1, 1, 0, 0],  // 29
  332.     [2, 1, 2, 1, 2, 3, 0, 0],  // 30
  333.     [2, 1, 2, 3, 2, 1, 0, 0],  // 31
  334.     [2, 3, 2, 1, 2, 1, 0, 0],  // 32
  335.     [1, 1, 1, 3, 2, 3, 0, 0],  // 33
  336.     [1, 3, 1, 1, 2, 3, 0, 0],  // 34
  337.     [1, 3, 1, 3, 2, 1, 0, 0],  // 35
  338.     [1, 1, 2, 3, 1, 3, 0, 0],  // 36
  339.     [1, 3, 2, 1, 1, 3, 0, 0],  // 37
  340.     [1, 3, 2, 3, 1, 1, 0, 0],  // 38
  341.     [2, 1, 1, 3, 1, 3, 0, 0],  // 39
  342.     [2, 3, 1, 1, 1, 3, 0, 0],  // 40
  343.     [2, 3, 1, 3, 1, 1, 0, 0],  // 41
  344.     [1, 1, 2, 1, 3, 3, 0, 0],  // 42
  345.     [1, 1, 2, 3, 3, 1, 0, 0],  // 43
  346.     [1, 3, 2, 1, 3, 1, 0, 0],  // 44
  347.     [1, 1, 3, 1, 2, 3, 0, 0],  // 45
  348.     [1, 1, 3, 3, 2, 1, 0, 0],  // 46
  349.     [1, 3, 3, 1, 2, 1, 0, 0],  // 47
  350.     [3, 1, 3, 1, 2, 1, 0, 0],  // 48
  351.     [2, 1, 1, 3, 3, 1, 0, 0],  // 49
  352.     [2, 3, 1, 1, 3, 1, 0, 0],  // 50
  353.     [2, 1, 3, 1, 1, 3, 0, 0],  // 51
  354.     [2, 1, 3, 3, 1, 1, 0, 0],  // 52
  355.     [2, 1, 3, 1, 3, 1, 0, 0],  // 53
  356.     [3, 1, 1, 1, 2, 3, 0, 0],  // 54
  357.     [3, 1, 1, 3, 2, 1, 0, 0],  // 55
  358.     [3, 3, 1, 1, 2, 1, 0, 0],  // 56
  359.     [3, 1, 2, 1, 1, 3, 0, 0],  // 57
  360.     [3, 1, 2, 3, 1, 1, 0, 0],  // 58
  361.     [3, 3, 2, 1, 1, 1, 0, 0],  // 59
  362.     [3, 1, 4, 1, 1, 1, 0, 0],  // 60
  363.     [2, 2, 1, 4, 1, 1, 0, 0],  // 61
  364.     [4, 3, 1, 1, 1, 1, 0, 0],  // 62
  365.     [1, 1, 1, 2, 2, 4, 0, 0],  // 63
  366.     [1, 1, 1, 4, 2, 2, 0, 0],  // 64
  367.     [1, 2, 1, 1, 2, 4, 0, 0],  // 65
  368.     [1, 2, 1, 4, 2, 1, 0, 0],  // 66
  369.     [1, 4, 1, 1, 2, 2, 0, 0],  // 67
  370.     [1, 4, 1, 2, 2, 1, 0, 0],  // 68
  371.     [1, 1, 2, 2, 1, 4, 0, 0],  // 69
  372.     [1, 1, 2, 4, 1, 2, 0, 0],  // 70
  373.     [1, 2, 2, 1, 1, 4, 0, 0],  // 71
  374.     [1, 2, 2, 4, 1, 1, 0, 0],  // 72
  375.     [1, 4, 2, 1, 1, 2, 0, 0],  // 73
  376.     [1, 4, 2, 2, 1, 1, 0, 0],  // 74
  377.     [2, 4, 1, 2, 1, 1, 0, 0],  // 75
  378.     [2, 2, 1, 1, 1, 4, 0, 0],  // 76
  379.     [4, 1, 3, 1, 1, 1, 0, 0],  // 77
  380.     [2, 4, 1, 1, 1, 2, 0, 0],  // 78
  381.     [1, 3, 4, 1, 1, 1, 0, 0],  // 79
  382.     [1, 1, 1, 2, 4, 2, 0, 0],  // 80
  383.     [1, 2, 1, 1, 4, 2, 0, 0],  // 81
  384.     [1, 2, 1, 2, 4, 1, 0, 0],  // 82
  385.     [1, 1, 4, 2, 1, 2, 0, 0],  // 83
  386.     [1, 2, 4, 1, 1, 2, 0, 0],  // 84
  387.     [1, 2, 4, 2, 1, 1, 0, 0],  // 85
  388.     [4, 1, 1, 2, 1, 2, 0, 0],  // 86
  389.     [4, 2, 1, 1, 1, 2, 0, 0],  // 87
  390.     [4, 2, 1, 2, 1, 1, 0, 0],  // 88
  391.     [2, 1, 2, 1, 4, 1, 0, 0],  // 89
  392.     [2, 1, 4, 1, 2, 1, 0, 0],  // 90
  393.     [4, 1, 2, 1, 2, 1, 0, 0],  // 91
  394.     [1, 1, 1, 1, 4, 3, 0, 0],  // 92
  395.     [1, 1, 1, 3, 4, 1, 0, 0],  // 93
  396.     [1, 3, 1, 1, 4, 1, 0, 0],  // 94
  397.     [1, 1, 4, 1, 1, 3, 0, 0],  // 95
  398.     [1, 1, 4, 3, 1, 1, 0, 0],  // 96
  399.     [4, 1, 1, 1, 1, 3, 0, 0],  // 97
  400.     [4, 1, 1, 3, 1, 1, 0, 0],  // 98
  401.     [1, 1, 3, 1, 4, 1, 0, 0],  // 99
  402.     [1, 1, 4, 1, 3, 1, 0, 0],  // 100
  403.     [3, 1, 1, 1, 4, 1, 0, 0],  // 101
  404.     [4, 1, 1, 1, 3, 1, 0, 0],  // 102
  405.     [2, 1, 1, 4, 1, 2, 0, 0],  // 103
  406.     [2, 1, 1, 2, 1, 4, 0, 0],  // 104
  407.     [2, 1, 1, 2, 3, 2, 0, 0],  // 105
  408.     [2, 3, 3, 1, 1, 1, 2, 0]   // 106
  409. ]
  410. })();

qrcode.js

  1. var QR = (function () {
  2.  
  3.     // alignment pattern
  4.     var adelta = [
  5.       0, 11, 15, 19, 23, 27, 31, // force 1 pat
  6.       16, 18, 20, 22, 24, 26, 28, 20, 22, 24, 24, 26, 28, 28, 22, 24, 24,
  7.       26, 26, 28, 28, 24, 24, 26, 26, 26, 28, 28, 24, 26, 26, 26, 28, 28
  8.       ];
  9.  
  10.     // version block
  11.     var vpat = [
  12.         0xc94, 0x5bc, 0xa99, 0x4d3, 0xbf6, 0x762, 0x847, 0x60d,
  13.         0x928, 0xb78, 0x45d, 0xa17, 0x532, 0x9a6, 0x683, 0x8c9,
  14.         0x7ec, 0xec4, 0x1e1, 0xfab, 0x08e, 0xc1a, 0x33f, 0xd75,
  15.         0x250, 0x9d5, 0x6f0, 0x8ba, 0x79f, 0xb0b, 0x42e, 0xa64,
  16.         0x541, 0xc69
  17.     ];
  18.  
  19.     // final format bits with mask: level << 3 | mask
  20.     var fmtword = [
  21.         0x77c4, 0x72f3, 0x7daa, 0x789d, 0x662f, 0x6318, 0x6c41, 0x6976,    //L
  22.         0x5412, 0x5125, 0x5e7c, 0x5b4b, 0x45f9, 0x40ce, 0x4f97, 0x4aa0,    //M
  23.         0x355f, 0x3068, 0x3f31, 0x3a06, 0x24b4, 0x2183, 0x2eda, 0x2bed,    //Q
  24.         0x1689, 0x13be, 0x1ce7, 0x19d0, 0x0762, 0x0255, 0x0d0c, 0x083b    //H
  25.     ];
  26.  
  27.     // 4 per version: number of blocks 1,2; data width; ecc width
  28.     var eccblocks = [
  29.         1, 0, 19, 7, 1, 0, 16, 10, 1, 0, 13, 13, 1, 0, 9, 17,
  30.         1, 0, 34, 10, 1, 0, 28, 16, 1, 0, 22, 22, 1, 0, 16, 28,
  31.         1, 0, 55, 15, 1, 0, 44, 26, 2, 0, 17, 18, 2, 0, 13, 22,
  32.         1, 0, 80, 20, 2, 0, 32, 18, 2, 0, 24, 26, 4, 0, 9, 16,
  33.         1, 0, 108, 26, 2, 0, 43, 24, 2, 2, 15, 18, 2, 2, 11, 22,
  34.         2, 0, 68, 18, 4, 0, 27, 16, 4, 0, 19, 24, 4, 0, 15, 28,
  35.         2, 0, 78, 20, 4, 0, 31, 18, 2, 4, 14, 18, 4, 1, 13, 26,
  36.         2, 0, 97, 24, 2, 2, 38, 22, 4, 2, 18, 22, 4, 2, 14, 26,
  37.         2, 0, 116, 30, 3, 2, 36, 22, 4, 4, 16, 20, 4, 4, 12, 24,
  38.         2, 2, 68, 18, 4, 1, 43, 26, 6, 2, 19, 24, 6, 2, 15, 28,
  39.         4, 0, 81, 20, 1, 4, 50, 30, 4, 4, 22, 28, 3, 8, 12, 24,
  40.         2, 2, 92, 24, 6, 2, 36, 22, 4, 6, 20, 26, 7, 4, 14, 28,
  41.         4, 0, 107, 26, 8, 1, 37, 22, 8, 4, 20, 24, 12, 4, 11, 22,
  42.         3, 1, 115, 30, 4, 5, 40, 24, 11, 5, 16, 20, 11, 5, 12, 24,
  43.         5, 1, 87, 22, 5, 5, 41, 24, 5, 7, 24, 30, 11, 7, 12, 24,
  44.         5, 1, 98, 24, 7, 3, 45, 28, 15, 2, 19, 24, 3, 13, 15, 30,
  45.         1, 5, 107, 28, 10, 1, 46, 28, 1, 15, 22, 28, 2, 17, 14, 28,
  46.         5, 1, 120, 30, 9, 4, 43, 26, 17, 1, 22, 28, 2, 19, 14, 28,
  47.         3, 4, 113, 28, 3, 11, 44, 26, 17, 4, 21, 26, 9, 16, 13, 26,
  48.         3, 5, 107, 28, 3, 13, 41, 26, 15, 5, 24, 30, 15, 10, 15, 28,
  49.         4, 4, 116, 28, 17, 0, 42, 26, 17, 6, 22, 28, 19, 6, 16, 30,
  50.         2, 7, 111, 28, 17, 0, 46, 28, 7, 16, 24, 30, 34, 0, 13, 24,
  51.         4, 5, 121, 30, 4, 14, 47, 28, 11, 14, 24, 30, 16, 14, 15, 30,
  52.         6, 4, 117, 30, 6, 14, 45, 28, 11, 16, 24, 30, 30, 2, 16, 30,
  53.         8, 4, 106, 26, 8, 13, 47, 28, 7, 22, 24, 30, 22, 13, 15, 30,
  54.         10, 2, 114, 28, 19, 4, 46, 28, 28, 6, 22, 28, 33, 4, 16, 30,
  55.         8, 4, 122, 30, 22, 3, 45, 28, 8, 26, 23, 30, 12, 28, 15, 30,
  56.         3, 10, 117, 30, 3, 23, 45, 28, 4, 31, 24, 30, 11, 31, 15, 30,
  57.         7, 7, 116, 30, 21, 7, 45, 28, 1, 37, 23, 30, 19, 26, 15, 30,
  58.         5, 10, 115, 30, 19, 10, 47, 28, 15, 25, 24, 30, 23, 25, 15, 30,
  59.         13, 3, 115, 30, 2, 29, 46, 28, 42, 1, 24, 30, 23, 28, 15, 30,
  60.         17, 0, 115, 30, 10, 23, 46, 28, 10, 35, 24, 30, 19, 35, 15, 30,
  61.         17, 1, 115, 30, 14, 21, 46, 28, 29, 19, 24, 30, 11, 46, 15, 30,
  62.         13, 6, 115, 30, 14, 23, 46, 28, 44, 7, 24, 30, 59, 1, 16, 30,
  63.         12, 7, 121, 30, 12, 26, 47, 28, 39, 14, 24, 30, 22, 41, 15, 30,
  64.         6, 14, 121, 30, 6, 34, 47, 28, 46, 10, 24, 30, 2, 64, 15, 30,
  65.         17, 4, 122, 30, 29, 14, 46, 28, 49, 10, 24, 30, 24, 46, 15, 30,
  66.         4, 18, 122, 30, 13, 32, 46, 28, 48, 14, 24, 30, 42, 32, 15, 30,
  67.         20, 4, 117, 30, 40, 7, 47, 28, 43, 22, 24, 30, 10, 67, 15, 30,
  68.         19, 6, 118, 30, 18, 31, 47, 28, 34, 34, 24, 30, 20, 61, 15, 30
  69.     ];
  70.  
  71.     // Galois field log table
  72.     var glog = [
  73.         0xff, 0x00, 0x01, 0x19, 0x02, 0x32, 0x1a, 0xc6, 0x03, 0xdf, 0x33, 0xee, 0x1b, 0x68, 0xc7, 0x4b,
  74.         0x04, 0x64, 0xe0, 0x0e, 0x34, 0x8d, 0xef, 0x81, 0x1c, 0xc1, 0x69, 0xf8, 0xc8, 0x08, 0x4c, 0x71,
  75.         0x05, 0x8a, 0x65, 0x2f, 0xe1, 0x24, 0x0f, 0x21, 0x35, 0x93, 0x8e, 0xda, 0xf0, 0x12, 0x82, 0x45,
  76.         0x1d, 0xb5, 0xc2, 0x7d, 0x6a, 0x27, 0xf9, 0xb9, 0xc9, 0x9a, 0x09, 0x78, 0x4d, 0xe4, 0x72, 0xa6,
  77.         0x06, 0xbf, 0x8b, 0x62, 0x66, 0xdd, 0x30, 0xfd, 0xe2, 0x98, 0x25, 0xb3, 0x10, 0x91, 0x22, 0x88,
  78.         0x36, 0xd0, 0x94, 0xce, 0x8f, 0x96, 0xdb, 0xbd, 0xf1, 0xd2, 0x13, 0x5c, 0x83, 0x38, 0x46, 0x40,
  79.         0x1e, 0x42, 0xb6, 0xa3, 0xc3, 0x48, 0x7e, 0x6e, 0x6b, 0x3a, 0x28, 0x54, 0xfa, 0x85, 0xba, 0x3d,
  80.         0xca, 0x5e, 0x9b, 0x9f, 0x0a, 0x15, 0x79, 0x2b, 0x4e, 0xd4, 0xe5, 0xac, 0x73, 0xf3, 0xa7, 0x57,
  81.         0x07, 0x70, 0xc0, 0xf7, 0x8c, 0x80, 0x63, 0x0d, 0x67, 0x4a, 0xde, 0xed, 0x31, 0xc5, 0xfe, 0x18,
  82.         0xe3, 0xa5, 0x99, 0x77, 0x26, 0xb8, 0xb4, 0x7c, 0x11, 0x44, 0x92, 0xd9, 0x23, 0x20, 0x89, 0x2e,
  83.         0x37, 0x3f, 0xd1, 0x5b, 0x95, 0xbc, 0xcf, 0xcd, 0x90, 0x87, 0x97, 0xb2, 0xdc, 0xfc, 0xbe, 0x61,
  84.         0xf2, 0x56, 0xd3, 0xab, 0x14, 0x2a, 0x5d, 0x9e, 0x84, 0x3c, 0x39, 0x53, 0x47, 0x6d, 0x41, 0xa2,
  85.         0x1f, 0x2d, 0x43, 0xd8, 0xb7, 0x7b, 0xa4, 0x76, 0xc4, 0x17, 0x49, 0xec, 0x7f, 0x0c, 0x6f, 0xf6,
  86.         0x6c, 0xa1, 0x3b, 0x52, 0x29, 0x9d, 0x55, 0xaa, 0xfb, 0x60, 0x86, 0xb1, 0xbb, 0xcc, 0x3e, 0x5a,
  87.         0xcb, 0x59, 0x5f, 0xb0, 0x9c, 0xa9, 0xa0, 0x51, 0x0b, 0xf5, 0x16, 0xeb, 0x7a, 0x75, 0x2c, 0xd7,
  88.         0x4f, 0xae, 0xd5, 0xe9, 0xe6, 0xe7, 0xad, 0xe8, 0x74, 0xd6, 0xf4, 0xea, 0xa8, 0x50, 0x58, 0xaf
  89.     ];
  90.  
  91.     // Galios field exponent table
  92.     var gexp = [
  93.         0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1d, 0x3a, 0x74, 0xe8, 0xcd, 0x87, 0x13, 0x26,
  94.         0x4c, 0x98, 0x2d, 0x5a, 0xb4, 0x75, 0xea, 0xc9, 0x8f, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0,
  95.         0x9d, 0x27, 0x4e, 0x9c, 0x25, 0x4a, 0x94, 0x35, 0x6a, 0xd4, 0xb5, 0x77, 0xee, 0xc1, 0x9f, 0x23,
  96.         0x46, 0x8c, 0x05, 0x0a, 0x14, 0x28, 0x50, 0xa0, 0x5d, 0xba, 0x69, 0xd2, 0xb9, 0x6f, 0xde, 0xa1,
  97.         0x5f, 0xbe, 0x61, 0xc2, 0x99, 0x2f, 0x5e, 0xbc, 0x65, 0xca, 0x89, 0x0f, 0x1e, 0x3c, 0x78, 0xf0,
  98.         0xfd, 0xe7, 0xd3, 0xbb, 0x6b, 0xd6, 0xb1, 0x7f, 0xfe, 0xe1, 0xdf, 0xa3, 0x5b, 0xb6, 0x71, 0xe2,
  99.         0xd9, 0xaf, 0x43, 0x86, 0x11, 0x22, 0x44, 0x88, 0x0d, 0x1a, 0x34, 0x68, 0xd0, 0xbd, 0x67, 0xce,
  100.         0x81, 0x1f, 0x3e, 0x7c, 0xf8, 0xed, 0xc7, 0x93, 0x3b, 0x76, 0xec, 0xc5, 0x97, 0x33, 0x66, 0xcc,
  101.         0x85, 0x17, 0x2e, 0x5c, 0xb8, 0x6d, 0xda, 0xa9, 0x4f, 0x9e, 0x21, 0x42, 0x84, 0x15, 0x2a, 0x54,
  102.         0xa8, 0x4d, 0x9a, 0x29, 0x52, 0xa4, 0x55, 0xaa, 0x49, 0x92, 0x39, 0x72, 0xe4, 0xd5, 0xb7, 0x73,
  103.         0xe6, 0xd1, 0xbf, 0x63, 0xc6, 0x91, 0x3f, 0x7e, 0xfc, 0xe5, 0xd7, 0xb3, 0x7b, 0xf6, 0xf1, 0xff,
  104.         0xe3, 0xdb, 0xab, 0x4b, 0x96, 0x31, 0x62, 0xc4, 0x95, 0x37, 0x6e, 0xdc, 0xa5, 0x57, 0xae, 0x41,
  105.         0x82, 0x19, 0x32, 0x64, 0xc8, 0x8d, 0x07, 0x0e, 0x1c, 0x38, 0x70, 0xe0, 0xdd, 0xa7, 0x53, 0xa6,
  106.         0x51, 0xa2, 0x59, 0xb2, 0x79, 0xf2, 0xf9, 0xef, 0xc3, 0x9b, 0x2b, 0x56, 0xac, 0x45, 0x8a, 0x09,
  107.         0x12, 0x24, 0x48, 0x90, 0x3d, 0x7a, 0xf4, 0xf5, 0xf7, 0xf3, 0xfb, 0xeb, 0xcb, 0x8b, 0x0b, 0x16,
  108.         0x2c, 0x58, 0xb0, 0x7d, 0xfa, 0xe9, 0xcf, 0x83, 0x1b, 0x36, 0x6c, 0xd8, 0xad, 0x47, 0x8e, 0x00
  109.     ];
  110.  
  111.     // Working buffers:
  112.     // data input and ecc append, image working buffer, fixed part of image, run lengths for badness
  113.     var strinbuf=[], eccbuf=[], qrframe=[], framask=[], rlens=[]; 
  114.     // Control values - width is based on version, last 4 are from table.
  115.     var version, width, neccblk1, neccblk2, datablkw, eccblkwid;
  116.     var ecclevel = 2;
  117.     // set bit to indicate cell in qrframe is immutable.  symmetric around diagonal
  118.     function setmask(x, y)
  119.     {
  120.         var bt;
  121.         if (x > y) {
  122.             bt = x;
  123.             x = y;
  124.             y = bt;
  125.         }
  126.         // y*y = 1+3+5...
  127.         bt = y;
  128.         bt *= y;
  129.         bt += y;
  130.         bt >>= 1;
  131.         bt += x;
  132.         framask[bt] = 1;
  133.     }
  134.  
  135.     // enter alignment pattern - black to qrframe, white to mask (later black frame merged to mask)
  136.     function putalign(x, y)
  137.     {
  138.         var j;
  139.  
  140.         qrframe[x + width * y] = 1;
  141.         for (j = -2; j < 2; j++) {
  142.             qrframe[(x + j) + width * (y - 2)] = 1;
  143.             qrframe[(x - 2) + width * (y + j + 1)] = 1;
  144.             qrframe[(x + 2) + width * (y + j)] = 1;
  145.             qrframe[(x + j + 1) + width * (y + 2)] = 1;
  146.         }
  147.         for (j = 0; j < 2; j++) {
  148.             setmask(x - 1, y + j);
  149.             setmask(x + 1, y - j);
  150.             setmask(x - j, y - 1);
  151.             setmask(x + j, y + 1);
  152.         }
  153.     }
  154.  
  155.     //========================================================================
  156.     // Reed Solomon error correction
  157.     // exponentiation mod N
  158.     function modnn(x)
  159.     {
  160.         while (x >= 255) {
  161.             x -= 255;
  162.             x = (x >> 8) + (x & 255);
  163.         }
  164.         return x;
  165.     }
  166.  
  167.     var genpoly = [];
  168.  
  169.     // Calculate and append ECC data to data block.  Block is in strinbuf, indexes to buffers given.
  170.     function appendrs(data, dlen, ecbuf, eclen)
  171.     {
  172.         var i, j, fb;
  173.  
  174.         for (i = 0; i < eclen; i++)
  175.             strinbuf[ecbuf + i] = 0;
  176.         for (i = 0; i < dlen; i++) {
  177.             fb = glog[strinbuf[data + i] ^ strinbuf[ecbuf]];
  178.             if (fb != 255)     /* fb term is non-zero */
  179.                 for (j = 1; j < eclen; j++)
  180.                     strinbuf[ecbuf + j - 1] = strinbuf[ecbuf + j] ^ gexp[modnn(fb + genpoly[eclen - j])];
  181.             else
  182.                 for( j = ecbuf ; j < ecbuf + eclen; j++ )
  183.                     strinbuf[j] = strinbuf[j + 1];
  184.             strinbuf[ ecbuf + eclen - 1] = fb == 255 ? 0 : gexp[modnn(fb + genpoly[0])];
  185.         }
  186.     }
  187.  
  188.     //========================================================================
  189.     // Frame data insert following the path rules
  190.  
  191.     // check mask - since symmetrical use half.
  192.     function ismasked(x, y)
  193.     {
  194.         var bt;
  195.         if (x > y) {
  196.             bt = x;
  197.             x = y;
  198.             y = bt;
  199.         }
  200.         bt = y;
  201.         bt += y * y;
  202.         bt >>= 1;
  203.         bt += x;
  204.         return framask[bt];
  205.     }
  206.  
  207.     //========================================================================
  208.     //  Apply the selected mask out of the 8.
  209.     function  applymask(m)
  210.     {
  211.         var x, y, r3x, r3y;
  212.  
  213.         switch (m) {
  214.         case 0:
  215.             for (y = 0; y < width; y++)
  216.                 for (x = 0; x < width; x++)
  217.                     if (!((x + y) & 1) && !ismasked(x, y))
  218.                         qrframe[x + y * width] ^= 1;
  219.             break;
  220.         case 1:
  221.             for (y = 0; y < width; y++)
  222.                 for (x = 0; x < width; x++)
  223.                     if (!(y & 1) && !ismasked(x, y))
  224.                         qrframe[x + y * width] ^= 1;
  225.             break;
  226.         case 2:
  227.             for (y = 0; y < width; y++)
  228.                 for (r3x = 0, x = 0; x < width; x++, r3x++) {
  229.                     if (r3x == 3)
  230.                         r3x = 0;
  231.                     if (!r3x && !ismasked(x, y))
  232.                         qrframe[x + y * width] ^= 1;
  233.                 }
  234.             break;
  235.         case 3:
  236.             for (r3y = 0, y = 0; y < width; y++, r3y++) {
  237.                 if (r3y == 3)
  238.                     r3y = 0;
  239.                 for (r3x = r3y, x = 0; x < width; x++, r3x++) {
  240.                     if (r3x == 3)
  241.                         r3x = 0;
  242.                     if (!r3x && !ismasked(x, y))
  243.                         qrframe[x + y * width] ^= 1;
  244.                 }
  245.             }
  246.             break;
  247.         case 4:
  248.             for (y = 0; y < width; y++)
  249.                 for (r3x = 0, r3y = ((y >> 1) & 1), x = 0; x < width; x++, r3x++) {
  250.                     if (r3x == 3) {
  251.                         r3x = 0;
  252.                         r3y = !r3y;
  253.                     }
  254.                     if (!r3y && !ismasked(x, y))
  255.                         qrframe[x + y * width] ^= 1;
  256.                 }
  257.             break;
  258.         case 5:
  259.             for (r3y = 0, y = 0; y < width; y++, r3y++) {
  260.                 if (r3y == 3)
  261.                     r3y = 0;
  262.                 for (r3x = 0, x = 0; x < width; x++, r3x++) {
  263.                     if (r3x == 3)
  264.                         r3x = 0;
  265.                     if (!((x & y & 1) + !(!r3x | !r3y)) && !ismasked(x, y))
  266.                         qrframe[x + y * width] ^= 1;
  267.                 }
  268.             }
  269.             break;
  270.         case 6:
  271.             for (r3y = 0, y = 0; y < width; y++, r3y++) {
  272.                 if (r3y == 3)
  273.                     r3y = 0;
  274.                 for (r3x = 0, x = 0; x < width; x++, r3x++) {
  275.                     if (r3x == 3)
  276.                         r3x = 0;
  277.                     if (!(((x & y & 1) + (r3x && (r3x == r3y))) & 1) && !ismasked(x, y))
  278.                         qrframe[x + y * width] ^= 1;
  279.                 }
  280.             }
  281.             break;
  282.         case 7:
  283.             for (r3y = 0, y = 0; y < width; y++, r3y++) {
  284.                 if (r3y == 3)
  285.                     r3y = 0;
  286.                 for (r3x = 0, x = 0; x < width; x++, r3x++) {
  287.                     if (r3x == 3)
  288.                         r3x = 0;
  289.                     if (!(((r3x && (r3x == r3y)) + ((x + y) & 1)) & 1) && !ismasked(x, y))
  290.                         qrframe[x + y * width] ^= 1;
  291.                 }
  292.             }
  293.             break;
  294.         }
  295.         return;
  296.     }
  297.  
  298.     // Badness coefficients.
  299.     var N1 = 3, N2 = 3, N3 = 40, N4 = 10;
  300.  
  301.     // Using the table of the length of each run, calculate the amount of bad image 
  302.     // - long runs or those that look like finders; called twice, once each for X and Y
  303.     function badruns(length)
  304.     {
  305.         var i;
  306.         var runsbad = 0;
  307.         for (i = 0; i <= length; i++)
  308.             if (rlens[i] >= 5)
  309.                 runsbad += N1 + rlens[i] - 5;
  310.         // BwBBBwB as in finder
  311.         for (i = 3; i < length - 1; i += 2)
  312.             if (rlens[i - 2] == rlens[i + 2]
  313.                 && rlens[i + 2] == rlens[i - 1]
  314.                 && rlens[i - 1] == rlens[i + 1]
  315.                 && rlens[i - 1] * 3 == rlens[i]
  316.                 // white around the black pattern? Not part of spec
  317.                 && (rlens[i - 3] == 0 // beginning
  318.                     || i + 3 > length  // end
  319.                     || rlens[i - 3] * 3 >= rlens[i] * 4 || rlens[i + 3] * 3 >= rlens[i] * 4)
  320.                )
  321.                 runsbad += N3;
  322.         return runsbad;
  323.     }
  324.  
  325.     // Calculate how bad the masked image is - blocks, imbalance, runs, or finders.
  326.     function badcheck()
  327.     {
  328.         var x, y, h, b, b1;
  329.         var thisbad = 0;
  330.         var bw = 0;
  331.  
  332.         // blocks of same color.
  333.         for (y = 0; y < width - 1; y++)
  334.             for (x = 0; x < width - 1; x++)
  335.                 if ((qrframe[x + width * y] && qrframe[(x + 1) + width * y]
  336.                      && qrframe[x + width * (y + 1)] && qrframe[(x + 1) + width * (y + 1)]) // all black
  337.                     || !(qrframe[x + width * y] || qrframe[(x + 1) + width * y]
  338.                          || qrframe[x + width * (y + 1)] || qrframe[(x + 1) + width * (y + 1)])) // all white
  339.                     thisbad += N2;
  340.  
  341.         // X runs
  342.         for (y = 0; y < width; y++) {
  343.             rlens[0] = 0;
  344.             for (h = b = x = 0; x < width; x++) {
  345.                 if ((b1 = qrframe[x + width * y]) == b)
  346.                     rlens[h]++;
  347.                 else
  348.                     rlens[++h] = 1;
  349.                 b = b1;
  350.                 bw += b ? 1 : -1;
  351.             }
  352.             thisbad += badruns(h);
  353.         }
  354.  
  355.         // black/white imbalance
  356.         if (bw < 0)
  357.             bw = -bw;
  358.  
  359.         var big = bw;
  360.         var count = 0;
  361.         big += big << 2;
  362.         big <<= 1;
  363.         while (big > width * width)
  364.             big -= width * width, count++;
  365.         thisbad += count * N4;
  366.  
  367.         // Y runs
  368.         for (x = 0; x < width; x++) {
  369.             rlens[0] = 0;
  370.             for (h = b = y = 0; y < width; y++) {
  371.                 if ((b1 = qrframe[x + width * y]) == b)
  372.                     rlens[h]++;
  373.                 else
  374.                     rlens[++h] = 1;
  375.                 b = b1;
  376.             }
  377.             thisbad += badruns(h);
  378.         }
  379.         return thisbad;
  380.     }
  381.  
  382.     function genframe(instring)
  383.     {
  384.         var x, y, k, t, v, i, j, m;
  385.  
  386.     // find the smallest version that fits the string
  387.         t = instring.length;
  388.         version = 0;
  389.         do {
  390.             version++;
  391.             k = (ecclevel - 1) * 4 + (version - 1) * 16;
  392.             neccblk1 = eccblocks[k++];
  393.             neccblk2 = eccblocks[k++];
  394.             datablkw = eccblocks[k++];
  395.             eccblkwid = eccblocks[k];
  396.             k = datablkw * (neccblk1 + neccblk2) + neccblk2 - 3 + (version <= 9);
  397.             if (t <= k)
  398.                 break;
  399.         } while (version < 40);
  400.  
  401.     // FIXME - insure that it fits insted of being truncated
  402.         width = 17 + 4 * version;
  403.  
  404.     // allocate, clear and setup data structures
  405.         v = datablkw + (datablkw + eccblkwid) * (neccblk1 + neccblk2) + neccblk2;
  406.         for( t = 0; t < v; t++ )
  407.             eccbuf[t] = 0;
  408.         strinbuf = instring.slice(0);
  409.  
  410.         for( t = 0; t < width * width; t++ )
  411.             qrframe[t] = 0;
  412.  
  413.         for( t = 0 ; t < (width * (width + 1) + 1) / 2; t++)
  414.             framask[t] = 0;
  415.  
  416.     // insert finders - black to frame, white to mask
  417.         for (t = 0; t < 3; t++) {
  418.             k = 0;
  419.             y = 0;
  420.             if (t == 1)
  421.                 k = (width - 7);
  422.             if (t == 2)
  423.                 y = (width - 7);
  424.             qrframe[(y + 3) + width * (k + 3)] = 1;
  425.             for (x = 0; x < 6; x++) {
  426.                 qrframe[(y + x) + width * k] = 1;
  427.                 qrframe[y + width * (k + x + 1)] = 1;
  428.                 qrframe[(y + 6) + width * (k + x)] = 1;
  429.                 qrframe[(y + x + 1) + width * (k + 6)] = 1;
  430.             }
  431.             for (x = 1; x < 5; x++) {
  432.                 setmask(y + x, k + 1);
  433.                 setmask(y + 1, k + x + 1);
  434.                 setmask(y + 5, k + x);
  435.                 setmask(y + x + 1, k + 5);
  436.             }
  437.             for (x = 2; x < 4; x++) {
  438.                 qrframe[(y + x) + width * (k + 2)] = 1;
  439.                 qrframe[(y + 2) + width * (k + x + 1)] = 1;
  440.                 qrframe[(y + 4) + width * (k + x)] = 1;
  441.                 qrframe[(y + x + 1) + width * (k + 4)] = 1;
  442.             }
  443.         }
  444.  
  445.     // alignment blocks
  446.         if (version > 1) {
  447.             t = adelta[version];
  448.             y = width - 7;
  449.             for (;;) {
  450.                 x = width - 7;
  451.                 while (x > t - 3) {
  452.                     putalign(x, y);
  453.                     if (x < t)
  454.                         break;
  455.                     x -= t;
  456.                 }
  457.                 if (y <= t + 9)
  458.                     break;
  459.                 y -= t;
  460.                 putalign(6, y);
  461.                 putalign(y, 6);
  462.             }
  463.         }
  464.  
  465.     // single black
  466.         qrframe[8 + width * (width - 8)] = 1;
  467.  
  468.     // timing gap - mask only
  469.         for (y = 0; y < 7; y++) {
  470.             setmask(7, y);
  471.             setmask(width - 8, y);
  472.             setmask(7, y + width - 7);
  473.         }
  474.         for (x = 0; x < 8; x++) {
  475.             setmask(x, 7);
  476.             setmask(x + width - 8, 7);
  477.             setmask(x, width - 8);
  478.         }
  479.  
  480.     // reserve mask-format area
  481.         for (x = 0; x < 9; x++)
  482.             setmask(x, 8);
  483.         for (x = 0; x < 8; x++) {
  484.             setmask(x + width - 8, 8);
  485.             setmask(8, x);
  486.         }
  487.         for (y = 0; y < 7; y++)
  488.             setmask(8, y + width - 7);
  489.  
  490.     // timing row/col
  491.         for (x = 0; x < width - 14; x++)
  492.             if (x & 1) {
  493.                 setmask(8 + x, 6);
  494.                 setmask(6, 8 + x);
  495.             }
  496.             else {
  497.                 qrframe[(8 + x) + width * 6] = 1;
  498.                 qrframe[6 + width * (8 + x)] = 1;
  499.             }
  500.  
  501.     // version block
  502.         if (version > 6) {
  503.             t = vpat[version - 7];
  504.             k = 17;
  505.             for (x = 0; x < 6; x++)
  506.                 for (y = 0; y < 3; y++, k--)
  507.                     if (1 & (k > 11 ? version >> (k - 12) : t >> k)) {
  508.                         qrframe[(5 - x) + width * (2 - y + width - 11)] = 1;
  509.                         qrframe[(2 - y + width - 11) + width * (5 - x)] = 1;
  510.                     }
  511.             else {
  512.                 setmask(5 - x, 2 - y + width - 11);
  513.                 setmask(2 - y + width - 11, 5 - x);
  514.             }
  515.         }
  516.  
  517.     // sync mask bits - only set above for white spaces, so add in black bits
  518.         for (y = 0; y < width; y++)
  519.             for (x = 0; x <= y; x++)
  520.                 if (qrframe[x + width * y])
  521.                     setmask(x, y);
  522.  
  523.     // convert string to bitstream
  524.     // 8 bit data to QR-coded 8 bit data (numeric or alphanum, or kanji not supported)
  525.         v = strinbuf.length;
  526.  
  527.     // string to array
  528.         for( i = 0 ; i < v; i++ )
  529.             eccbuf[i] = strinbuf.charCodeAt(i);
  530.         strinbuf = eccbuf.slice(0);
  531.  
  532.     // calculate max string length
  533.         x = datablkw * (neccblk1 + neccblk2) + neccblk2;
  534.         if (v >= x - 2) {
  535.             v = x - 2;
  536.             if (version > 9)
  537.                 v--;
  538.         }
  539.  
  540.     // shift and repack to insert length prefix
  541.         i = v;
  542.         if (version > 9) {
  543.             strinbuf[i + 2] = 0;
  544.             strinbuf[i + 3] = 0;
  545.             while (i--) {
  546.                 t = strinbuf[i];
  547.                 strinbuf[i + 3] |= 255 & (t << 4);
  548.                 strinbuf[i + 2] = t >> 4;
  549.             }
  550.             strinbuf[2] |= 255 & (v << 4);
  551.             strinbuf[1] = v >> 4;
  552.             strinbuf[0] = 0x40 | (v >> 12);
  553.         }
  554.         else {
  555.             strinbuf[i + 1] = 0;
  556.             strinbuf[i + 2] = 0;
  557.             while (i--) {
  558.                 t = strinbuf[i];
  559.                 strinbuf[i + 2] |= 255 & (t << 4);
  560.                 strinbuf[i + 1] = t >> 4;
  561.             }
  562.             strinbuf[1] |= 255 & (v << 4);
  563.             strinbuf[0] = 0x40 | (v >> 4);
  564.         }
  565.     // fill to end with pad pattern
  566.         i = v + 3 - (version < 10);
  567.         while (i < x) {
  568.             strinbuf[i++] = 0xec;
  569.             // buffer has room    if (i == x)      break;
  570.             strinbuf[i++] = 0x11;
  571.         }
  572.  
  573.     // calculate and append ECC
  574.  
  575.     // calculate generator polynomial
  576.         genpoly[0] = 1;
  577.         for (i = 0; i < eccblkwid; i++) {
  578.             genpoly[i + 1] = 1;
  579.             for (j = i; j > 0; j--)
  580.                 genpoly[j] = genpoly[j]
  581.                 ? genpoly[j - 1] ^ gexp[modnn(glog[genpoly[j]] + i)] : genpoly[j - 1];
  582.             genpoly[0] = gexp[modnn(glog[genpoly[0]] + i)];
  583.         }
  584.         for (i = 0; i <= eccblkwid; i++)
  585.             genpoly[i] = glog[genpoly[i]]; // use logs for genpoly[] to save calc step
  586.  
  587.     // append ecc to data buffer
  588.         k = x;
  589.         y = 0;
  590.         for (i = 0; i < neccblk1; i++) {
  591.             appendrs(y, datablkw, k, eccblkwid);
  592.             y += datablkw;
  593.             k += eccblkwid;
  594.         }
  595.         for (i = 0; i < neccblk2; i++) {
  596.             appendrs(y, datablkw + 1, k, eccblkwid);
  597.             y += datablkw + 1;
  598.             k += eccblkwid;
  599.         }
  600.     // interleave blocks
  601.         y = 0;
  602.         for (i = 0; i < datablkw; i++) {
  603.             for (j = 0; j < neccblk1; j++)
  604.                 eccbuf[y++] = strinbuf[i + j * datablkw];
  605.             for (j = 0; j < neccblk2; j++)
  606.                 eccbuf[y++] = strinbuf[(neccblk1 * datablkw) + i + (j * (datablkw + 1))];
  607.         }
  608.         for (j = 0; j < neccblk2; j++)
  609.             eccbuf[y++] = strinbuf[(neccblk1 * datablkw) + i + (j * (datablkw + 1))];
  610.         for (i = 0; i < eccblkwid; i++)
  611.             for (j = 0; j < neccblk1 + neccblk2; j++)
  612.                 eccbuf[y++] = strinbuf[x + i + j * eccblkwid];
  613.         strinbuf = eccbuf;
  614.  
  615.     // pack bits into frame avoiding masked area.
  616.         x = y = width - 1;
  617.         k = v = 1;         // up, minus
  618.         /* inteleaved data and ecc codes */
  619.         m = (datablkw + eccblkwid) * (neccblk1 + neccblk2) + neccblk2;
  620.         for (i = 0; i < m; i++) {
  621.             t = strinbuf[i];
  622.             for (j = 0; j < 8; j++, t <<= 1) {
  623.                 if (0x80 & t)
  624.                     qrframe[x + width * y] = 1;
  625.                 do {        // find next fill position
  626.                     if (v)
  627.                         x--;
  628.                     else {
  629.                         x++;
  630.                         if (k) {
  631.                             if (y != 0)
  632.                                 y--;
  633.                             else {
  634.                                 x -= 2;
  635.                                 k = !k;
  636.                                 if (x == 6) {
  637.                                     x--;
  638.                                     y = 9;
  639.                                 }
  640.                             }
  641.                         }
  642.                         else {
  643.                             if (y != width - 1)
  644.                                 y++;
  645.                             else {
  646.                                 x -= 2;
  647.                                 k = !k;
  648.                                 if (x == 6) {
  649.                                     x--;
  650.                                     y -= 8;
  651.                                 }
  652.                             }
  653.                         }
  654.                     }
  655.                     v = !v;
  656.                 } while (ismasked(x, y));
  657.             }
  658.         }
  659.  
  660.     // save pre-mask copy of frame
  661.         strinbuf = qrframe.slice(0);
  662.         t = 0;           // best
  663.         y = 30000;         // demerit
  664.     // for instead of while since in original arduino code
  665.     // if an early mask was "good enough" it wouldn't try for a better one
  666.     // since they get more complex and take longer.
  667.         for (k = 0; k < 8; k++) {
  668.             applymask(k);      // returns black-white imbalance
  669.             x = badcheck();
  670.             if (x < y) { // current mask better than previous best?
  671.                 y = x;
  672.                 t = k;
  673.             }
  674.             if (t == 7)
  675.                 break;       // don't increment i to a void redoing mask
  676.             qrframe = strinbuf.slice(0); // reset for next pass
  677.         }
  678.         if (t != k)         // redo best mask - none good enough, last wasn't t
  679.             applymask(t);
  680.  
  681.     // add in final mask/ecclevel bytes
  682.         y = fmtword[t + ((ecclevel - 1) << 3)];
  683.         // low byte
  684.         for (k = 0; k < 8; k++, y >>= 1)
  685.             if (y & 1) {
  686.                 qrframe[(width - 1 - k) + width * 8] = 1;
  687.                 if (k < 6)
  688.                     qrframe[8 + width * k] = 1;
  689.                 else
  690.                     qrframe[8 + width * (k + 1)] = 1;
  691.             }
  692.         // high byte
  693.         for (k = 0; k < 7; k++, y >>= 1)
  694.             if (y & 1) {
  695.                 qrframe[8 + width * (width - 7 + k)] = 1;
  696.                 if (k)
  697.                     qrframe[(6 - k) + width * 8] = 1;
  698.                 else
  699.                     qrframe[7 + width * 8] = 1;
  700.             }
  701.  
  702.     // return image
  703.         return qrframe;
  704.     }
  705.  
  706.     var _canvas = null,
  707.         _size = null;
  708.  
  709.     var api = {
  710.  
  711.         get ecclevel () {
  712.             return ecclevel;
  713.         },
  714.  
  715.         set ecclevel (val) {
  716.             ecclevel = val;
  717.         },
  718.  
  719.         get size () {
  720.             return _size;
  721.         },
  722.  
  723.         set size (val) {
  724.             _size = val
  725.         },
  726.  
  727.         get canvas () {
  728.             return _canvas;
  729.         },
  730.  
  731.         set canvas (el) {
  732.             _canvas = el;
  733.         },
  734.  
  735.         getFrame: function (string) {
  736.             return genframe(string);
  737.         },
  738.  
  739.         draw: function (string, canvas, size, ecc) {
  740.  
  741.             ecclevel = ecc || ecclevel;
  742.             canvas = canvas || _canvas;
  743.  
  744.             if (!canvas) {
  745.                 console.warn('No canvas provided to draw QR code in!')
  746.                 return;
  747.             }
  748.  
  749.             size = size || _size || Math.min(canvas.width, canvas.height);
  750.  
  751.             var frame = genframe(string),
  752.                 ctx = canvas.ctx,
  753.                 px = Math.round(size / (width + 8));
  754.  
  755.             var roundedSize = px * (width + 8),
  756.                 offset = Math.floor((size - roundedSize) / 2);
  757.  
  758.             size = roundedSize;
  759.  
  760.             ctx.clearRect(0, 0, canvas.width, canvas.height);
  761.             ctx.setFillStyle('#000000');
  762.             for (var i = 0; i < width; i++) {
  763.                 for (var j = 0; j < width; j++) {
  764.                     if (frame[j * width + i]) {
  765.                         ctx.fillRect(px * (4 + i) + offset, px * (4 + j) + offset, px, px);
  766.                     }
  767.                 }
  768.             }
  769.             ctx.draw();
  770.         }
  771.     }
  772.  
  773.     module.exports = {
  774.         api: api
  775.     }
  776.  
  777. })()

 

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号