zxing_cpp_no_cmake 0.1.1

data/ext/zxing/zxing-cpp/core/src/zxing/common/BitArrayIO.cpp

@@ -0,0 +1,31 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  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/BitArray.h>
+
+using zxing::BitArray;
+using std::ostream;
+
+ostream& zxing::operator << (ostream& os, BitArray const& ba) {
+  for (int i = 0, size = ba.getSize(); i < size; i++) {
+    if ((i & 0x07) == 0) {
+      os << ' ';
+    }
+    os << (ba.get(i) ? 'X' : '.');
+  }
+  return os;
+}

data/ext/zxing/zxing-cpp/core/src/zxing/common/BitMatrix.cpp

@@ -0,0 +1,143 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  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/BitMatrix.h>
+#include <zxing/common/IllegalArgumentException.h>
+
+#include <iostream>
+#include <sstream>
+#include <string>
+
+using std::ostream;
+using std::ostringstream;
+
+using zxing::BitMatrix;
+using zxing::BitArray;
+using zxing::ArrayRef;
+using zxing::Ref;
+
+void BitMatrix::init(int width, int height) {
+  if (width < 1 || height < 1) {
+    throw IllegalArgumentException("Both dimensions must be greater than 0");
+  }
+  this->width = width;
+  this->height = height;
+  this->rowSize = (width + bitsPerWord - 1) >> logBits;
+  bits = ArrayRef<int>(rowSize * height);
+}
+
+BitMatrix::BitMatrix(int dimension) {
+  init(dimension, dimension);
+}
+
+BitMatrix::BitMatrix(int width, int height) {
+  init(width, height);
+}
+
+BitMatrix::~BitMatrix() {}
+
+void BitMatrix::flip(int x, int y) {
+  int offset = y * rowSize + (x >> logBits);
+  bits[offset] ^= 1 << (x & bitsMask);
+}
+
+void BitMatrix::setRegion(int left, int top, int width, int height) {
+  if (top < 0 || left < 0) {
+    throw IllegalArgumentException("Left and top must be nonnegative");
+  }
+  if (height < 1 || width < 1) {
+    throw IllegalArgumentException("Height and width must be at least 1");
+  }
+  int right = left + width;
+  int bottom = top + height;
+  if (bottom > this->height || right > this->width) {
+    throw IllegalArgumentException("The region must fit inside the matrix");
+  }
+  for (int y = top; y < bottom; y++) {
+    int offset = y * rowSize;
+    for (int x = left; x < right; x++) {
+      bits[offset + (x >> logBits)] |= 1 << (x & bitsMask);
+    }
+  }
+}
+
+Ref<BitArray> BitMatrix::getRow(int y, Ref<BitArray> row) {
+  if (row.empty() || row->getSize() < width) {
+    row = new BitArray(width);
+  }
+  int offset = y * rowSize;
+  for (int x = 0; x < rowSize; x++) {
+    row->setBulk(x << logBits, bits[offset + x]);
+  }
+  return row;
+}
+
+int BitMatrix::getWidth() const {
+  return width;
+}
+
+int BitMatrix::getHeight() const {
+  return height;
+}
+
+ArrayRef<int> BitMatrix::getTopLeftOnBit() const {
+  int bitsOffset = 0;
+  while (bitsOffset < bits->size() && bits[bitsOffset] == 0) {
+    bitsOffset++;
+  }
+  if (bitsOffset == bits->size()) {
+    return ArrayRef<int>();
+  }
+  int y = bitsOffset / rowSize;
+  int x = (bitsOffset % rowSize) << 5;
+
+  int theBits = bits[bitsOffset];
+  int bit = 0;
+  while ((theBits << (31-bit)) == 0) {
+    bit++;
+  }
+  x += bit;
+  ArrayRef<int> res (2);
+  res[0]=x;
+  res[1]=y;
+  return res;
+}
+
+ArrayRef<int> BitMatrix::getBottomRightOnBit() const {
+  int bitsOffset = bits->size() - 1;
+  while (bitsOffset >= 0 && bits[bitsOffset] == 0) {
+    bitsOffset--;
+  }
+  if (bitsOffset < 0) {
+    return ArrayRef<int>();
+  }
+
+  int y = bitsOffset / rowSize;
+  int x = (bitsOffset % rowSize) << 5;
+
+  int theBits = bits[bitsOffset];
+  int bit = 31;
+  while ((theBits >> bit) == 0) {
+    bit--;
+  }
+  x += bit;
+
+  ArrayRef<int> res (2);
+  res[0]=x;
+  res[1]=y;
+  return res;
+}

