zxing_cpp_no_cmake 0.1.1

data/ext/zxing/zxing-cpp/core/src/zxing/datamatrix/decoder/BitMatrixParser.h

@@ -0,0 +1,59 @@
+#ifndef __BIT_MATRIX_PARSER_DM_H__
+#define __BIT_MATRIX_PARSER_DM_H__
+
+/*
+ *  BitMatrixParser.h
+ *  zxing
+ *
+ *  Created by Luiz Silva on 09/02/2010.
+ *  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/datamatrix/Version.h>
+
+namespace zxing {
+namespace datamatrix {
+
+class BitMatrixParser : public Counted {
+private:
+  Ref<BitMatrix> bitMatrix_;
+  Ref<Version> parsedVersion_;
+  Ref<BitMatrix> readBitMatrix_;
+
+  int copyBit(size_t x, size_t y, int versionBits);
+
+public:
+  BitMatrixParser(Ref<BitMatrix> bitMatrix);
+  Ref<Version> readVersion(Ref<BitMatrix> bitMatrix);
+  ArrayRef<char> readCodewords();
+  bool readModule(int row, int column, int numRows, int numColumns);
+
+private:
+  int readUtah(int row, int column, int numRows, int numColumns);
+  int readCorner1(int numRows, int numColumns);
+  int readCorner2(int numRows, int numColumns);
+  int readCorner3(int numRows, int numColumns);
+  int readCorner4(int numRows, int numColumns);
+  Ref<BitMatrix> extractDataRegion(Ref<BitMatrix> bitMatrix);
+};
+
+}
+}
+
+#endif // __BIT_MATRIX_PARSER_DM_H__

data/ext/zxing/zxing-cpp/core/src/zxing/datamatrix/decoder/DataBlock.cpp

@@ -0,0 +1,113 @@
+/*
+ *  DataBlock.cpp
+ *  zxing
+ *
+ *  Created by Luiz Silva on 09/02/2010.
+ *  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/datamatrix/decoder/DataBlock.h>
+#include <zxing/common/IllegalArgumentException.h>
+
+namespace zxing {
+namespace datamatrix {
+
+using namespace std;
+
+DataBlock::DataBlock(int numDataCodewords, ArrayRef<char> codewords) :
+    numDataCodewords_(numDataCodewords), codewords_(codewords) {
+}
+
+int DataBlock::getNumDataCodewords() {
+  return numDataCodewords_;
+}
+
+ArrayRef<char> DataBlock::getCodewords() {
+  return codewords_;
+}
+
+std::vector<Ref<DataBlock> > DataBlock::getDataBlocks(ArrayRef<char> rawCodewords, Version *version) {
+  // Figure out the number and size of data blocks used by this version and
+  // error correction level
+  ECBlocks* ecBlocks = version->getECBlocks();
+
+  // First count the total number of data blocks
+  int totalBlocks = 0;
+  vector<ECB*> ecBlockArray = ecBlocks->getECBlocks();
+  for (size_t i = 0; i < ecBlockArray.size(); i++) {
+    totalBlocks += ecBlockArray[i]->getCount();
+  }
+
+  // Now establish DataBlocks of the appropriate size and number of data codewords
+  std::vector<Ref<DataBlock> > result(totalBlocks);
+  int numResultBlocks = 0;
+  for (size_t j = 0; j < ecBlockArray.size(); j++) {
+    ECB *ecBlock = ecBlockArray[j];
+    for (int i = 0; i < ecBlock->getCount(); i++) {
+      int numDataCodewords = ecBlock->getDataCodewords();
+      int numBlockCodewords = ecBlocks->getECCodewords() + numDataCodewords;
+      ArrayRef<char> buffer(numBlockCodewords);
+      Ref<DataBlock> blockRef(new DataBlock(numDataCodewords, buffer));
+      result[numResultBlocks++] = blockRef;
+    }
+  }
+
+  // All blocks have the same amount of data, except that the last n
+  // (where n may be 0) have 1 more byte. Figure out where these start.
+  int shorterBlocksTotalCodewords = result[0]->codewords_->size();
+  int longerBlocksStartAt = result.size() - 1;
+  while (longerBlocksStartAt >= 0) {
+    int numCodewords = result[longerBlocksStartAt]->codewords_->size();
+    if (numCodewords == shorterBlocksTotalCodewords) {
+      break;
+    }
+    if (numCodewords != shorterBlocksTotalCodewords + 1) {
+      throw IllegalArgumentException("Data block sizes differ by more than 1");
+    }
+    longerBlocksStartAt--;
+  }
+  longerBlocksStartAt++;
+
+  int shorterBlocksNumDataCodewords = shorterBlocksTotalCodewords - ecBlocks->getECCodewords();
+  // The last elements of result may be 1 element longer;
+  // first fill out as many elements as all of them have
+  int rawCodewordsOffset = 0;
+  for (int i = 0; i < shorterBlocksNumDataCodewords; i++) {
+    for (int j = 0; j < numResultBlocks; j++) {
+      result[j]->codewords_[i] = rawCodewords[rawCodewordsOffset++];
+    }
+  }
+  // Fill out the last data block in the longer ones
+  for (int j = longerBlocksStartAt; j < numResultBlocks; j++) {
+    result[j]->codewords_[shorterBlocksNumDataCodewords] = rawCodewords[rawCodewordsOffset++];
+  }
+  // Now add in error correction blocks
+  int max = result[0]->codewords_->size();
+  for (int i = shorterBlocksNumDataCodewords; i < max; i++) {
+    for (int j = 0; j < numResultBlocks; j++) {
+      int iOffset = j < longerBlocksStartAt ? i : i + 1;
+      result[j]->codewords_[iOffset] = rawCodewords[rawCodewordsOffset++];
+    }
+  }
+
+  if (rawCodewordsOffset != rawCodewords->size()) {
+    throw IllegalArgumentException("rawCodewordsOffset != rawCodewords.length");
+  }
+
+  return result;
+}
+
+}
+}

data/ext/zxing/zxing-cpp/core/src/zxing/datamatrix/decoder/DataBlock.h

@@ -0,0 +1,49 @@
+#ifndef __DATA_BLOCK_DM_H__
+#define __DATA_BLOCK_DM_H__
+
+/*
+ *  DataBlock.h
+ *  zxing
+ *
+ *  Created by Luiz Silva on 09/02/2010.
+ *  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/datamatrix/Version.h>
+
+namespace zxing {
+namespace datamatrix {
+
+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);
+
+  int getNumDataCodewords();
+  ArrayRef<char> getCodewords();
+};
+
+}
+}
+
+#endif // __DATA_BLOCK_DM_H__

data/ext/zxing/zxing-cpp/core/src/zxing/datamatrix/decoder/DecodedBitStreamParser.cpp

@@ -0,0 +1,415 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  DecodedBitStreamParser.cpp
+ *  zxing
+ *
+ *  Created by Luiz Silva on 09/02/2010.
+ *  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/FormatException.h>
+#include <zxing/datamatrix/decoder/DecodedBitStreamParser.h>
+#include <iostream>
+#include <zxing/common/DecoderResult.h>
+
+namespace zxing {
+namespace datamatrix {
+
+using namespace std;
+
+const char DecodedBitStreamParser::C40_BASIC_SET_CHARS[] = {
+    '*', '*', '*', ' ', '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'
+};
+  
+const char DecodedBitStreamParser::C40_SHIFT2_SET_CHARS[] = {
+    '!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.',
+    '/', ':', ';', '<', '=', '>', '?', '@', '[', '\\', ']', '^', '_'
+};
+  
+const char DecodedBitStreamParser::TEXT_BASIC_SET_CHARS[] = {
+    '*', '*', '*', ' ', '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'
+};
+  
+const char DecodedBitStreamParser::TEXT_SHIFT3_SET_CHARS[] = {
+    '\'', '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', '{', '|', '}', '~', (char) 127
+};
+
+Ref<DecoderResult> DecodedBitStreamParser::decode(ArrayRef<char> bytes) {
+  Ref<BitSource> bits(new BitSource(bytes));
+  ostringstream result;
+  ostringstream resultTrailer;
+  vector<char> byteSegments;
+  int mode = ASCII_ENCODE;
+  do {
+    if (mode == ASCII_ENCODE) {
+      mode = decodeAsciiSegment(bits, result, resultTrailer);
+    } else {
+      switch (mode) {
+        case C40_ENCODE:
+          decodeC40Segment(bits, result);
+          break;
+        case TEXT_ENCODE:
+          decodeTextSegment(bits, result);
+          break;
+        case ANSIX12_ENCODE:
+          decodeAnsiX12Segment(bits, result);
+          break;
+        case EDIFACT_ENCODE:
+          decodeEdifactSegment(bits, result);
+          break;
+        case BASE256_ENCODE:
+          decodeBase256Segment(bits, result, byteSegments);
+          break;
+        default:
+          throw FormatException("Unsupported mode indicator");
+      }
+      mode = ASCII_ENCODE;
+    }
+  } while (mode != PAD_ENCODE && bits->available() > 0);
+
+  if (resultTrailer.str().size() > 0) {
+    result << resultTrailer.str();
+  }
+  ArrayRef<char> rawBytes(bytes);
+  Ref<String> text(new String(result.str()));
+  return Ref<DecoderResult>(new DecoderResult(rawBytes, text));
+}
+
+int DecodedBitStreamParser::decodeAsciiSegment(Ref<BitSource> bits, ostringstream & result,
+  ostringstream & resultTrailer) {
+  bool upperShift = false;
+  do {
+    int oneByte = bits->readBits(8);
+    if (oneByte == 0) {
+      throw FormatException("Not enough bits to decode");
+    } else if (oneByte <= 128) {  // ASCII data (ASCII value + 1)
+      oneByte = upperShift ? (oneByte + 128) : oneByte;
+      // upperShift = false;
+      result << (char) (oneByte - 1);
+      return ASCII_ENCODE;
+    } else if (oneByte == 129) {  // Pad
+      return PAD_ENCODE;
+    } else if (oneByte <= 229) {  // 2-digit data 00-99 (Numeric Value + 130)
+      int value = oneByte - 130;
+      if (value < 10) { // padd with '0' for single digit values
+        result << '0';
+      }
+      result << value;
+    } else if (oneByte == 230) {  // Latch to C40 encodation
+      return C40_ENCODE;
+    } else if (oneByte == 231) {  // Latch to Base 256 encodation
+      return BASE256_ENCODE;
+    } else if (oneByte == 232) {  // FNC1
+      result << ((char) 29); // translate as ASCII 29
+    } else if (oneByte == 233 || oneByte == 234) {
+      // Structured Append, Reader Programming
+      // Ignore these symbols for now
+      // throw FormatException.getInstance();
+    } else if (oneByte == 235) {  // Upper Shift (shift to Extended ASCII)
+      upperShift = true;
+    } else if (oneByte == 236) {  // 05 Macro
+        result << ("[)>RS05GS");
+        resultTrailer << ("RSEOT");
+    } else if (oneByte == 237) {  // 06 Macro
+      result << ("[)>RS06GS");
+      resultTrailer <<  ("RSEOT");
+    } else if (oneByte == 238) {  // Latch to ANSI X12 encodation
+      return ANSIX12_ENCODE;
+    } else if (oneByte == 239) {  // Latch to Text encodation
+      return TEXT_ENCODE;
+    } else if (oneByte == 240) {  // Latch to EDIFACT encodation
+      return EDIFACT_ENCODE;
+    } else if (oneByte == 241) {  // ECI Character
+      // TODO(bbrown): I think we need to support ECI
+      // throw FormatException.getInstance();
+      // Ignore this symbol for now
+    } else if (oneByte >= 242) { // Not to be used in ASCII encodation
+      // ... but work around encoders that end with 254, latch back to ASCII
+      if (oneByte != 254 || bits->available() != 0) {
+        throw FormatException("Not to be used in ASCII encodation");
+      }
+    }
+  } while (bits->available() > 0);
+  return ASCII_ENCODE;
+}
+
+void DecodedBitStreamParser::decodeC40Segment(Ref<BitSource> bits, ostringstream & result) {
+  // Three C40 values are encoded in a 16-bit value as
+  // (1600 * C1) + (40 * C2) + C3 + 1
+  // TODO(bbrown): The Upper Shift with C40 doesn't work in the 4 value scenario all the time
+  bool upperShift = false;
+
+  int cValues[3];
+  int shift = 0;
+  do {
+    // If there is only one byte left then it will be encoded as ASCII
+    if (bits->available() == 8) {
+      return;
+    }
+    int firstByte = bits->readBits(8);
+    if (firstByte == 254) {  // Unlatch codeword
+      return;
+    }
+
+    parseTwoBytes(firstByte, bits->readBits(8), cValues);
+
+    for (int i = 0; i < 3; i++) {
+      int cValue = cValues[i];
+      switch (shift) {
+        case 0:
+          if (cValue < 3) {
+            shift = cValue + 1;
+          } else {
+            if (upperShift) {
+              result << (char) (C40_BASIC_SET_CHARS[cValue] + 128);
+              upperShift = false;
+            } else {
+              result << C40_BASIC_SET_CHARS[cValue];
+            }
+          }
+          break;
+        case 1:
+          if (upperShift) {
+            result << (char) (cValue + 128);
+            upperShift = false;
+          } else {
+            result << (char) cValue;
+          }
+          shift = 0;
+          break;
+        case 2:
+          if (cValue < 27) {
+            if (upperShift) {
+              result << (char) (C40_SHIFT2_SET_CHARS[cValue] + 128);
+              upperShift = false;
+            } else {
+              result << C40_SHIFT2_SET_CHARS[cValue];
+            }
+          } else if (cValue == 27) {  // FNC1
+            result << ((char) 29); // translate as ASCII 29
+          } else if (cValue == 30) {  // Upper Shift
+            upperShift = true;
+          } else {
+            throw FormatException("decodeC40Segment: Upper Shift");
+          }
+          shift = 0;
+          break;
+        case 3:
+          if (upperShift) {
+            result << (char) (cValue + 224);
+            upperShift = false;
+          } else {
+            result << (char) (cValue + 96);
+          }
+          shift = 0;
+          break;
+        default:
+          throw FormatException("decodeC40Segment: no case");
+      }
+    }
+  } while (bits->available() > 0);
+}
+
+void DecodedBitStreamParser::decodeTextSegment(Ref<BitSource> bits, ostringstream & result) {
+  // Three Text values are encoded in a 16-bit value as
+  // (1600 * C1) + (40 * C2) + C3 + 1
+  // TODO(bbrown): The Upper Shift with Text doesn't work in the 4 value scenario all the time
+  bool upperShift = false;
+
+  int cValues[3];
+  int shift = 0;
+  do {
+    // If there is only one byte left then it will be encoded as ASCII
+    if (bits->available() == 8) {
+      return;
+    }
+    int firstByte = bits->readBits(8);
+    if (firstByte == 254) {  // Unlatch codeword
+      return;
+    }
+
+    parseTwoBytes(firstByte, bits->readBits(8), cValues);
+
+    for (int i = 0; i < 3; i++) {
+      int cValue = cValues[i];
+      switch (shift) {
+        case 0:
+          if (cValue < 3) {
+            shift = cValue + 1;
+          } else {
+            if (upperShift) {
+              result << (char) (TEXT_BASIC_SET_CHARS[cValue] + 128);
+              upperShift = false;
+            } else {
+              result << (TEXT_BASIC_SET_CHARS[cValue]);
+            }
+          }
+          break;
+        case 1:
+          if (upperShift) {
+            result << (char) (cValue + 128);
+            upperShift = false;
+          } else {
+            result << (char) (cValue);
+          }
+          shift = 0;
+          break;
+        case 2:
+          // Shift 2 for Text is the same encoding as C40
+          if (cValue < 27) {
+            if (upperShift) {
+              result << (char) (C40_SHIFT2_SET_CHARS[cValue] + 128);
+              upperShift = false;
+            } else {
+              result << (C40_SHIFT2_SET_CHARS[cValue]);
+            }
+          } else if (cValue == 27) {  // FNC1
+            result << ((char) 29); // translate as ASCII 29
+          } else if (cValue == 30) {  // Upper Shift
+            upperShift = true;
+          } else {
+            throw FormatException("decodeTextSegment: Upper Shift");
+          }
+          shift = 0;
+          break;
+        case 3:
+          if (upperShift) {
+            result << (char) (TEXT_SHIFT3_SET_CHARS[cValue] + 128);
+            upperShift = false;
+          } else {
+            result << (TEXT_SHIFT3_SET_CHARS[cValue]);
+          }
+          shift = 0;
+          break;
+        default:
+          throw FormatException("decodeTextSegment: no case");
+      }
+    }
+  } while (bits->available() > 0);
+}
+
+void DecodedBitStreamParser::decodeAnsiX12Segment(Ref<BitSource> bits, ostringstream & result) {
+  // Three ANSI X12 values are encoded in a 16-bit value as
+  // (1600 * C1) + (40 * C2) + C3 + 1
+
+  int cValues[3];
+  do {
+    // If there is only one byte left then it will be encoded as ASCII
+    if (bits->available() == 8) {
+      return;
+    }
+    int firstByte = bits->readBits(8);
+    if (firstByte == 254) {  // Unlatch codeword
+      return;
+    }
+
+    parseTwoBytes(firstByte, bits->readBits(8), cValues);
+
+    for (int i = 0; i < 3; i++) {
+      int cValue = cValues[i];
+      if (cValue == 0) {  // X12 segment terminator <CR>
+        result << '\r';
+      } else if (cValue == 1) {  // X12 segment separator *
+        result << '*';
+      } else if (cValue == 2) {  // X12 sub-element separator >
+        result << '>';
+      } else if (cValue == 3) {  // space
+        result << ' ';
+      } else if (cValue < 14) {  // 0 - 9
+        result << (char) (cValue + 44);
+      } else if (cValue < 40) {  // A - Z
+        result << (char) (cValue + 51);
+      } else {
+        throw FormatException("decodeAnsiX12Segment: no case");
+      }
+    }
+  } while (bits->available() > 0);
+}
+
+void DecodedBitStreamParser::parseTwoBytes(int firstByte, int secondByte, int* result) {
+  int fullBitValue = (firstByte << 8) + secondByte - 1;
+  int temp = fullBitValue / 1600;
+  result[0] = temp;
+  fullBitValue -= temp * 1600;
+  temp = fullBitValue / 40;
+  result[1] = temp;
+  result[2] = fullBitValue - temp * 40;
+}
+  
+void DecodedBitStreamParser::decodeEdifactSegment(Ref<BitSource> bits, ostringstream & result) {
+  do {
+    // If there is only two or less bytes left then it will be encoded as ASCII
+    if (bits->available() <= 16) {
+      return;
+    }
+
+    for (int i = 0; i < 4; i++) {
+      int edifactValue = bits->readBits(6);
+
+      // Check for the unlatch character
+      if (edifactValue == 0x1f) {  // 011111
+        // Read rest of byte, which should be 0, and stop
+        int bitsLeft = 8 - bits->getBitOffset();
+        if (bitsLeft != 8) {
+          bits->readBits(bitsLeft);
+        }
+        return;
+      }
+
+      if ((edifactValue & 0x20) == 0) {  // no 1 in the leading (6th) bit
+        edifactValue |= 0x40;  // Add a leading 01 to the 6 bit binary value
+      }
+      result << (char)(edifactValue);
+    }
+  } while (bits->available() > 0);
+}
+  
+void DecodedBitStreamParser::decodeBase256Segment(Ref<BitSource> bits, ostringstream& result, vector<char> byteSegments) {
+  // Figure out how long the Base 256 Segment is.
+  int codewordPosition = 1 + bits->getByteOffset(); // position is 1-indexed
+  int d1 = unrandomize255State(bits->readBits(8), codewordPosition++);
+  int count;
+  if (d1 == 0) {  // Read the remainder of the symbol
+    count = bits->available() / 8;
+  } else if (d1 < 250) {
+    count = d1;
+  } else {
+    count = 250 * (d1 - 249) + unrandomize255State(bits->readBits(8), codewordPosition++);
+  }
+
+  // We're seeing NegativeArraySizeException errors from users.
+  if (count < 0) {
+    throw FormatException("NegativeArraySizeException");
+  }
+
+  for (int i = 0; i < count; i++) {
+    // Have seen this particular error in the wild, such as at
+    // http://www.bcgen.com/demo/IDAutomationStreamingDataMatrix.aspx?MODE=3&D=Fred&PFMT=3&PT=F&X=0.3&O=0&LM=0.2
+    if (bits->available() < 8) {
+      throw FormatException("byteSegments");
+    }
+    char byte = unrandomize255State(bits->readBits(8), codewordPosition++);
+    byteSegments.push_back(byte);
+    result << byte;
+  }
+}
+}
+}
+