zxing_cpp 0.1.0

data/ext/zxing/zxing-cpp/core/src/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 void 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/ext/zxing/zxing-cpp/core/src/zxing/qrcode/decoder/Decoder.cpp

@@ -0,0 +1,107 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  Decoder.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/Decoder.h>
+#include <zxing/qrcode/decoder/BitMatrixParser.h>
+#include <zxing/qrcode/ErrorCorrectionLevel.h>
+#include <zxing/qrcode/Version.h>
+#include <zxing/qrcode/decoder/DataBlock.h>
+#include <zxing/qrcode/decoder/DecodedBitStreamParser.h>
+#include <zxing/ReaderException.h>
+#include <zxing/ChecksumException.h>
+#include <zxing/common/reedsolomon/ReedSolomonException.h>
+
+using zxing::qrcode::Decoder;
+using zxing::DecoderResult;
+using zxing::Ref;
+
+// VC++
+using zxing::ArrayRef;
+using zxing::BitMatrix;
+
+Decoder::Decoder() :
+  rsDecoder_(GenericGF::QR_CODE_FIELD_256) {
+}
+
+void Decoder::correctErrors(ArrayRef<char> codewordBytes, int numDataCodewords) {
+  int numCodewords = codewordBytes->size();
+  ArrayRef<int> codewordInts(numCodewords);
+  for (int i = 0; i < numCodewords; i++) {
+    codewordInts[i] = codewordBytes[i] & 0xff;
+  }
+  int numECCodewords = numCodewords - numDataCodewords;
+
+  try {
+    rsDecoder_.decode(codewordInts, numECCodewords);
+  } catch (ReedSolomonException const& ignored) {
+    (void)ignored;
+    throw ChecksumException();
+  }
+
+  for (int i = 0; i < numDataCodewords; i++) {
+    codewordBytes[i] = (char)codewordInts[i];
+  }
+}
+
+Ref<DecoderResult> Decoder::decode(Ref<BitMatrix> bits) {
+  // Construct a parser and read version, error-correction level
+  BitMatrixParser parser(bits);
+
+  // std::cerr << *bits << std::endl;
+
+  Version *version = parser.readVersion();
+  ErrorCorrectionLevel &ecLevel = parser.readFormatInformation()->getErrorCorrectionLevel();
+
+
+  // Read codewords
+  ArrayRef<char> codewords(parser.readCodewords());
+
+
+  // Separate into data blocks
+  std::vector<Ref<DataBlock> > dataBlocks(DataBlock::getDataBlocks(codewords, version, ecLevel));
+
+
+  // Count total number of data bytes
+  int totalBytes = 0;
+  for (size_t i = 0; i < dataBlocks.size(); i++) {
+    totalBytes += dataBlocks[i]->getNumDataCodewords();
+  }
+  ArrayRef<char> resultBytes(totalBytes);
+  int resultOffset = 0;
+
+
+  // Error-correct and copy data blocks together into a stream of bytes
+  for (size_t j = 0; j < dataBlocks.size(); j++) {
+    Ref<DataBlock> dataBlock(dataBlocks[j]);
+    ArrayRef<char> codewordBytes = dataBlock->getCodewords();
+    int numDataCodewords = dataBlock->getNumDataCodewords();
+    correctErrors(codewordBytes, numDataCodewords);
+    for (int i = 0; i < numDataCodewords; i++) {
+      resultBytes[resultOffset++] = codewordBytes[i];
+    }
+  }
+
+  return DecodedBitStreamParser::decode(resultBytes,
+                                        version,
+                                        ecLevel,
+                                        DecodedBitStreamParser::Hashtable());
+}
+

data/ext/zxing/zxing-cpp/core/src/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/ext/zxing/zxing-cpp/core/src/zxing/qrcode/decoder/Mode.cpp