data/ext/zxing/zxing-cpp/core/src/zxing/common/BitMatrix.h

@@ -0,0 +1,91 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __BIT_MATRIX_H__
+#define __BIT_MATRIX_H__
+
+/*
+ *  BitMatrix.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/common/BitArray.h>
+#include <zxing/common/Array.h>
+#include <limits>
+
+namespace zxing {
+
+class BitMatrix : public Counted {
+public:
+  static const int bitsPerWord = std::numeric_limits<unsigned int>::digits;
+
+private:
+  int width;
+  int height;
+  int rowSize;
+  ArrayRef<int> bits;
+
+#define ZX_LOG_DIGITS(digits) \
+    ((digits == 8) ? 3 : \
+     ((digits == 16) ? 4 : \
+      ((digits == 32) ? 5 : \
+       ((digits == 64) ? 6 : \
+        ((digits == 128) ? 7 : \
+         (-1))))))
+
+  static const int logBits = ZX_LOG_DIGITS(bitsPerWord);
+  static const int bitsMask = (1 << logBits) - 1;
+
+public:
+  BitMatrix(int dimension);
+  BitMatrix(int width, int height);
+
+  ~BitMatrix();
+
+  bool get(int x, int y) const {
+    int offset = y * rowSize + (x >> logBits);
+    return ((((unsigned)bits[offset]) >> (x & bitsMask)) & 1) != 0;
+  }
+
+  void set(int x, int y) {
+    int offset = y * rowSize + (x >> logBits);
+    bits[offset] |= 1 << (x & bitsMask);
+  }
+
+  void flip(int x, int y);
+  void clear();
+  void setRegion(int left, int top, int width, int height);
+  Ref<BitArray> getRow(int y, Ref<BitArray> row);
+
+  int getWidth() const;
+  int getHeight() const;
+
+  ArrayRef<int> getTopLeftOnBit() const;
+  ArrayRef<int> getBottomRightOnBit() const;
+
+  friend std::ostream& operator<<(std::ostream &out, const BitMatrix &bm);
+  const char *description();
+
+private:
+  inline void init(int, int);
+
+  BitMatrix(const BitMatrix&);
+  BitMatrix& operator =(const BitMatrix&);
+};
+
+}
+
+#endif // __BIT_MATRIX_H__

data/ext/zxing/zxing-cpp/core/src/zxing/common/BitSource.cpp

@@ -0,0 +1,76 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  BitSource.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 09/05/2008.
+ *  Copyright 2008 Google UK. 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/BitSource.h>
+#include <sstream>
+#include <zxing/common/IllegalArgumentException.h>
+
+namespace zxing {
+
+int BitSource::readBits(int numBits) {
+  if (numBits < 0 || numBits > 32 || numBits > available()) {
+    std::ostringstream oss;
+    oss << numBits;
+    throw IllegalArgumentException(oss.str().c_str());
+  }
+
+  int result = 0;
+
+  // First, read remainder from current byte
+  if (bitOffset_ > 0) {
+    int bitsLeft = 8 - bitOffset_;
+    int toRead = numBits < bitsLeft ? numBits : bitsLeft;
+    int bitsToNotRead = bitsLeft - toRead;
+    int mask = (0xFF >> (8 - toRead)) << bitsToNotRead;
+    result = (bytes_[byteOffset_] & mask) >> bitsToNotRead;
+    numBits -= toRead;
+    bitOffset_ += toRead;
+    if (bitOffset_ == 8) {
+      bitOffset_ = 0;
+      byteOffset_++;
+    }
+  }
+
+  // Next read whole bytes
+  if (numBits > 0) {
+    while (numBits >= 8) {
+      result = (result << 8) | (bytes_[byteOffset_] & 0xFF);
+      byteOffset_++;
+      numBits -= 8;
+    }
+
+
+    // Finally read a partial byte
+    if (numBits > 0) {
+      int bitsToNotRead = 8 - numBits;
+      int mask = (0xFF >> bitsToNotRead) << bitsToNotRead;
+      result = (result << numBits) | ((bytes_[byteOffset_] & mask) >> bitsToNotRead);
+      bitOffset_ += numBits;
+    }
+  }
+
+  return result;
+}
+
+int BitSource::available() {
+  return 8 * (bytes_->size() - byteOffset_) - bitOffset_;
+}
+}

data/ext/zxing/zxing-cpp/core/src/zxing/common/BitSource.h

@@ -0,0 +1,74 @@
+#ifndef __BIT_SOURCE_H__
+#define __BIT_SOURCE_H__
+
+/*
+ *  BitSource.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>
+
+namespace zxing {
+/**
+ * <p>This provides an easy abstraction to read bits at a time from a sequence of bytes, where the
+ * number of bits read is not often a multiple of 8.</p>
+ *
+ * <p>This class is not thread-safe.</p>
+ *
+ * @author srowen@google.com (Sean Owen)
+ * @author christian.brunschen@gmail.com (Christian Brunschen)
+ */
+class BitSource : public Counted {
+  typedef char byte;
+private:
+  ArrayRef<byte> bytes_;
+  int byteOffset_;
+  int bitOffset_;
+public:
+  /**
+   * @param bytes bytes from which this will read bits. Bits will be read from the first byte first.
+   * Bits are read within a byte from most-significant to least-significant bit.
+   */
+  BitSource(ArrayRef<byte> &bytes) :
+      bytes_(bytes), byteOffset_(0), bitOffset_(0) {
+  }
+
+  int getBitOffset() {
+    return bitOffset_;
+  }
+
+  int getByteOffset() {
+    return byteOffset_;
+  }
+
+  /**
+   * @param numBits number of bits to read
+   * @return int representing the bits read. The bits will appear as the least-significant
+   *         bits of the int
+   * @throws IllegalArgumentException if numBits isn't in [1,32]
+   */
+  int readBits(int numBits);
+
+  /**
+   * @return number of bits that can be read successfully
+   */
+  int available();
+};
+
+}
+
+#endif // __BIT_SOURCE_H__

