rhodes 5.5.15 → 5.5.17

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/qrcode/Version.h

@@ -0,0 +1,86 @@
+#ifndef __VERSION_H__
+#define __VERSION_H__
+
+/*
+ *  Version.h
+ *  zxing
+ *
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/common/Counted.h>
+#include <zxing/qrcode/ErrorCorrectionLevel.h>
+#include <zxing/ReaderException.h>
+#include <zxing/common/BitMatrix.h>
+#include <zxing/common/Counted.h>
+#include <vector>
+
+namespace zxing {
+namespace qrcode {
+
+class ECB {
+private:
+  int count_;
+  int dataCodewords_;
+public:
+  ECB(int count, int dataCodewords);
+  int getCount();
+  int getDataCodewords();
+};
+
+class ECBlocks {
+private:
+  int ecCodewordsPerBloc_;
+  std::vector<ECB*> ecBlocks_;
+public:
+  ECBlocks(int ecCodewordsPerBloc, ECB *ecBlocks);
+  ECBlocks(int ecCodewordsPerBloc, ECB *ecBlocks1, ECB *ecBlocks2);
+  int getECCodewordsPerBloc();
+  int getTotalECCodewords();
+  std::vector<ECB*>& getECBlocks();
+  ~ECBlocks();
+};
+
+class Version : public Counted {
+
+private:
+  int versionNumber_;
+  std::vector<int> &alignmentPatternCenters_;
+  std::vector<ECBlocks*> ecBlocks_;
+  int totalCodewords_;
+  Version(int versionNumber, std::vector<int> *alignmentPatternCenters, ECBlocks *ecBlocks1, ECBlocks *ecBlocks2,
+          ECBlocks *ecBlocks3, ECBlocks *ecBlocks4);
+
+public:
+  static unsigned int VERSION_DECODE_INFO[];
+  static int N_VERSION_DECODE_INFOS;
+  static std::vector<Ref<Version> > VERSIONS;
+
+  ~Version();
+  int getVersionNumber() const;
+  std::vector<int> &getAlignmentPatternCenters();
+  int getTotalCodewords();
+  int getDimensionForVersion();
+  ECBlocks &getECBlocksForLevel(const ErrorCorrectionLevel &ecLevel) const;
+  static Ref<Version> getProvisionalVersionForDimension(int dimension);
+  static Ref<Version> getVersionForNumber(int versionNumber);
+  static Ref<Version> decodeVersionInformation(unsigned int versionBits);
+  Ref<BitMatrix> buildFunctionPattern();
+  static int buildVersions();
+};
+}
+}
+
+#endif // __VERSION_H__

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/qrcode/decoder/BitMatrixParser.h

@@ -0,0 +1,56 @@
+#ifndef __BIT_MATRIX_PARSER_H__
+#define __BIT_MATRIX_PARSER_H__
+
+/*
+ *  BitMatrixParser.h
+ *  zxing
+ *
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/ReaderException.h>
+#include <zxing/common/BitMatrix.h>
+#include <zxing/common/Counted.h>
+#include <zxing/common/Array.h>
+#include <zxing/qrcode/Version.h>
+#include <zxing/qrcode/FormatInformation.h>
+
+namespace zxing {
+namespace qrcode {
+
+class BitMatrixParser : public Counted {
+private:
+  Ref<BitMatrix> bitMatrix_;
+  Version *parsedVersion_;
+  Ref<FormatInformation> parsedFormatInfo_;
+
+  int copyBit(size_t x, size_t y, int versionBits);
+
+public:
+  BitMatrixParser(Ref<BitMatrix> bitMatrix);
+  Ref<FormatInformation> readFormatInformation();
+  Version *readVersion();
+  ArrayRef<char> readCodewords();
+
+private:
+  BitMatrixParser(const BitMatrixParser&);
+  BitMatrixParser& operator =(const BitMatrixParser&);
+  
+};
+
+}
+}
+
+#endif // __BIT_MATRIX_PARSER_H__

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/qrcode/decoder/DataBlock.h

@@ -0,0 +1,50 @@
+#ifndef __DATA_BLOCK_H__
+#define __DATA_BLOCK_H__
+
+/*
+ *  DataBlock.h
+ *  zxing
+ *
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <vector>
+#include <zxing/common/Counted.h>
+#include <zxing/common/Array.h>
+#include <zxing/qrcode/Version.h>
+#include <zxing/qrcode/ErrorCorrectionLevel.h>
+
+namespace zxing {
+namespace qrcode {
+
+class DataBlock : public Counted {
+private:
+  int numDataCodewords_;
+  ArrayRef<char> codewords_;
+
+  DataBlock(int numDataCodewords, ArrayRef<char> codewords);
+
+public:
+  static std::vector<Ref<DataBlock> >
+  getDataBlocks(ArrayRef<char> rawCodewords, Version *version, ErrorCorrectionLevel &ecLevel);
+
+  int getNumDataCodewords();
+  ArrayRef<char> getCodewords();
+};
+
+}
+}
+
+#endif // __DATA_BLOCK_H__

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/qrcode/decoder/DataMask.h

@@ -0,0 +1,50 @@
+#ifndef __DATA_MASK_H__
+#define __DATA_MASK_H__
+
+/*
+ *  DataMask.h
+ *  zxing
+ *
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/common/Array.h>
+#include <zxing/common/Counted.h>
+#include <zxing/common/BitMatrix.h>
+
+#include <vector>
+
+namespace zxing {
+namespace qrcode {
+
+class DataMask : public Counted {
+private:
+  static std::vector<Ref<DataMask> > DATA_MASKS;
+
+protected:
+
+public:
+  static int buildDataMasks();
+  DataMask();
+  virtual ~DataMask();
+  void unmaskBitMatrix(BitMatrix& matrix, size_t dimension);
+  virtual bool isMasked(size_t x, size_t y) = 0;
+  static DataMask& forReference(int reference);
+};
+
+}
+}
+
+#endif // __DATA_MASK_H__

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/qrcode/decoder/DecodedBitStreamParser.h

@@ -0,0 +1,72 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+
+#ifndef __DECODED_BIT_STREAM_PARSER_H__
+#define __DECODED_BIT_STREAM_PARSER_H__
+
+/*
+ *  DecodedBitStreamParser.h
+ *  zxing
+ *
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <string>
+#include <sstream>
+#include <map>
+#include <zxing/qrcode/decoder/Mode.h>
+#include <zxing/common/BitSource.h>
+#include <zxing/common/Counted.h>
+#include <zxing/common/Array.h>
+#include <zxing/common/DecoderResult.h>
+#include <zxing/common/CharacterSetECI.h>
+#include <zxing/DecodeHints.h>
+
+namespace zxing {
+namespace qrcode {
+
+class DecodedBitStreamParser {
+public:
+  typedef std::map<DecodeHintType, std::string> Hashtable;
+
+private:
+  static char const ALPHANUMERIC_CHARS[];
+  static char toAlphaNumericChar(size_t value);
+
+  static void decodeHanziSegment(Ref<BitSource> bits, std::string &result, int count);
+  static void decodeKanjiSegment(Ref<BitSource> bits, std::string &result, int count);
+  static void decodeByteSegment(Ref<BitSource> bits, std::string &result, int count);
+  static std::string decodeByteSegment(Ref<BitSource> bits_,
+                                std::string& result,
+                                int count,
+                                zxing::common::CharacterSetECI* currentCharacterSetECI,
+                                ArrayRef< ArrayRef<char> >& byteSegments,
+                                Hashtable const& hints);
+  static void decodeAlphanumericSegment(Ref<BitSource> bits, std::string &result, int count, bool fc1InEffect);
+  static void decodeNumericSegment(Ref<BitSource> bits, std::string &result, int count);
+
+  static void append(std::string &ost, const char *bufIn, size_t nIn, const char *src);
+  static void append(std::string &ost, std::string const& in, const char *src);
+
+public:
+  static Ref<DecoderResult> decode(ArrayRef<char> bytes,
+                                   Version *version,
+                                   ErrorCorrectionLevel const& ecLevel,
+                                   Hashtable const& hints);
+};
+
+}
+}
+
+#endif // __DECODED_BIT_STREAM_PARSER_H__

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/qrcode/decoder/Decoder.h

@@ -0,0 +1,46 @@
+#ifndef __DECODER_H__
+#define __DECODER_H__
+
+/*
+ *  Decoder.h
+ *  zxing
+ *
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/common/reedsolomon/ReedSolomonDecoder.h>
+#include <zxing/common/Counted.h>
+#include <zxing/common/Array.h>
+#include <zxing/common/DecoderResult.h>
+#include <zxing/common/BitMatrix.h>
+
+namespace zxing {
+namespace qrcode {
+
+class Decoder {
+private:
+  ReedSolomonDecoder rsDecoder_;
+
+  void correctErrors(ArrayRef<char> bytes, int numDataCodewords);
+
+public:
+  Decoder();
+  Ref<DecoderResult> decode(Ref<BitMatrix> bits);
+};
+
+}
+}
+
+#endif // __DECODER_H__

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/qrcode/decoder/Mode.h

@@ -0,0 +1,68 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __MODE_H__
+#define __MODE_H__
+
+/*
+ *  Mode.h
+ *  zxing
+ *
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/common/Counted.h>
+#include <zxing/qrcode/Version.h>
+#include <zxing/common/Counted.h>
+
+namespace zxing {
+namespace qrcode {
+
+class Mode : public Counted
+{
+private:
+  int characterCountBitsForVersions0To9_;
+  int characterCountBitsForVersions10To26_;
+  int characterCountBitsForVersions27AndHigher_;
+  int bits_;
+  std::string name_;
+
+  Mode(int cbv0_9, int cbv10_26, int cbv27, int bits, char const* name);
+
+public:
+  Mode(const Mode& mode);
+  Mode();
+
+  static Mode TERMINATOR;
+  static Mode NUMERIC;
+  static Mode ALPHANUMERIC;
+  static Mode STRUCTURED_APPEND;
+  static Mode BYTE;
+  static Mode ECI;
+  static Mode KANJI;
+  static Mode FNC1_FIRST_POSITION;
+  static Mode FNC1_SECOND_POSITION;
+  static Mode HANZI;
+
+  static Mode& forBits(int bits);
+  int getCharacterCountBits(const Version *version) const;
+  int getBits() const { return bits_; }
+
+  bool operator==(const Mode& other);
+
+  std::string getName() const { return name_; }
+};
+}
+}
+
+#endif // __MODE_H__

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/qrcode/decoder/QRBitMatrixParser.cpp

@@ -0,0 +1,183 @@
+/*
+ *  BitMatrixParser.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 20/05/2008.
+ *  Copyright 2008 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/qrcode/decoder/BitMatrixParser.h>
+#include <zxing/qrcode/decoder/DataMask.h>
+
+
+namespace zxing {
+namespace qrcode {
+
+int BitMatrixParser::copyBit(size_t x, size_t y, int versionBits) {
+  return bitMatrix_->get(x, y) ? (versionBits << 1) | 0x1 : versionBits << 1;
+}
+
+BitMatrixParser::BitMatrixParser(Ref<BitMatrix> bitMatrix) :
+    bitMatrix_(bitMatrix), parsedVersion_(0), parsedFormatInfo_() {
+  size_t dimension = bitMatrix->getHeight();
+  if ((dimension < 21) || (dimension & 0x03) != 1) {
+    throw ReaderException("Dimension must be 1 mod 4 and >= 21");
+  }
+}
+
+Ref<FormatInformation> BitMatrixParser::readFormatInformation() {
+  if (parsedFormatInfo_ != 0) {
+    return parsedFormatInfo_;
+  }
+
+  // Read top-left format info bits
+  int formatInfoBits1 = 0;
+  for (int i = 0; i < 6; i++) {
+    formatInfoBits1 = copyBit(i, 8, formatInfoBits1);
+  }
+  // .. and skip a bit in the timing pattern ...
+  formatInfoBits1 = copyBit(7, 8, formatInfoBits1);
+  formatInfoBits1 = copyBit(8, 8, formatInfoBits1);
+  formatInfoBits1 = copyBit(8, 7, formatInfoBits1);
+  // .. and skip a bit in the timing pattern ...
+  for (int j = 5; j >= 0; j--) {
+    formatInfoBits1 = copyBit(8, j, formatInfoBits1);
+  }
+
+  // Read the top-right/bottom-left pattern
+  int dimension = bitMatrix_->getHeight();
+  int formatInfoBits2 = 0;
+  int jMin = dimension - 7;
+  for (int j = dimension - 1; j >= jMin; j--) {
+    formatInfoBits2 = copyBit(8, j, formatInfoBits2);
+  }
+  for (int i = dimension - 8; i < dimension; i++) {
+    formatInfoBits2 = copyBit(i, 8, formatInfoBits2);
+  }
+
+  parsedFormatInfo_ = FormatInformation::decodeFormatInformation(formatInfoBits1,formatInfoBits2);
+  if (parsedFormatInfo_ != 0) {
+    return parsedFormatInfo_;
+  }
+  throw ReaderException("Could not decode format information");
+}
+
+Version *BitMatrixParser::readVersion() {
+  if (parsedVersion_ != 0) {
+    return parsedVersion_;
+  }
+
+  int dimension = bitMatrix_->getHeight();
+
+  int provisionalVersion = (dimension - 17) >> 2;
+  if (provisionalVersion <= 6) {
+    return Version::getVersionForNumber(provisionalVersion);
+  }
+
+  // Read top-right version info: 3 wide by 6 tall
+  int versionBits = 0;
+  for (int y = 5; y >= 0; y--) {
+    int xMin = dimension - 11;
+    for (int x = dimension - 9; x >= xMin; x--) {
+      versionBits = copyBit(x, y, versionBits);
+    }
+  }
+
+  parsedVersion_ = Version::decodeVersionInformation(versionBits);
+  if (parsedVersion_ != 0 && parsedVersion_->getDimensionForVersion() == dimension) {
+    return parsedVersion_;
+  }
+
+  // Hmm, failed. Try bottom left: 6 wide by 3 tall
+  versionBits = 0;
+  for (int x = 5; x >= 0; x--) {
+    int yMin = dimension - 11;
+    for (int y = dimension - 9; y >= yMin; y--) {
+      versionBits = copyBit(x, y, versionBits);
+    }
+  }
+
+  parsedVersion_ = Version::decodeVersionInformation(versionBits);
+  if (parsedVersion_ != 0 && parsedVersion_->getDimensionForVersion() == dimension) {
+    return parsedVersion_;
+  }
+  throw ReaderException("Could not decode version");
+}
+
+ArrayRef<char> BitMatrixParser::readCodewords() {
+  Ref<FormatInformation> formatInfo = readFormatInformation();
+  Version *version = readVersion();
+
+
+  // Get the data mask for the format used in this QR Code. This will exclude
+  // some bits from reading as we wind through the bit matrix.
+  DataMask &dataMask = DataMask::forReference((int)formatInfo->getDataMask());
+  //	cout << (int)formatInfo->getDataMask() << endl;
+  int dimension = bitMatrix_->getHeight();
+  dataMask.unmaskBitMatrix(*bitMatrix_, dimension);
+
+
+  //		cerr << *bitMatrix_ << endl;
+  //	cerr << version->getTotalCodewords() << endl;
+
+  Ref<BitMatrix> functionPattern = version->buildFunctionPattern();
+
+
+  //	cout << *functionPattern << endl;
+
+  bool readingUp = true;
+  ArrayRef<char> result(version->getTotalCodewords());
+  int resultOffset = 0;
+  int currentByte = 0;
+  int bitsRead = 0;
+  // Read columns in pairs, from right to left
+  for (int x = dimension - 1; x > 0; x -= 2) {
+    if (x == 6) {
+      // Skip whole column with vertical alignment pattern;
+      // saves time and makes the other code proceed more cleanly
+      x--;
+    }
+    // Read alternatingly from bottom to top then top to bottom
+    for (int counter = 0; counter < dimension; counter++) {
+      int y = readingUp ? dimension - 1 - counter : counter;
+      for (int col = 0; col < 2; col++) {
+        // Ignore bits covered by the function pattern
+        if (!functionPattern->get(x - col, y)) {
+          // Read a bit
+          bitsRead++;
+          currentByte <<= 1;
+          if (bitMatrix_->get(x - col, y)) {
+            currentByte |= 1;
+          }
+          // If we've made a whole byte, save it off
+          if (bitsRead == 8) {
+            result[resultOffset++] = (char)currentByte;
+            bitsRead = 0;
+            currentByte = 0;
+          }
+        }
+      }
+    }
+    readingUp = !readingUp; // switch directions
+  }
+
+  if (resultOffset != version->getTotalCodewords()) {
+    throw ReaderException("Did not read all codewords");
+  }
+  return result;
+}
+
+}
+}