@@ -0,0 +1,90 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  Mode.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 19/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/ZXing.h>
+#include <zxing/qrcode/decoder/Mode.h>
+#include <zxing/common/Counted.h>
+#include <zxing/ReaderException.h>
+#include <zxing/qrcode/Version.h>
+#include <sstream>
+
+using zxing::qrcode::Mode;
+using std::ostringstream;
+
+// VC++
+using zxing::qrcode::Version;
+
+Mode Mode::TERMINATOR(0, 0, 0, 0x00, "TERMINATOR");
+Mode Mode::NUMERIC(10, 12, 14, 0x01, "NUMERIC");
+Mode Mode::ALPHANUMERIC(9, 11, 13, 0x02, "ALPHANUMERIC");
+Mode Mode::STRUCTURED_APPEND(0, 0, 0, 0x03, "STRUCTURED_APPEND");
+Mode Mode::BYTE(8, 16, 16, 0x04, "BYTE");
+Mode Mode::ECI(0, 0, 0, 0x07, "ECI");
+Mode Mode::KANJI(8, 10, 12, 0x08, "KANJI");
+Mode Mode::FNC1_FIRST_POSITION(0, 0, 0, 0x05, "FNC1_FIRST_POSITION");
+Mode Mode::FNC1_SECOND_POSITION(0, 0, 0, 0x09, "FNC1_SECOND_POSITION");
+Mode Mode::HANZI(8, 10, 12, 0x0D, "HANZI");
+
+Mode::Mode(int cbv0_9, int cbv10_26, int cbv27, int /* bits */, char const* name) :
+  characterCountBitsForVersions0To9_(cbv0_9), characterCountBitsForVersions10To26_(cbv10_26),
+  characterCountBitsForVersions27AndHigher_(cbv27), name_(name) {
+}
+
+Mode& Mode::forBits(int bits) {
+  switch (bits) {
+  case 0x0:
+    return TERMINATOR;
+  case 0x1:
+    return NUMERIC;
+  case 0x2:
+    return ALPHANUMERIC;
+  case 0x3:
+    return STRUCTURED_APPEND;
+  case 0x4:
+    return BYTE;
+  case 0x5:
+    return FNC1_FIRST_POSITION;
+  case 0x7:
+    return ECI;
+  case 0x8:
+    return KANJI;
+  case 0x9:
+    return FNC1_SECOND_POSITION;
+  case 0xD:
+    // 0xD is defined in GBT 18284-2000, may not be supported in foreign country
+    return HANZI;
+  default:
+    ostringstream s;
+    s << "Illegal mode bits: " << bits;
+    throw ReaderException(s.str().c_str());
+  }
+}
+
+int Mode::getCharacterCountBits(Version *version) {
+  int number = version->getVersionNumber();
+  if (number <= 9) {
+    return characterCountBitsForVersions0To9_;
+  } else if (number <= 26) {
+    return characterCountBitsForVersions10To26_;
+  } else {
+    return characterCountBitsForVersions27AndHigher_;
+  }
+}

data/ext/zxing/zxing-cpp/core/src/zxing/qrcode/decoder/Mode.h

@@ -0,0 +1,57 @@
+// -*- 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>
+
+namespace zxing {
+namespace qrcode {
+
+class Mode {
+private:
+  int characterCountBitsForVersions0To9_;
+  int characterCountBitsForVersions10To26_;
+  int characterCountBitsForVersions27AndHigher_;
+  std::string name_;
+
+  Mode(int cbv0_9, int cbv10_26, int cbv27, int bits, char const* name);
+
+public:
+  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(Version *version);
+};
+}
+}
+
+#endif // __MODE_H__

data/ext/zxing/zxing-cpp/core/src/zxing/qrcode/detector/AlignmentPattern.cpp

@@ -0,0 +1,47 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  AlignmentPattern.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 13/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/detector/AlignmentPattern.h>
+
+using std::abs;
+using zxing::Ref;
+using zxing::qrcode::AlignmentPattern;
+
+AlignmentPattern::AlignmentPattern(float posX, float posY, float estimatedModuleSize) :
+    ResultPoint(posX,posY), estimatedModuleSize_(estimatedModuleSize) {
+}
+
+bool AlignmentPattern::aboutEquals(float moduleSize, float i, float j) const {
+  if (abs(i - getY()) <= moduleSize && abs(j - getX()) <= moduleSize) {
+    float moduleSizeDiff = abs(moduleSize - estimatedModuleSize_);
+    return moduleSizeDiff <= 1.0f || moduleSizeDiff <= estimatedModuleSize_;
+  }
+  return false;
+}
+
+Ref<AlignmentPattern> AlignmentPattern::combineEstimate(float i, float j, float newModuleSize) const {
+  float combinedX = (getX() + j) / 2.0f;
+  float combinedY = (getY() + i) / 2.0f;
+  float combinedModuleSize = (estimatedModuleSize_ + newModuleSize) / 2.0f;
+  Ref<AlignmentPattern> result
+      (new AlignmentPattern(combinedX, combinedY, combinedModuleSize));
+  return result;
+}

data/ext/zxing/zxing-cpp/core/src/zxing/qrcode/detector/AlignmentPattern.h

@@ -0,0 +1,45 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+
+#ifndef __ALIGNMENT_PATTERN_H__
+#define __ALIGNMENT_PATTERN_H__
+
+/*
+ *  AlignmentPattern.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/ResultPoint.h>
+#include <cmath>
+
+namespace zxing {
+	namespace qrcode {
+		
+		class AlignmentPattern : public ResultPoint {
+		private:
+			float estimatedModuleSize_;
+			
+		public:
+			AlignmentPattern(float posX, float posY, float estimatedModuleSize);
+			bool aboutEquals(float moduleSize, float i, float j) const;
+      Ref<AlignmentPattern> combineEstimate(float i, float j,
+                                            float newModuleSize) const;
+		};
+		
+	}
+}
+
+#endif // __ALIGNMENT_PATTERN_H__