data/ext/zxing/zxing-cpp/core/src/zxing/common/CharacterSetECI.cpp

@@ -0,0 +1,105 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ * Copyright 2008-2011 ZXing authors
+ *
+ * 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/CharacterSetECI.h>
+#include <zxing/common/IllegalArgumentException.h>
+#include <zxing/FormatException.h>
+
+using std::string;
+
+using zxing::common::CharacterSetECI;
+using zxing::IllegalArgumentException;
+
+std::map<int, zxing::Ref<CharacterSetECI> > CharacterSetECI::VALUE_TO_ECI;
+std::map<std::string, zxing::Ref<CharacterSetECI> > CharacterSetECI::NAME_TO_ECI;
+
+const bool CharacterSetECI::inited = CharacterSetECI::init_tables();
+
+#define ADD_CHARACTER_SET(VALUES, STRINGS) \
+  { static int values[] = {VALUES, -1}; \
+    static char const* strings[] = {STRINGS, 0}; \
+    addCharacterSet(values, strings); }
+
+#define XC ,
+
+bool CharacterSetECI::init_tables() {
+  ADD_CHARACTER_SET(0 XC 2, "Cp437");
+  ADD_CHARACTER_SET(1 XC 3, "ISO8859_1" XC "ISO-8859-1");
+  ADD_CHARACTER_SET(4, "ISO8859_2" XC "ISO-8859-2");
+  ADD_CHARACTER_SET(5, "ISO8859_3" XC "ISO-8859-3");
+  ADD_CHARACTER_SET(6, "ISO8859_4" XC "ISO-8859-4");
+  ADD_CHARACTER_SET(7, "ISO8859_5" XC "ISO-8859-5");
+  ADD_CHARACTER_SET(8, "ISO8859_6" XC "ISO-8859-6");
+  ADD_CHARACTER_SET(9, "ISO8859_7" XC "ISO-8859-7");
+  ADD_CHARACTER_SET(10, "ISO8859_8" XC "ISO-8859-8");
+  ADD_CHARACTER_SET(11, "ISO8859_9" XC "ISO-8859-9");
+  ADD_CHARACTER_SET(12, "ISO8859_10" XC "ISO-8859-10");
+  ADD_CHARACTER_SET(13, "ISO8859_11" XC "ISO-8859-11");
+  ADD_CHARACTER_SET(15, "ISO8859_13" XC "ISO-8859-13");
+  ADD_CHARACTER_SET(16, "ISO8859_14" XC "ISO-8859-14");
+  ADD_CHARACTER_SET(17, "ISO8859_15" XC "ISO-8859-15");
+  ADD_CHARACTER_SET(18, "ISO8859_16" XC "ISO-8859-16");
+  ADD_CHARACTER_SET(20, "SJIS" XC "Shift_JIS");
+  ADD_CHARACTER_SET(21, "Cp1250" XC "windows-1250");
+  ADD_CHARACTER_SET(22, "Cp1251" XC "windows-1251");
+  ADD_CHARACTER_SET(23, "Cp1252" XC "windows-1252");
+  ADD_CHARACTER_SET(24, "Cp1256" XC "windows-1256");
+  ADD_CHARACTER_SET(25, "UnicodeBigUnmarked" XC "UTF-16BE" XC "UnicodeBig");
+  ADD_CHARACTER_SET(26, "UTF8" XC "UTF-8");
+  ADD_CHARACTER_SET(27 XC 170, "ASCII" XC "US-ASCII");
+  ADD_CHARACTER_SET(28, "Big5");
+  ADD_CHARACTER_SET(29, "GB18030" XC "GB2312" XC "EUC_CN" XC "GBK");
+  ADD_CHARACTER_SET(30, "EUC_KR" XC "EUC-KR");
+  return true;
+}
+
+#undef XC
+
+CharacterSetECI::CharacterSetECI(int const* values,
+                                 char const* const* names) 
+  : values_(values), names_(names) {
+  zxing::Ref<CharacterSetECI> this_ref(this);
+  for(int const* values = values_; *values != -1; values++) {
+    VALUE_TO_ECI[*values] = this_ref;
+  }
+  for(char const* const* names = names_; *names; names++) {
+    NAME_TO_ECI[string(*names)] = this_ref;
+  }
+}
+
+char const* CharacterSetECI::name() const {
+  return names_[0];
+}
+
+int CharacterSetECI::getValue() const {
+  return values_[0];
+}
+
+void CharacterSetECI::addCharacterSet(int const* values, char const* const* names) {
+  new CharacterSetECI(values, names);
+}
+
+CharacterSetECI* CharacterSetECI::getCharacterSetECIByValue(int value) {
+  if (value < 0 || value >= 900) {
+    throw FormatException();
+  }
+  return VALUE_TO_ECI[value];
+}
+
+CharacterSetECI* CharacterSetECI::getCharacterSetECIByName(string const& name) {
+  return NAME_TO_ECI[name];
+}