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

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

电子政务应用

开发平台：

C#

QRCodeDataBlockReader.cs：源码内容
  1. using System;
  2. using QRCodeDecoder = ThoughtWorks.QRCode.Codec.QRCodeDecoder;
  3. using InvalidDataBlockException = ThoughtWorks.QRCode.ExceptionHandler.InvalidDataBlockException;
  4. using DebugCanvas = ThoughtWorks.QRCode.Codec.Util.DebugCanvas;
  5. using SystemUtils = ThoughtWorks.QRCode.Codec.Util.SystemUtils;
  6. namespace ThoughtWorks.QRCode.Codec.Reader
  7. {
  9. public class QRCodeDataBlockReader
  10. {
  11. virtual internal int NextMode
  12. {
  13. get
  14. {
  15. //canvas.println("data blocks:"+ (blocks.length - numErrorCorrectionCode));
  16. if ((blockPointer > blocks.Length - numErrorCorrectionCode - 2))
  17. return 0;
  18. else
  19. return getNextBits(4);
  20. }
  22. }
  23. virtual public sbyte[] DataByte
  24. {
  25. get
  26. {
  27. canvas.println("Reading data blocks.");
  28. System.IO.MemoryStream output = new System.IO.MemoryStream();
  30. try
  31. {
  32. do 
  33. {
  34. int mode = NextMode;
  35. //canvas.println("mode: " + mode);
  36. if (mode == 0)
  37. {
  38. if (output.Length > 0)
  39. break;
  40. else
  41. throw new InvalidDataBlockException("Empty data block");
  42. }
  43. //if (mode != 1 && mode != 2 && mode != 4 && mode != 8)
  44. // break;
  45. //}
  46. if (mode != MODE_NUMBER && mode != MODE_ROMAN_AND_NUMBER && mode != MODE_8BIT_BYTE && mode != MODE_KANJI)
  47. {
  48. /* canvas.println("Invalid mode: " + mode);
  49. mode = guessMode(mode);
  50. canvas.println("Guessed mode: " + mode); */
  51. throw new InvalidDataBlockException("Invalid mode: " + mode + " in (block:" + blockPointer + " bit:" + bitPointer + ")");
  52. }
  53. dataLength = getDataLength(mode);
  54. if (dataLength < 1)
  55. throw new InvalidDataBlockException("Invalid data length: " + dataLength);
  56. //canvas.println("length: " + dataLength);
  57. switch (mode)
  58. {
  60. case MODE_NUMBER: 
  61. //canvas.println("Mode: Figure");
  62. sbyte[] temp_sbyteArray;
  63. temp_sbyteArray = SystemUtils.ToSByteArray(SystemUtils.ToByteArray(getFigureString(dataLength)));
  64. output.Write(SystemUtils.ToByteArray(temp_sbyteArray), 0, temp_sbyteArray.Length);
  65. break;
  67. case MODE_ROMAN_AND_NUMBER: 
  68. //canvas.println("Mode: Roman&Figure");
  69. sbyte[] temp_sbyteArray2;
  70. temp_sbyteArray2 = SystemUtils.ToSByteArray(SystemUtils.ToByteArray(getRomanAndFigureString(dataLength)));
  71. output.Write(SystemUtils.ToByteArray(temp_sbyteArray2), 0, temp_sbyteArray2.Length);
  72. break;
  74. case MODE_8BIT_BYTE: 
  75. //canvas.println("Mode: 8bit Byte");
  76. sbyte[] temp_sbyteArray3;
  77. temp_sbyteArray3 = get8bitByteArray(dataLength);
  78. output.Write(SystemUtils.ToByteArray(temp_sbyteArray3), 0, temp_sbyteArray3.Length);
  79. break;
  81. case MODE_KANJI: 
  82. //canvas.println("Mode: Kanji");
  83. sbyte[] temp_sbyteArray4;
  84. temp_sbyteArray4 = SystemUtils.ToSByteArray(SystemUtils.ToByteArray(getKanjiString(dataLength)));
  85. output.Write(SystemUtils.ToByteArray(temp_sbyteArray4), 0, temp_sbyteArray4.Length);
  86. break;
  87. }
  88. //
  89. //canvas.println("DataLength: " + dataLength);
  90. //Console.out.println(dataString);
  91. }
  92. while (true);
  93. }
  94. catch (System.IndexOutOfRangeException e)
  95. {
  96. SystemUtils.WriteStackTrace(e, Console.Error);
  97. throw new InvalidDataBlockException("Data Block Error in (block:" + blockPointer + " bit:" + bitPointer + ")");
  98. }
  99. catch (System.IO.IOException e)
  100. {
  101. throw new InvalidDataBlockException(e.Message);
  102. }
  103. return SystemUtils.ToSByteArray(output.ToArray());
  104. }
  106. }
  107. virtual public String DataString
  108. {
  109. get
  110. {
  111. canvas.println("Reading data blocks...");
  112. String dataString = "";
  113. do 
  114. {
  115. int mode = NextMode;
  116. canvas.println("mode: " + mode);
  117. if (mode == 0)
  118. break;
  119. //if (mode != 1 && mode != 2 && mode != 4 && mode != 8)
  120. // break;
  121. //}
  122. if (mode != MODE_NUMBER && mode != MODE_ROMAN_AND_NUMBER && mode != MODE_8BIT_BYTE && mode != MODE_KANJI)
  123. {
  124. // mode = guessMode(mode);
  125. // do not guesswork
  126. //Console.out.println("guessed mode: " + mode);
  127. }
  129. dataLength = getDataLength(mode);
  130. canvas.println(System.Convert.ToString(blocks[blockPointer]));
  131. System.Console.Out.WriteLine("length: " + dataLength);
  132. switch (mode)
  133. {
  135. case MODE_NUMBER: 
  136. //canvas.println("Mode: Figure");
  137. dataString += getFigureString(dataLength);
  138. break;
  140. case MODE_ROMAN_AND_NUMBER: 
  141. //canvas.println("Mode: Roman&Figure");
  142. dataString += getRomanAndFigureString(dataLength);
  143. break;
  145. case MODE_8BIT_BYTE: 
  146. //canvas.println("Mode: 8bit Byte");
  147. dataString += get8bitByteString(dataLength);
  148. break;
  150. case MODE_KANJI: 
  151. //canvas.println("Mode: Kanji");
  152. dataString += getKanjiString(dataLength);
  153. break;
  154. }
  155. //canvas.println("DataLength: " + dataLength);
  156. //Console.out.println(dataString);
  157. }
  158. while (true);
  159. System.Console.Out.WriteLine("");
  160. return dataString;
  161. }
  163. }
  164. internal int[] blocks;
  165. internal int dataLengthMode;
  166. internal int blockPointer;
  167. internal int bitPointer;
  168. internal int dataLength;
  169. internal int numErrorCorrectionCode;
  170. internal DebugCanvas canvas;
  172. const  int MODE_NUMBER = 1;
  173.     const int MODE_ROMAN_AND_NUMBER = 2;
  174.     const int MODE_8BIT_BYTE = 4;
  175.     const int MODE_KANJI = 8;
  176.     int[][] sizeOfDataLengthInfo = new int[][] { new int[] { 10, 9, 8, 8 }, new int[] { 12, 11, 16, 10 }, new int[] { 14, 13, 16, 12 } };
  178. public QRCodeDataBlockReader(int[] blocks, int version, int numErrorCorrectionCode)
  179. {
  180. blockPointer = 0;
  181. bitPointer = 7;
  182. dataLength = 0;
  183. this.blocks = blocks;
  184. this.numErrorCorrectionCode = numErrorCorrectionCode;
  185. if (version <= 9)
  186. dataLengthMode = 0;
  187. else if (version >= 10 && version <= 26)
  188. dataLengthMode = 1;
  189. else if (version >= 27 && version <= 40)
  190. dataLengthMode = 2;
  191. canvas = QRCodeDecoder.Canvas;
  192. }
  194. internal virtual int getNextBits(int numBits)
  195. {
  196. int bits = 0;
  197. if (numBits < bitPointer + 1)
  198. {
  199. // next word fits into current data block
  200. int mask = 0;
  201. for (int i = 0; i < numBits; i++)
  202. {
  203. mask += (1 << i);
  204. }
  205. mask <<= (bitPointer - numBits + 1);
  207. bits = (blocks[blockPointer] & mask) >> (bitPointer - numBits + 1);
  208. bitPointer -= numBits;
  209. return bits;
  210. }
  211. else if (numBits < bitPointer + 1 + 8)
  212. {
  213. // next word crosses 2 data blocks
  214. int mask1 = 0;
  215. for (int i = 0; i < bitPointer + 1; i++)
  216. {
  217. mask1 += (1 << i);
  218. }
  219. bits = (blocks[blockPointer] & mask1) << (numBits - (bitPointer + 1));
  220.                 blockPointer++;
  221. bits += ((blocks[blockPointer]) >> (8 - (numBits - (bitPointer + 1))));
  223. bitPointer = bitPointer - numBits % 8;
  224. if (bitPointer < 0)
  225. {
  226. bitPointer = 8 + bitPointer;
  227. }
  228. return bits;
  229. }
  230. else if (numBits < bitPointer + 1 + 16)
  231. {
  232. // next word crosses 3 data blocks
  233. int mask1 = 0; // mask of first block
  234. int mask3 = 0; // mask of 3rd block
  235. //bitPointer + 1 : number of bits of the 1st block
  236. //8 : number of the 2nd block (note that use already 8bits because next word uses 3 data blocks)
  237. //numBits - (bitPointer + 1 + 8) : number of bits of the 3rd block 
  238. for (int i = 0; i < bitPointer + 1; i++)
  239. {
  240. mask1 += (1 << i);
  241. }
  242. int bitsFirstBlock = (blocks[blockPointer] & mask1) << (numBits - (bitPointer + 1));
  243. blockPointer++;
  245. int bitsSecondBlock = blocks[blockPointer] << (numBits - (bitPointer + 1 + 8));
  246. blockPointer++;
  248. for (int i = 0; i < numBits - (bitPointer + 1 + 8); i++)
  249. {
  250. mask3 += (1 << i);
  251. }
  252. mask3 <<= 8 - (numBits - (bitPointer + 1 + 8));
  253. int bitsThirdBlock = (blocks[blockPointer] & mask3) >> (8 - (numBits - (bitPointer + 1 + 8)));
  255. bits = bitsFirstBlock + bitsSecondBlock + bitsThirdBlock;
  256. bitPointer = bitPointer - (numBits - 8) % 8;
  257. if (bitPointer < 0)
  258. {
  259. bitPointer = 8 + bitPointer;
  260. }
  261. return bits;
  262. }
  263. else
  264. {
  265. System.Console.Out.WriteLine("ERROR!");
  266. return 0;
  267. }
  268. }
  270. internal virtual int guessMode(int mode)
  271. {
  272. //correct modes: 0001 0010 0100 1000
  273. //possible data: 0000 0011 0101 1001 0110 1010 1100
  274. //               0111 1101 1011 1110 1111
  275. // MODE_NUMBER = 1;
  276. // MODE_ROMAN_AND_NUMBER = 2;
  277. // MODE_8BIT_BYTE = 4;
  278. // MODE_KANJI = 8;
  279. switch (mode)
  280. {
  282. case 3: 
  283. return MODE_NUMBER;
  285. case 5: 
  286. return MODE_8BIT_BYTE;
  288. case 6: 
  289. return MODE_8BIT_BYTE;
  291. case 7: 
  292. return MODE_8BIT_BYTE;
  294. case 9: 
  295. return MODE_KANJI;
  297. case 10: 
  298. return MODE_KANJI;
  300. case 11: 
  301. return MODE_KANJI;
  303. case 12: 
  304. return MODE_8BIT_BYTE;
  306. case 13: 
  307. return MODE_8BIT_BYTE;
  309. case 14: 
  310. return MODE_8BIT_BYTE;
  312. case 15: 
  313. return MODE_8BIT_BYTE;
  315. default: 
  316. return MODE_KANJI;
  318. }
  319. }
  321. internal virtual int getDataLength(int modeIndicator)
  322. {
  323. int index = 0;
  324. while (true)
  325. {
  326. if ((modeIndicator >> index) == 1)
  327. break;
  328. index++;
  329. }
  331. return getNextBits(sizeOfDataLengthInfo[dataLengthMode][index]);
  332. }
  335. internal virtual String getFigureString(int dataLength)
  336. {
  337. int length = dataLength;
  338. int intData = 0;
  339. String strData = "";
  340. do 
  341. {
  342. if (length >= 3)
  343. {
  344. intData = getNextBits(10);
  345. if (intData < 100)
  346. strData += "0";
  347. if (intData < 10)
  348. strData += "0";
  349. length -= 3;
  350. }
  351. else if (length == 2)
  352. {
  353. intData = getNextBits(7);
  354. if (intData < 10)
  355. strData += "0";
  356. length -= 2;
  357. }
  358. else if (length == 1)
  359. {
  360. intData = getNextBits(4);
  361. length -= 1;
  362. }
  363. strData += System.Convert.ToString(intData);
  364. }
  365. while (length > 0);
  367. return strData;
  368. }
  370. internal virtual String getRomanAndFigureString(int dataLength)
  371. {
  372. int length = dataLength;
  373. int intData = 0;
  374. String strData = "";
  375. char[] tableRomanAndFigure = new char[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', ' ', '$', '%', '*', '+', '-', '.', '/', ':'};
  376. do 
  377. {
  378. if (length > 1)
  379. {
  380. intData = getNextBits(11);
  381. int firstLetter = intData / 45;
  382. int secondLetter = intData % 45;
  383. strData += System.Convert.ToString(tableRomanAndFigure[firstLetter]);
  384. strData += System.Convert.ToString(tableRomanAndFigure[secondLetter]);
  385. length -= 2;
  386. }
  387. else if (length == 1)
  388. {
  389. intData = getNextBits(6);
  390. strData += System.Convert.ToString(tableRomanAndFigure[intData]);
  391. length -= 1;
  392. }
  393. }
  394. while (length > 0);
  396. return strData;
  397. }
  399. public virtual sbyte[] get8bitByteArray(int dataLength)
  400. {
  401. int length = dataLength;
  402. int intData = 0;
  403. System.IO.MemoryStream output = new System.IO.MemoryStream();
  405. do 
  406. {
  407.                 canvas.println("Length: " + length);
  408. intData = getNextBits(8);
  409. output.WriteByte((byte) intData);
  410. length--;
  411. }
  412. while (length > 0);
  413. return SystemUtils.ToSByteArray(output.ToArray());
  414. }
  416. internal virtual String get8bitByteString(int dataLength)
  417. {
  418. int length = dataLength;
  419. int intData = 0;
  420. String strData = "";
  421. do 
  422. {
  423. intData = getNextBits(8);
  424. strData += (char) intData;
  425. length--;
  426. }
  427. while (length > 0);
  428. return strData;
  429. }
  431. internal virtual String getKanjiString(int dataLength)
  432. {
  433. int length = dataLength;
  434. int intData = 0;
  435. String unicodeString = "";
  436. do 
  437. {
  438. intData = getNextBits(13);
  439. int lowerByte = intData % 0xC0;
  440. int higherByte = intData / 0xC0;
  442. int tempWord = (higherByte << 8) + lowerByte;
  443. int shiftjisWord = 0;
  444. if (tempWord + 0x8140 <= 0x9FFC)
  445. {
  446. // between 8140 - 9FFC on Shift_JIS character set
  447. shiftjisWord = tempWord + 0x8140;
  448. }
  449. else
  450. {
  451. // between E040 - EBBF on Shift_JIS character set
  452. shiftjisWord = tempWord + 0xC140;
  453. }
  455. sbyte[] tempByte = new sbyte[2];
  456. tempByte[0] = (sbyte) (shiftjisWord >> 8);
  457. tempByte[1] = (sbyte) (shiftjisWord & 0xFF);
  458. unicodeString += new String(SystemUtils.ToCharArray(SystemUtils.ToByteArray(tempByte)));
  459. length--;
  460. }
  461. while (length > 0);
  464. return unicodeString;
  465. }
  466. }
  467. }