开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 电子政务应用 > 查看源码
QRCodeEncoder.cs
资源名称：QRCodeLib.rar　[点击查看]
上传用户：tjjgrl
上传日期：2019-04-04
资源大小：1010k
文件大小：29k
源码类别：

电子政务应用

开发平台：

C#

QRCodeEncoder.cs：源码内容
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.Drawing.Imaging;
  5. using System.Drawing;
  6. using System.IO;
  7. using System.Resources;
  9. using ThoughtWorks.QRCode.Properties;
  11. using SystemUtils = ThoughtWorks.QRCode.Codec.Util.SystemUtils;
  12. using QRCodeUtility = ThoughtWorks.QRCode.Codec.Util.QRCodeUtility;
  14. namespace ThoughtWorks.QRCode.Codec
  15. {
  16.     public class QRCodeEncoder
  17.     {
  18.         public enum ENCODE_MODE {ALPHA_NUMERIC,NUMERIC,BYTE};
  19.         
  20.         public enum ERROR_CORRECTION {L, M, Q, H};
  22.         //internal static String DATA_PATH = "qrcode_data";
  23.         //internal static String QRCODE_DATA_PATH = String.Empty;
  25.         internal ERROR_CORRECTION qrcodeErrorCorrect;
  26.         internal ENCODE_MODE qrcodeEncodeMode;
  27. internal int qrcodeVersion;
  29. internal int qrcodeStructureappendN;
  30. internal int qrcodeStructureappendM;
  31. internal int qrcodeStructureappendParity;
  32.         
  33.         internal Color qrCodeBackgroundColor;
  34.         internal Color qrCodeForegroundColor;
  36.         internal int qrCodeScale;
  38. internal String qrcodeStructureappendOriginaldata;
  40.         /// <summary>
  41.         /// Constructor
  42.         /// </summary>
  43.         public QRCodeEncoder()
  44.         {
  45.             qrcodeErrorCorrect = ERROR_CORRECTION.M;
  46.             qrcodeEncodeMode = ENCODE_MODE.BYTE;
  47.             qrcodeVersion = 7;
  49.             qrcodeStructureappendN = 0;
  50.             qrcodeStructureappendM = 0;
  51.             qrcodeStructureappendParity = 0;
  52.             qrcodeStructureappendOriginaldata = "";
  54.             qrCodeScale = 4;
  55.             qrCodeBackgroundColor = Color.White;
  56.             qrCodeForegroundColor = Color.Black;
  57.            
  58.             //QRCODE_DATA_PATH = Environment.CurrentDirectory + @"" + DATA_PATH;
  60.         }
  63.         virtual public ERROR_CORRECTION QRCodeErrorCorrect
  64. {
  65. get
  66. {
  67. return qrcodeErrorCorrect;
  68. }
  70. set
  71. {
  72. qrcodeErrorCorrect = value;
  73. }
  75. }
  77. virtual public int QRCodeVersion
  78. {
  79. get
  80. {
  81. return qrcodeVersion;
  82. }
  84. set
  85. {
  86. if (value >= 0 && value <= 40)
  87. {
  88. qrcodeVersion = value;
  89. }
  90. }
  92. }
  94.         virtual public ENCODE_MODE QRCodeEncodeMode
  95. {
  96. get
  97. {
  98. return qrcodeEncodeMode;
  99. }
  101. set
  102. {
  103. qrcodeEncodeMode = value;
  104. }
  106. }
  108.         virtual public int QRCodeScale
  109.         {
  110.             get
  111.             {
  112.                 return qrCodeScale;
  113.             }
  114.             set
  115.             {
  116.                 qrCodeScale = value;
  117.             }
  118.         }
  120.         virtual public Color QRCodeBackgroundColor
  121.         {
  122.             get
  123.             {
  124.                 return qrCodeBackgroundColor;
  125.             }
  126.             set
  127.             {
  128.                 qrCodeBackgroundColor = value;
  129.             }
  130.         }
  132.         virtual public Color QRCodeForegroundColor
  133.         {
  134.             get
  135.             {
  136.                 return qrCodeForegroundColor;
  137.             }
  138.             set
  139.             {
  140.                 qrCodeForegroundColor = value;
  141.             }
  142.         }
  145. public virtual void  setStructureappend(int m, int n, int p)
  146. {
  147. if (n > 1 && n <= 16 && m > 0 && m <= 16 && p >= 0 && p <= 255)
  148. {
  149. qrcodeStructureappendM = m;
  150. qrcodeStructureappendN = n;
  151. qrcodeStructureappendParity = p;
  152. }
  153. }
  155. public virtual int calStructureappendParity(sbyte[] originaldata)
  156. {
  157. int originaldataLength;
  158. int i = 0;
  159. int structureappendParity = 0;
  161. originaldataLength = originaldata.Length;
  163. if (originaldataLength > 1)
  164. {
  165. structureappendParity = 0;
  166. while (i < originaldataLength)
  167. {
  168. structureappendParity = (structureappendParity ^ (originaldata[i] & 0xFF));
  169. i++;
  170. }
  171. }
  172. else
  173. {
  174. structureappendParity = - 1;
  175. }
  176. return structureappendParity;
  177. }
  179. public virtual bool[][] calQrcode(byte[] qrcodeData)
  180. {
  181. int dataLength;
  182. int dataCounter = 0;
  184. dataLength = qrcodeData.Length;
  186. int[] dataValue = new int[dataLength + 32];
  187. sbyte[] dataBits = new sbyte[dataLength + 32];
  189. if (dataLength <= 0)
  190. {
  191. bool[][] ret = new bool[][]{new bool[]{false}};
  192. return ret;
  193. }
  195. if (qrcodeStructureappendN > 1)
  196. {
  197. dataValue[0] = 3;
  198. dataBits[0] = 4;
  200. dataValue[1] = qrcodeStructureappendM - 1;
  201. dataBits[1] = 4;
  203. dataValue[2] = qrcodeStructureappendN - 1;
  204. dataBits[2] = 4;
  206. dataValue[3] = qrcodeStructureappendParity;
  207. dataBits[3] = 8;
  209. dataCounter = 4;
  210. }
  211. dataBits[dataCounter] = 4;
  213. /*  --- determine encode mode --- */
  215. int[] codewordNumPlus;
  216. int codewordNumCounterValue;
  218. switch (qrcodeEncodeMode)
  219. {
  220. /* ---- alphanumeric mode ---  */
  221.                 case ENCODE_MODE.ALPHA_NUMERIC: 
  223. codewordNumPlus = new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4};
  225. dataValue[dataCounter] = 2;
  226. dataCounter++;
  227. dataValue[dataCounter] = dataLength;
  228. dataBits[dataCounter] = 9;
  229. codewordNumCounterValue = dataCounter;
  231. dataCounter++;
  232. for (int i = 0; i < dataLength; i++)
  233. {
  234. char chr = (char) qrcodeData[i];
  235. sbyte chrValue = 0;
  236. if (chr >= 48 && chr < 58)
  237. {
  238. chrValue = (sbyte) (chr - 48);
  239. }
  240. else
  241. {
  242. if (chr >= 65 && chr < 91)
  243. {
  244. chrValue = (sbyte) (chr - 55);
  245. }
  246. else
  247. {
  248. if (chr == 32)
  249. {
  250. chrValue = 36;
  251. }
  252. if (chr == 36)
  253. {
  254. chrValue = 37;
  255. }
  256. if (chr == 37)
  257. {
  258. chrValue = 38;
  259. }
  260. if (chr == 42)
  261. {
  262. chrValue = 39;
  263. }
  264. if (chr == 43)
  265. {
  266. chrValue = 40;
  267. }
  268. if (chr == 45)
  269. {
  270. chrValue = 41;
  271. }
  272. if (chr == 46)
  273. {
  274. chrValue = 42;
  275. }
  276. if (chr == 47)
  277. {
  278. chrValue = 43;
  279. }
  280. if (chr == 58)
  281. {
  282. chrValue = 44;
  283. }
  284. }
  285. }
  286. if ((i % 2) == 0)
  287. {
  288. dataValue[dataCounter] = chrValue;
  289. dataBits[dataCounter] = 6;
  290. }
  291. else
  292. {
  293. dataValue[dataCounter] = dataValue[dataCounter] * 45 + chrValue;
  294. dataBits[dataCounter] = 11;
  295. if (i < dataLength - 1)
  296. {
  297. dataCounter++;
  298. }
  299. }
  300. }
  301. dataCounter++;
  302. break;
  304. /* ---- numeric mode ---- */
  306.                 case ENCODE_MODE.NUMERIC: 
  308. codewordNumPlus = new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4};
  310. dataValue[dataCounter] = 1;
  311. dataCounter++;
  312. dataValue[dataCounter] = dataLength;
  314. dataBits[dataCounter] = 10; /* #version 1-9*/
  315. codewordNumCounterValue = dataCounter;
  317. dataCounter++;
  318. for (int i = 0; i < dataLength; i++)
  319. {
  321. if ((i % 3) == 0)
  322. {
  323. dataValue[dataCounter] = (int) (qrcodeData[i] - 0x30);
  324. dataBits[dataCounter] = 4;
  325. }
  326. else
  327. {
  329. dataValue[dataCounter] = dataValue[dataCounter] * 10 + (int) (qrcodeData[i] - 0x30);
  331. if ((i % 3) == 1)
  332. {
  333. dataBits[dataCounter] = 7;
  334. }
  335. else
  336. {
  337. dataBits[dataCounter] = 10;
  338. if (i < dataLength - 1)
  339. {
  340. dataCounter++;
  341. }
  342. }
  343. }
  344. }
  345. dataCounter++;
  346. break;
  348. /* ---- 8bit byte ---- */
  350. default: 
  352. codewordNumPlus = new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8};
  353. dataValue[dataCounter] = 4;
  354. dataCounter++;
  355. dataValue[dataCounter] = dataLength;
  356. dataBits[dataCounter] = 8; /* #version 1-9 */
  357. codewordNumCounterValue = dataCounter;
  359. dataCounter++;
  361. for (int i = 0; i < dataLength; i++)
  362. {
  363. dataValue[i + dataCounter] = (qrcodeData[i] & 0xFF);
  364. dataBits[i + dataCounter] = 8;
  365. }
  366. dataCounter += dataLength;
  368. break;
  370. }
  372. int totalDataBits = 0;
  373. for (int i = 0; i < dataCounter; i++)
  374. {
  375. totalDataBits += dataBits[i];
  376. }
  378. int ec;
  379. switch (qrcodeErrorCorrect)
  380. {
  382. case ERROR_CORRECTION.L: 
  383. ec = 1;
  384. break;
  386.                 case ERROR_CORRECTION.Q: 
  387. ec = 3;
  388. break;
  390.                 case ERROR_CORRECTION.H: 
  391. ec = 2;
  392. break;
  394. default: 
  395. ec = 0;
  396. break;
  398. }
  401. int[][] maxDataBitsArray = new int[][]{new int[]{0, 128, 224, 352, 512, 688, 864, 992, 1232, 1456, 1728, 2032, 2320, 2672, 2920, 3320, 3624, 4056, 4504, 5016, 5352, 5712, 6256, 6880, 7312, 8000, 8496, 9024, 9544, 10136, 10984, 11640, 12328, 13048, 13800, 14496, 15312, 15936, 16816, 17728, 18672}, new int[]{0, 152, 272, 440, 640, 864, 1088, 1248, 1552, 1856, 2192, 2592, 2960, 3424, 3688, 4184, 4712, 5176, 5768, 6360, 6888, 7456, 8048, 8752, 9392, 10208, 10960, 11744, 12248, 13048, 13880, 14744, 15640, 16568, 17528, 18448, 19472, 20528, 21616, 22496, 23648}, new int[]{0, 72, 128, 208, 288, 368, 480, 528, 688, 800, 976, 1120, 1264, 1440, 1576, 1784, 2024, 2264, 2504, 2728, 3080, 3248, 3536, 3712, 4112, 4304, 4768, 5024, 5288, 5608, 5960, 6344, 6760, 7208, 7688, 7888, 8432, 8768, 9136, 9776, 10208}, new int[]{0, 104, 176, 272, 384, 496, 608, 704, 880, 1056, 1232, 1440, 1648, 1952, 2088, 2360, 2600, 2936, 3176, 3560, 3880, 4096, 4544, 4912, 5312, 5744, 6032, 6464, 6968, 7288, 7880, 8264, 8920, 9368, 9848, 10288, 10832, 11408, 12016, 12656, 13328}};
  403. int maxDataBits = 0;
  405. if (qrcodeVersion == 0)
  406. {
  407. /* auto version select */
  409. qrcodeVersion = 1;
  410. for (int i = 1; i <= 40; i++)
  411. {
  412. if ((maxDataBitsArray[ec][i]) >= totalDataBits + codewordNumPlus[qrcodeVersion])
  413. {
  414. maxDataBits = maxDataBitsArray[ec][i];
  415. break;
  416. }
  417. qrcodeVersion++;
  418. }
  419. }
  420. else
  421. {
  422. maxDataBits = maxDataBitsArray[ec][qrcodeVersion];
  423. }
  424. totalDataBits += codewordNumPlus[qrcodeVersion];
  425. dataBits[codewordNumCounterValue] = (sbyte) (dataBits[codewordNumCounterValue] + codewordNumPlus[qrcodeVersion]);
  427. int[] maxCodewordsArray = new int[]{0, 26, 44, 70, 100, 134, 172, 196, 242, 292, 346, 404, 466, 532, 581, 655, 733, 815, 901, 991, 1085, 1156, 1258, 1364, 1474, 1588, 1706, 1828, 1921, 2051, 2185, 2323, 2465, 2611, 2761, 2876, 3034, 3196, 3362, 3532, 3706};
  429. int maxCodewords = maxCodewordsArray[qrcodeVersion];
  430. int maxModules1side = 17 + (qrcodeVersion << 2);
  432. int[] matrixRemainBit = new int[]{0, 0, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0};
  434. /* ---- read version ECC data file */
  436. int byte_num = matrixRemainBit[qrcodeVersion] + (maxCodewords << 3);
  438. sbyte[] matrixX = new sbyte[byte_num];
  439. sbyte[] matrixY = new sbyte[byte_num];
  440. sbyte[] maskArray = new sbyte[byte_num];
  441. sbyte[] formatInformationX2 = new sbyte[15];
  442. sbyte[] formatInformationY2 = new sbyte[15];
  443. sbyte[] rsEccCodewords = new sbyte[1];
  444. sbyte[] rsBlockOrderTemp = new sbyte[128];
  446. try
  447. {
  448. //String filename = QRCODE_DATA_PATH + @"qrv" + System.Convert.ToString(qrcodeVersion) + "_" + System.Convert.ToString(ec) + ".dat";
  449.             //StreamReader reader = new StreamReader(filename);
  450.                 //BufferedStream bis = new BufferedStream(reader.BaseStream);
  451.                                 
  452.                 String fileName = "qrv" + Convert.ToString(qrcodeVersion) + "_" + Convert.ToString(ec);
  453.                 MemoryStream memoryStream = new MemoryStream(Resources.GetResource(fileName));
  454.                 BufferedStream bis = new BufferedStream(memoryStream);
  455.                 
  456.                 SystemUtils.ReadInput(bis, matrixX, 0, matrixX.Length);
  457.                 SystemUtils.ReadInput(bis, matrixY, 0, matrixY.Length);
  458.                 SystemUtils.ReadInput(bis, maskArray, 0, maskArray.Length);
  459.                 SystemUtils.ReadInput(bis, formatInformationX2, 0, formatInformationX2.Length);
  460.                 SystemUtils.ReadInput(bis, formatInformationY2, 0, formatInformationY2.Length);
  461.                 SystemUtils.ReadInput(bis, rsEccCodewords, 0, rsEccCodewords.Length);
  462.                 SystemUtils.ReadInput(bis, rsBlockOrderTemp, 0, rsBlockOrderTemp.Length);
  464.                 bis.Close();
  465.                 memoryStream.Close();
  467.                 // reader.Close();
  468. /*
  469.                 fis.Close();
  470.                 */
  471. }
  472. catch (Exception e)
  473. {
  474. SystemUtils.WriteStackTrace(e, Console.Error);
  475. }
  477. sbyte rsBlockOrderLength = 1;
  478. for (sbyte i = 1; i < 128; i++)
  479. {
  480. if (rsBlockOrderTemp[i] == 0)
  481. {
  482. rsBlockOrderLength = i;
  483. break;
  484. }
  485. }
  486. sbyte[] rsBlockOrder = new sbyte[rsBlockOrderLength];
  487. Array.Copy(rsBlockOrderTemp, 0, rsBlockOrder, 0, (byte) rsBlockOrderLength);
  490. sbyte[] formatInformationX1 = new sbyte[]{0, 1, 2, 3, 4, 5, 7, 8, 8, 8, 8, 8, 8, 8, 8};
  491. sbyte[] formatInformationY1 = new sbyte[]{8, 8, 8, 8, 8, 8, 8, 8, 7, 5, 4, 3, 2, 1, 0};
  493. int maxDataCodewords = maxDataBits >> 3;
  495. /* -- read frame data  -- */
  497. int modules1Side = 4 * qrcodeVersion + 17;
  498. int matrixTotalBits = modules1Side * modules1Side;
  499. sbyte[] frameData = new sbyte[matrixTotalBits + modules1Side];
  501. try
  502. {
  503. //String filename = QRCODE_DATA_PATH + "/qrvfr" + System.Convert.ToString(qrcodeVersion) + ".dat";
  504.                 //StreamReader reader = new StreamReader(filename);
  506.                 String fileName = "qrvfr" + Convert.ToString(qrcodeVersion);
  507.                 MemoryStream memoryStream = new MemoryStream(Resources.GetResource(fileName));
  508.                 
  509. BufferedStream bis = new BufferedStream(memoryStream);
  510. SystemUtils.ReadInput(bis, frameData, 0, frameData.Length);
  511. bis.Close();
  512.                 memoryStream.Close();
  513.                 //reader.Close();
  514.                 //fis.Close();
  515. }
  516. catch (Exception e)
  517. {
  518. SystemUtils.WriteStackTrace(e, Console.Error);
  519. }
  521. /*  --- set terminator */
  523. if (totalDataBits <= maxDataBits - 4)
  524. {
  525. dataValue[dataCounter] = 0;
  526. dataBits[dataCounter] = 4;
  527. }
  528. else
  529. {
  530. if (totalDataBits < maxDataBits)
  531. {
  532. dataValue[dataCounter] = 0;
  533. dataBits[dataCounter] = (sbyte) (maxDataBits - totalDataBits);
  534. }
  535. else
  536. {
  537. if (totalDataBits > maxDataBits)
  538. {
  539. System.Console.Out.WriteLine("overflow");
  540. }
  541. }
  542. }
  543. sbyte[] dataCodewords = divideDataBy8Bits(dataValue, dataBits, maxDataCodewords);
  544. sbyte[] codewords = calculateRSECC(dataCodewords, rsEccCodewords[0], rsBlockOrder, maxDataCodewords, maxCodewords);
  546. /* ---- flash matrix */
  548. sbyte[][] matrixContent = new sbyte[modules1Side][];
  549. for (int i2 = 0; i2 < modules1Side; i2++)
  550. {
  551. matrixContent[i2] = new sbyte[modules1Side];
  552. }
  554. for (int i = 0; i < modules1Side; i++)
  555. {
  556. for (int j = 0; j < modules1Side; j++)
  557. {
  558. matrixContent[j][i] = 0;
  559. }
  560. }
  562. /* --- attach data */
  563. for (int i = 0; i < maxCodewords; i++)
  564. {
  566. sbyte codeword_i = codewords[i];
  567. for (int j = 7; j >= 0; j--)
  568. {
  570. int codewordBitsNumber = (i * 8) + j;
  572. matrixContent[matrixX[codewordBitsNumber] & 0xFF][matrixY[codewordBitsNumber] & 0xFF] = (sbyte) ((255 * (codeword_i & 1)) ^ maskArray[codewordBitsNumber]);
  574. codeword_i = (sbyte) (SystemUtils.URShift((codeword_i & 0xFF), 1));
  575. }
  576. }
  578. for (int matrixRemain = matrixRemainBit[qrcodeVersion]; matrixRemain > 0; matrixRemain--)
  579. {
  580. int remainBitTemp = matrixRemain + (maxCodewords * 8) - 1;
  581. matrixContent[matrixX[remainBitTemp] & 0xFF][matrixY[remainBitTemp] & 0xFF] = (sbyte) (255 ^ maskArray[remainBitTemp]);
  582. }
  584. /* --- mask select --- */
  585. sbyte maskNumber = selectMask(matrixContent, matrixRemainBit[qrcodeVersion] + maxCodewords * 8);
  586. sbyte maskContent = (sbyte) (1 << maskNumber);
  588. /* --- format information --- */
  590. sbyte formatInformationValue = (sbyte) (ec << 3 | maskNumber);
  592. String[] formatInformationArray = new String[]{"101010000010010", "101000100100101", "101111001111100", "101101101001011", "100010111111001", "100000011001110", "100111110010111", "100101010100000", "111011111000100", "111001011110011", "111110110101010", "111100010011101", "110011000101111", "110001100011000", "110110001000001", "110100101110110", "001011010001001", "001001110111110", "001110011100111", "001100111010000", "000011101100010", "000001001010101", "000110100001100", "000100000111011", "011010101011111", "011000001101000", "011111100110001", "011101000000110", "010010010110100", "010000110000011", "010111011011010", "010101111101101"};
  594. for (int i = 0; i < 15; i++)
  595. {
  597. sbyte content = (sbyte) System.SByte.Parse(formatInformationArray[formatInformationValue].Substring(i, (i + 1) - (i)));
  599. matrixContent[formatInformationX1[i] & 0xFF][formatInformationY1[i] & 0xFF] = (sbyte) (content * 255);
  600. matrixContent[formatInformationX2[i] & 0xFF][formatInformationY2[i] & 0xFF] = (sbyte) (content * 255);
  601. }
  603. bool[][] out_Renamed = new bool[modules1Side][];
  604. for (int i3 = 0; i3 < modules1Side; i3++)
  605. {
  606. out_Renamed[i3] = new bool[modules1Side];
  607. }
  609. int c = 0;
  610. for (int i = 0; i < modules1Side; i++)
  611. {
  612. for (int j = 0; j < modules1Side; j++)
  613. {
  615. if ((matrixContent[j][i] & maskContent) != 0 || frameData[c] == (char) 49)
  616. {
  617. out_Renamed[j][i] = true;
  618. }
  619. else
  620. {
  621. out_Renamed[j][i] = false;
  622. }
  623. c++;
  624. }
  625. c++;
  626. }
  628. return out_Renamed;
  629. }
  631. private static sbyte[] divideDataBy8Bits(int[] data, sbyte[] bits, int maxDataCodewords)
  632. {
  633. /* divide Data By 8bit and add padding char */
  634. int l1 = bits.Length;
  635. int l2;
  636. int codewordsCounter = 0;
  637. int remainingBits = 8;
  638. int max = 0;
  639. int buffer;
  640. int bufferBits;
  641. bool flag;
  643. if (l1 != data.Length)
  644. {
  645. }
  646. for (int i = 0; i < l1; i++)
  647. {
  648. max += bits[i];
  649. }
  650. l2 = (max - 1) / 8 + 1;
  651. sbyte[] codewords = new sbyte[maxDataCodewords];
  652. for (int i = 0; i < l2; i++)
  653. {
  654. codewords[i] = 0;
  655. }
  656. for (int i = 0; i < l1; i++)
  657. {
  658. buffer = data[i];
  659. bufferBits = bits[i];
  660. flag = true;
  662. if (bufferBits == 0)
  663. {
  664. break;
  665. }
  666. while (flag)
  667. {
  668. if (remainingBits > bufferBits)
  669. {
  670. codewords[codewordsCounter] = (sbyte) ((codewords[codewordsCounter] << bufferBits) | buffer);
  671. remainingBits -= bufferBits;
  672. flag = false;
  673. }
  674. else
  675. {
  676. bufferBits -= remainingBits;
  677. codewords[codewordsCounter] = (sbyte) ((codewords[codewordsCounter] << remainingBits) | (buffer >> bufferBits));
  679. if (bufferBits == 0)
  680. {
  681. flag = false;
  682. }
  683. else
  684. {
  685. buffer = (buffer & ((1 << bufferBits) - 1));
  686. flag = true;
  687. }
  688. codewordsCounter++;
  689. remainingBits = 8;
  690. }
  691. }
  692. }
  693. if (remainingBits != 8)
  694. {
  695. codewords[codewordsCounter] = (sbyte) (codewords[codewordsCounter] << remainingBits);
  696. }
  697. else
  698. {
  699. codewordsCounter--;
  700. }
  701. if (codewordsCounter < maxDataCodewords - 1)
  702. {
  703. flag = true;
  704. while (codewordsCounter < maxDataCodewords - 1)
  705. {
  706. codewordsCounter++;
  707. if (flag)
  708. {
  709. codewords[codewordsCounter] = - 20;
  710. }
  711. else
  712. {
  713. codewords[codewordsCounter] = 17;
  714. }
  715. flag = !(flag);
  716. }
  717. }
  718. return codewords;
  719. }
  722. private static sbyte[] calculateRSECC(sbyte[] codewords, sbyte rsEccCodewords, sbyte[] rsBlockOrder, int maxDataCodewords, int maxCodewords)
  723. {
  725. sbyte[][] rsCalTableArray = new sbyte[256][];
  726. for (int i = 0; i < 256; i++)
  727. {
  728. rsCalTableArray[i] = new sbyte[rsEccCodewords];
  729. }
  730. try
  731. {
  732.     //String filename = QRCODE_DATA_PATH + @"rsc" + rsEccCodewords.ToString() + ".dat";
  733.     //StreamReader reader = new StreamReader(filename);
  734.                 String fileName = "rsc" + rsEccCodewords.ToString();
  735.                 MemoryStream memoryStream = new MemoryStream(Resources.GetResource(fileName));
  736.                 BufferedStream bis = new BufferedStream(memoryStream);
  737. for (int i = 0; i < 256; i++)
  738. {
  739. SystemUtils.ReadInput(bis, rsCalTableArray[i], 0, rsCalTableArray[i].Length);
  740. }
  741. bis.Close();
  742. //reader.Close();
  743.                 memoryStream.Close();
  744. }
  745. catch (Exception e)
  746. {
  747. SystemUtils.WriteStackTrace(e, Console.Error);
  748. }
  751. /* ---- RS-ECC prepare */
  753. int i2 = 0;
  754. int j = 0;
  755. int rsBlockNumber = 0;
  757. sbyte[][] rsTemp = new sbyte[rsBlockOrder.Length][];
  758.             /*
  759.             for (int i = 0; i < rsBlockOrder.Length; i++)
  760.             {
  761.                 rsTemp[i] = new sbyte[rsBlockOrder.Length];
  762.             }
  763.             */
  764. sbyte[] res = new sbyte[maxCodewords];
  765. Array.Copy(codewords, 0, res, 0, codewords.Length);
  767. i2 = 0;
  768. while (i2 < rsBlockOrder.Length)
  769. {
  770. rsTemp[i2] = new sbyte[(rsBlockOrder[i2] & 0xFF) - rsEccCodewords];
  771. i2++;
  772. }
  773. i2 = 0;
  774. while (i2 < maxDataCodewords)
  775. {
  776. rsTemp[rsBlockNumber][j] = codewords[i2];
  777. j++;
  778. if (j >= (rsBlockOrder[rsBlockNumber] & 0xFF) - rsEccCodewords)
  779. {
  780. j = 0;
  781. rsBlockNumber++;
  782. }
  783. i2++;
  784. }
  786. /* ---  RS-ECC main --- */
  788. rsBlockNumber = 0;
  789. while (rsBlockNumber < rsBlockOrder.Length)
  790. {
  791. sbyte[] rsTempData;
  792. rsTempData = new sbyte[rsTemp[rsBlockNumber].Length];
  793. rsTemp[rsBlockNumber].CopyTo(rsTempData, 0);
  795. int rsCodewords = (rsBlockOrder[rsBlockNumber] & 0xFF);
  796. int rsDataCodewords = rsCodewords - rsEccCodewords;
  798. j = rsDataCodewords;
  799. while (j > 0)
  800. {
  801. sbyte first = rsTempData[0];
  802. if (first != 0)
  803. {
  804. sbyte[] leftChr = new sbyte[rsTempData.Length - 1];
  805. Array.Copy(rsTempData, 1, leftChr, 0, rsTempData.Length - 1);
  806. sbyte[] cal = rsCalTableArray[(first & 0xFF)];
  807. rsTempData = calculateByteArrayBits(leftChr, cal, "xor");
  808. }
  809. else
  810. {
  811. if (rsEccCodewords < rsTempData.Length)
  812. {
  813. sbyte[] rsTempNew = new sbyte[rsTempData.Length - 1];
  814. Array.Copy(rsTempData, 1, rsTempNew, 0, rsTempData.Length - 1);
  815. rsTempData = new sbyte[rsTempNew.Length];
  816. rsTempNew.CopyTo(rsTempData, 0);
  817. }
  818. else
  819. {
  820. sbyte[] rsTempNew = new sbyte[rsEccCodewords];
  821. Array.Copy(rsTempData, 1, rsTempNew, 0, rsTempData.Length - 1);
  822. rsTempNew[rsEccCodewords - 1] = 0;
  823. rsTempData = new sbyte[rsTempNew.Length];
  824. rsTempNew.CopyTo(rsTempData, 0);
  825. }
  826. }
  827. j--;
  828. }
  830. Array.Copy(rsTempData, 0, res, codewords.Length + rsBlockNumber * rsEccCodewords, (byte) rsEccCodewords);
  831. rsBlockNumber++;
  832. }
  833. return res;
  834. }
  836. private static sbyte[] calculateByteArrayBits(sbyte[] xa, sbyte[] xb, String ind)
  837. {
  838. int ll;
  839. int ls;
  840. sbyte[] res;
  841. sbyte[] xl;
  842. sbyte[] xs;
  844. if (xa.Length > xb.Length)
  845. {
  846. xl = new sbyte[xa.Length];
  847. xa.CopyTo(xl, 0);
  848. xs = new sbyte[xb.Length];
  849. xb.CopyTo(xs, 0);
  850. }
  851. else
  852. {
  853. xl = new sbyte[xb.Length];
  854. xb.CopyTo(xl, 0);
  855. xs = new sbyte[xa.Length];
  856. xa.CopyTo(xs, 0);
  857. }
  858. ll = xl.Length;
  859. ls = xs.Length;
  860. res = new sbyte[ll];
  862. for (int i = 0; i < ll; i++)
  863. {
  864. if (i < ls)
  865. {
  866. if ((System.Object) ind == (System.Object) "xor")
  867. {
  868. res[i] = (sbyte) (xl[i] ^ xs[i]);
  869. }
  870. else
  871. {
  872. res[i] = (sbyte) (xl[i] | xs[i]);
  873. }
  874. }
  875. else
  876. {
  877. res[i] = xl[i];
  878. }
  879. }
  880. return res;
  881. }
  883. private static sbyte selectMask(sbyte[][] matrixContent, int maxCodewordsBitWithRemain)
  884. {
  885. int l = matrixContent.Length;
  886. int[] d1 = new int[]{0, 0, 0, 0, 0, 0, 0, 0};
  887. int[] d2 = new int[]{0, 0, 0, 0, 0, 0, 0, 0};
  888. int[] d3 = new int[]{0, 0, 0, 0, 0, 0, 0, 0};
  889. int[] d4 = new int[]{0, 0, 0, 0, 0, 0, 0, 0};
  891. int d2And = 0;
  892. int d2Or = 0;
  893. int[] d4Counter = new int[]{0, 0, 0, 0, 0, 0, 0, 0};
  895. for (int y = 0; y < l; y++)
  896. {
  897. int[] xData = new int[]{0, 0, 0, 0, 0, 0, 0, 0};
  898. int[] yData = new int[]{0, 0, 0, 0, 0, 0, 0, 0};
  899. bool[] xD1Flag = new bool[]{false, false, false, false, false, false, false, false};
  900. bool[] yD1Flag = new bool[]{false, false, false, false, false, false, false, false};
  902. for (int x = 0; x < l; x++)
  903. {
  905. if (x > 0 && y > 0)
  906. {
  907. d2And = matrixContent[x][y] & matrixContent[x - 1][y] & matrixContent[x][y - 1] & matrixContent[x - 1][y - 1] & 0xFF;
  909. d2Or = (matrixContent[x][y] & 0xFF) | (matrixContent[x - 1][y] & 0xFF) | (matrixContent[x][y - 1] & 0xFF) | (matrixContent[x - 1][y - 1] & 0xFF);
  910. }
  912. for (int maskNumber = 0; maskNumber < 8; maskNumber++)
  913. {
  915. xData[maskNumber] = ((xData[maskNumber] & 63) << 1) | ((SystemUtils.URShift((matrixContent[x][y] & 0xFF), maskNumber)) & 1);
  918. yData[maskNumber] = ((yData[maskNumber] & 63) << 1) | ((SystemUtils.URShift((matrixContent[y][x] & 0xFF), maskNumber)) & 1);
  921. if ((matrixContent[x][y] & (1 << maskNumber)) != 0)
  922. {
  923. d4Counter[maskNumber]++;
  924. }
  927. if (xData[maskNumber] == 93)
  928. {
  929. d3[maskNumber] += 40;
  930. }
  932. if (yData[maskNumber] == 93)
  933. {
  934. d3[maskNumber] += 40;
  935. }
  937. if (x > 0 && y > 0)
  938. {
  940. if (((d2And & 1) != 0) || ((d2Or & 1) == 0))
  941. {
  942. d2[maskNumber] += 3;
  943. }
  945. d2And = d2And >> 1;
  946. d2Or = d2Or >> 1;
  947. }
  949. if (((xData[maskNumber] & 0x1F) == 0) || ((xData[maskNumber] & 0x1F) == 0x1F))
  950. {
  951. if (x > 3)
  952. {
  953. if (xD1Flag[maskNumber])
  954. {
  955. d1[maskNumber]++;
  956. }
  957. else
  958. {
  959. d1[maskNumber] += 3;
  960. xD1Flag[maskNumber] = true;
  961. }
  962. }
  963. }
  964. else
  965. {
  966. xD1Flag[maskNumber] = false;
  967. }
  968. if (((yData[maskNumber] & 0x1F) == 0) || ((yData[maskNumber] & 0x1F) == 0x1F))
  969. {
  970. if (x > 3)
  971. {
  972. if (yD1Flag[maskNumber])
  973. {
  974. d1[maskNumber]++;
  975. }
  976. else
  977. {
  978. d1[maskNumber] += 3;
  979. yD1Flag[maskNumber] = true;
  980. }
  981. }
  982. }
  983. else
  984. {
  985. yD1Flag[maskNumber] = false;
  986. }
  987. }
  988. }
  989. }
  990. int minValue = 0;
  991. sbyte res = 0;
  992. int[] d4Value = new int[]{90, 80, 70, 60, 50, 40, 30, 20, 10, 0, 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 90};
  993. for (int maskNumber = 0; maskNumber < 8; maskNumber++)
  994. {
  996. d4[maskNumber] = d4Value[(int) ((20 * d4Counter[maskNumber]) / maxCodewordsBitWithRemain)];
  998. int demerit = d1[maskNumber] + d2[maskNumber] + d3[maskNumber] + d4[maskNumber];
  1000. if (demerit < minValue || maskNumber == 0)
  1001. {
  1002. res = (sbyte) maskNumber;
  1003. minValue = demerit;
  1004. }
  1005. }
  1006. return res;
  1007. }
  1010.         /// <summary>
  1011.         /// Encode the content using the encoding scheme given
  1012.         /// </summary>
  1013.         /// <param name="content"></param>
  1014.         /// <param name="encoding"></param>
  1015.         /// <returns></returns>
  1016.         public virtual Bitmap Encode(String content, Encoding encoding)
  1017.         {
  1018.             bool[][] matrix = calQrcode(encoding.GetBytes(content));
  1019.             SolidBrush brush = new SolidBrush(qrCodeBackgroundColor);
  1020.             Bitmap image = new Bitmap( (matrix.Length * qrCodeScale) + 1, (matrix.Length * qrCodeScale) + 1);
  1021.             Graphics g = Graphics.FromImage(image);
  1022.             g.FillRectangle(brush, new Rectangle(0, 0, image.Width, image.Height));
  1023.             brush.Color = qrCodeForegroundColor ;
  1024.             for (int i = 0; i < matrix.Length; i++)
  1025.             {
  1026.                 for (int j = 0; j < matrix.Length; j++)
  1027.                 {
  1028.                     if (matrix[j][i])
  1029.                     {
  1030.                         g.FillRectangle(brush, j * qrCodeScale, i * qrCodeScale, qrCodeScale, qrCodeScale);
  1031.                     }
  1032.                 }
  1033.             }
  1034.             return image;
  1035.         }
  1037.         /// <summary>
  1038.         /// Encode the content using the encoding scheme given
  1039.         /// </summary>
  1040.         /// <param name="content"></param>
  1041.         /// <param name="encoding"></param>
  1042.         /// <returns></returns>
  1043.         public virtual Bitmap Encode(String content)
  1044.         {
  1045.             if (QRCodeUtility.IsUniCode(content))
  1046.             {
  1047.                 return Encode(content, Encoding.Unicode);
  1048.             }
  1049.             else
  1050.             {
  1051.                 return Encode(content, Encoding.ASCII);
  1052.             }
  1053.         }
  1055.        
  1056.     }
  1057. }