Merge lp:~dpm/qreator/qreator-touch-with-plugin into lp:qreator/touch

[David Planella]

Initial merge of the QZXing plugin into the app's code, and conversion to CMake. Now the app and the plugin can be built and distributed together in a click package. The .deb packaging will still generate 2 independent packages, but it will probably require some more fixes.

=== modified file '.bzrignore'
--- .bzrignore	2013-06-15 09:30:23 +0000
+++ .bzrignore	2014-05-10 17:38:08 +0000
@@ -1,3 +1,7 @@
 qreator.qmlproject.user
 qreator-touch.qmlproject.user
 jsqrcode
+plugins
+.excludes
+qreator.pro.user
+CMakeLists.txt.user

=== added directory '3rdParty'
=== added file '3rdParty/CMakeLists.txt'
--- 3rdParty/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ 3rdParty/CMakeLists.txt	2014-05-10 17:38:08 +0000
@@ -0,0 +1,1 @@
+add_subdirectory(zxing)

=== added file '3rdParty/lib.pro'
--- 3rdParty/lib.pro	1970-01-01 00:00:00 +0000
+++ 3rdParty/lib.pro	2014-05-10 17:38:08 +0000
@@ -0,0 +1,2 @@
+TEMPLATE = subdirs
+SUBDIRS = zxing

=== added directory '3rdParty/zxing'
=== added file '3rdParty/zxing/BarcodeFormat.cpp'
--- 3rdParty/zxing/BarcodeFormat.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/BarcodeFormat.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,37 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  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/BarcodeFormat.h>
+
+namespace zxing {
+
+const char *barcodeFormatNames[] = {
+    "None",
+    "QR_CODE",
+    "DATA_MATRIX",
+    "UPC_E",
+    "UPC_A",
+    "EAN_8",
+    "EAN_13",
+    "CODE_128",
+    "CODE_39",
+    "ITF",
+    "AZTEC"
+};
+
+}

=== added file '3rdParty/zxing/BarcodeFormat.h'
--- 3rdParty/zxing/BarcodeFormat.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/BarcodeFormat.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,44 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __BARCODE_FORMAT_H__
+#define __BARCODE_FORMAT_H__
+
+/*
+ *  BarcodeFormat.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.
+ */
+
+namespace zxing {
+	
+    typedef enum BarcodeFormat {
+        BarcodeFormat_None = 0, 
+        BarcodeFormat_QR_CODE,
+        BarcodeFormat_DATA_MATRIX,
+        BarcodeFormat_UPC_E,
+        BarcodeFormat_UPC_A,
+        BarcodeFormat_EAN_8,
+        BarcodeFormat_EAN_13,
+        BarcodeFormat_CODE_128,
+        BarcodeFormat_CODE_39,
+        BarcodeFormat_ITF,
+        BarcodeFormat_AZTEC
+    } BarcodeFormat;
+
+    /* if you update the enum, please update the name in BarcodeFormat.cpp */
+    extern const char *barcodeFormatNames[];
+}
+
+#endif // __BARCODE_FORMAT_H__

=== added file '3rdParty/zxing/Binarizer.cpp'
--- 3rdParty/zxing/Binarizer.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/Binarizer.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,37 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  Binarizer.cpp
+ *  zxing
+ *
+ *  Created by Ralf Kistner on 16/10/2009.
+ *  Copyright 2008 ZXing authors All rights reserved.
+ *  Modified by Lukasz Warchol on 02/02/2010.
+ *
+ * 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/Binarizer.h>
+
+namespace zxing {
+	
+	Binarizer::Binarizer(Ref<LuminanceSource> source) : source_(source) {
+  }
+	
+	Binarizer::~Binarizer() {
+	}
+	
+	Ref<LuminanceSource> Binarizer::getLuminanceSource() const {
+		return source_;
+	}
+	
+}

=== added file '3rdParty/zxing/Binarizer.h'
--- 3rdParty/zxing/Binarizer.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/Binarizer.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,46 @@
+#ifndef BINARIZER_H_
+#define BINARIZER_H_
+
+/*
+ *  Binarizer.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/LuminanceSource.h>
+#include <zxing/common/BitArray.h>
+#include <zxing/common/BitMatrix.h>
+#include <zxing/common/Counted.h>
+
+namespace zxing {
+
+class Binarizer : public Counted {
+ private:
+  Ref<LuminanceSource> source_;
+
+ public:
+  Binarizer(Ref<LuminanceSource> source);
+  virtual ~Binarizer();
+
+  virtual Ref<BitArray> getBlackRow(int y, Ref<BitArray> row) = 0;
+  virtual Ref<BitMatrix> getBlackMatrix() = 0;
+
+  Ref<LuminanceSource> getLuminanceSource() const ;
+  virtual Ref<Binarizer> createBinarizer(Ref<LuminanceSource> source) = 0;
+};
+
+}
+#endif /* BINARIZER_H_ */

=== added file '3rdParty/zxing/BinaryBitmap.cpp'
--- 3rdParty/zxing/BinaryBitmap.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/BinaryBitmap.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,67 @@
+/*
+ *  BinaryBitmap.cpp
+ *  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/BinaryBitmap.h>
+
+namespace zxing {
+	
+	BinaryBitmap::BinaryBitmap(Ref<Binarizer> binarizer) : binarizer_(binarizer) {
+		
+	}
+	
+	BinaryBitmap::~BinaryBitmap() {
+	}
+	
+	Ref<BitArray> BinaryBitmap::getBlackRow(int y, Ref<BitArray> row) {
+		return binarizer_->getBlackRow(y, row);
+	}
+	
+	Ref<BitMatrix> BinaryBitmap::getBlackMatrix() {
+		return binarizer_->getBlackMatrix();
+	}
+	
+	int BinaryBitmap::getWidth() const {
+		return getLuminanceSource()->getWidth();
+	}
+	
+	int BinaryBitmap::getHeight() const {
+		return getLuminanceSource()->getHeight();
+	}
+	
+	Ref<LuminanceSource> BinaryBitmap::getLuminanceSource() const {
+		return binarizer_->getLuminanceSource();
+	}
+	
+
+	bool BinaryBitmap::isCropSupported() const {
+	  return getLuminanceSource()->isCropSupported();
+	}
+
+	Ref<BinaryBitmap> BinaryBitmap::crop(int left, int top, int width, int height) {
+	  return Ref<BinaryBitmap> (new BinaryBitmap(binarizer_->createBinarizer(getLuminanceSource()->crop(left, top, width, height))));
+	}
+
+	bool BinaryBitmap::isRotateSupported() const {
+	  return getLuminanceSource()->isRotateSupported();
+	}
+
+	Ref<BinaryBitmap> BinaryBitmap::rotateCounterClockwise() {
+	  return Ref<BinaryBitmap> (new BinaryBitmap(binarizer_->createBinarizer(getLuminanceSource()->rotateCounterClockwise())));
+	}
+}

=== added file '3rdParty/zxing/BinaryBitmap.h'
--- 3rdParty/zxing/BinaryBitmap.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/BinaryBitmap.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,57 @@
+#ifndef __BINARYBITMAP_H__
+#define __BINARYBITMAP_H__
+
+/*
+ *  BinaryBitmap.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/BitMatrix.h>
+#include <zxing/common/BitArray.h>
+#include <zxing/Binarizer.h>
+
+namespace zxing {
+	
+	class BinaryBitmap : public Counted {
+	private:
+		Ref<Binarizer> binarizer_;
+		int cached_y_;
+		
+	public:
+		BinaryBitmap(Ref<Binarizer> binarizer);
+		virtual ~BinaryBitmap();
+		
+		Ref<BitArray> getBlackRow(int y, Ref<BitArray> row);
+		Ref<BitMatrix> getBlackMatrix();
+		
+		Ref<LuminanceSource> getLuminanceSource() const;
+
+		int getWidth() const;
+		int getHeight() const;
+
+		bool isRotateSupported() const;
+		Ref<BinaryBitmap> rotateCounterClockwise();
+
+		bool isCropSupported() const;
+		Ref<BinaryBitmap> crop(int left, int top, int width, int height);
+
+	};
+	
+}
+
+#endif /* BINARYBITMAP_H_ */

=== added file '3rdParty/zxing/CMakeLists.txt'
--- 3rdParty/zxing/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/CMakeLists.txt	2014-05-10 17:38:08 +0000
@@ -0,0 +1,110 @@
+include_directories(
+    ${CMAKE_CURRENT_SOURCE_DIR}/../
+    /usr/include/qt5/QtCore/
+    /usr/include/qt5/
+)
+
+#get_filename_component(PARENT_DIR ${CMAKE_CURRENT_SOURCE_DIR} DIRECTORY)
+
+add_definitions(
+    -DNOFMAXL
+    -DZXING_ICONV_CONST
+    -DQZXING_LIBRARY
+    #-DNO_ICONV
+)
+
+#CONFIG += qt staticlib object_parallel_to_source
+
+#QMAKE_CXXFLAGS += -std=c++0x -fPIC
+
+SET(libzxing_SRCS
+    ResultPointCallback.cpp
+    ResultPoint.cpp
+    Result.cpp
+    ReaderException.cpp
+    Reader.cpp
+    NotFoundException.cpp
+    MultiFormatReader.cpp
+    LuminanceSource.cpp
+    FormatException.cpp
+    Exception.cpp
+    DecodeHints.cpp
+    BinaryBitmap.cpp
+    Binarizer.cpp
+    BarcodeFormat.cpp
+    aztec/AztecReader.cpp
+    aztec/AztecDetectorResult.cpp
+    common/StringUtils.cpp
+    common/Str.cpp
+    common/PerspectiveTransform.cpp
+    common/IllegalArgumentException.cpp
+    common/HybridBinarizer.cpp
+    common/GridSampler.cpp
+    common/GreyscaleRotatedLuminanceSource.cpp
+    common/GreyscaleLuminanceSource.cpp
+    common/GlobalHistogramBinarizer.cpp
+    common/EdgeDetector.cpp
+    common/DetectorResult.cpp
+    common/DecoderResult.cpp
+    common/Counted.cpp
+    common/CharacterSetECI.cpp
+    common/BitSource.cpp
+    common/BitMatrix.cpp
+    common/BitArray.cpp
+    common/Array.cpp
+    common/detector/WhiteRectangleDetector.cpp
+    common/detector/MonochromeRectangleDetector.cpp
+    common/reedsolomon/ReedSolomonException.cpp
+    common/reedsolomon/ReedSolomonDecoder.cpp
+    common/reedsolomon/GenericGFPoly.cpp
+    common/reedsolomon/GenericGF.cpp
+    datamatrix/DataMatrixReader.cpp
+    oned/UPCEReader.cpp
+    oned/UPCEANReader.cpp
+    oned/UPCAReader.cpp
+    oned/OneDResultPoint.cpp
+    oned/OneDReader.cpp
+    oned/MultiFormatUPCEANReader.cpp
+    oned/MultiFormatOneDReader.cpp
+    oned/ITFReader.cpp
+    oned/EAN13Reader.cpp
+    oned/EAN8Reader.cpp
+    oned/Code128Reader.cpp
+    oned/Code39Reader.cpp
+    qrcode/QRCodeReader.cpp
+    qrcode/detector/QREdgeDetector.cpp
+    multi/MultipleBarcodeReader.cpp
+    multi/GenericMultipleBarcodeReader.cpp
+    multi/ByQuadrantReader.cpp
+    multi/qrcode/QRCodeMultiReader.cpp
+    multi/qrcode/detector/MultiFinderPatternFinder.cpp
+    multi/qrcode/detector/MultiDetector.cpp
+    aztec/decoder/AztecDecoder.cpp
+    aztec/detector/AztecDetector.cpp
+    datamatrix/DataMatrixVersion.cpp
+    datamatrix/decoder/DataMatrixDecoder.cpp
+    datamatrix/decoder/DataMatrixBitMatrixParser.cpp
+    datamatrix/decoder/DataMatrixDataBlock.cpp
+    datamatrix/decoder/DataMatrixDecodedBitStreamParser.cpp
+    datamatrix/detector/DataMatrixCornerPoint.cpp
+    datamatrix/detector/DataMatrixDetector.cpp
+    datamatrix/detector/DataMatrixDetectorException.cpp
+    datamatrix/detector/DataMatrixMonochromeRectangleDetector.cpp
+    qrcode/decoder/QRBitMatrixParser.cpp
+    qrcode/decoder/QRDataBlock.cpp
+    qrcode/decoder/QRDataMask.cpp
+    qrcode/decoder/QRDecodedBitStreamParser.cpp
+    qrcode/decoder/QRDecoder.cpp
+    qrcode/decoder/QRMode.cpp
+    qrcode/detector/QRAlignmentPattern.cpp
+    qrcode/detector/QRAlignmentPatternFinder.cpp
+    qrcode/detector/QRDetector.cpp
+    qrcode/detector/QRFinderPattern.cpp
+    qrcode/detector/QRFinderPatternFinder.cpp
+    qrcode/detector/QRFinderPatternInfo.cpp
+    qrcode/QRVersion.cpp
+    qrcode/QRFormatInformation.cpp
+    qrcode/QRErrorCorrectionLevel.cpp
+)
+
+add_library(libzxing ${libzxing_SRCS})

=== added file '3rdParty/zxing/DecodeHints.cpp'
--- 3rdParty/zxing/DecodeHints.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/DecodeHints.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,120 @@
+/*
+ *  DecodeHintType.cpp
+ *  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/DecodeHints.h>
+#include <zxing/common/IllegalArgumentException.h>
+namespace zxing {
+
+const DecodeHintType DecodeHints::CHARACTER_SET;
+
+const DecodeHints DecodeHints::PRODUCT_HINT(
+    BARCODEFORMAT_UPC_E_HINT |
+    BARCODEFORMAT_UPC_A_HINT |
+    BARCODEFORMAT_EAN_8_HINT |
+    BARCODEFORMAT_EAN_13_HINT);
+
+const DecodeHints DecodeHints::ONED_HINT(
+    BARCODEFORMAT_UPC_E_HINT |
+    BARCODEFORMAT_UPC_A_HINT |
+    BARCODEFORMAT_EAN_8_HINT |
+    BARCODEFORMAT_EAN_13_HINT |
+    BARCODEFORMAT_CODE_128_HINT |
+    BARCODEFORMAT_CODE_39_HINT |
+    BARCODEFORMAT_ITF_HINT);
+
+const DecodeHints DecodeHints::DEFAULT_HINT(
+    BARCODEFORMAT_UPC_E_HINT |
+    BARCODEFORMAT_UPC_A_HINT |
+    BARCODEFORMAT_EAN_8_HINT |
+    BARCODEFORMAT_EAN_13_HINT |
+    BARCODEFORMAT_CODE_128_HINT |
+    BARCODEFORMAT_CODE_39_HINT |
+    BARCODEFORMAT_ITF_HINT |
+    BARCODEFORMAT_DATA_MATRIX_HINT |
+    BARCODEFORMAT_AZTEC_HINT |
+    BARCODEFORMAT_QR_CODE_HINT);
+
+DecodeHints::DecodeHints() {
+  hints = 0;
+}
+
+DecodeHints::DecodeHints(DecodeHintType init) {
+  hints = init;
+}
+
+void DecodeHints::addFormat(BarcodeFormat toadd) {
+  switch (toadd) {
+    case BarcodeFormat_AZTEC: hints |= BARCODEFORMAT_AZTEC_HINT; break;
+    case BarcodeFormat_QR_CODE: hints |= BARCODEFORMAT_QR_CODE_HINT; break;
+    case BarcodeFormat_DATA_MATRIX: hints |= BARCODEFORMAT_DATA_MATRIX_HINT; break;
+    case BarcodeFormat_UPC_E: hints |= BARCODEFORMAT_UPC_E_HINT; break;
+    case BarcodeFormat_UPC_A: hints |= BARCODEFORMAT_UPC_A_HINT; break;
+    case BarcodeFormat_EAN_8: hints |= BARCODEFORMAT_EAN_8_HINT; break;
+    case BarcodeFormat_EAN_13: hints |= BARCODEFORMAT_EAN_13_HINT; break;
+    case BarcodeFormat_CODE_128: hints |= BARCODEFORMAT_CODE_128_HINT; break;
+    case BarcodeFormat_CODE_39: hints |= BARCODEFORMAT_CODE_39_HINT; break;
+    case BarcodeFormat_ITF: hints |= BARCODEFORMAT_ITF_HINT; break;
+    default: throw IllegalArgumentException("Unrecognizd barcode format");
+  }
+}
+
+bool DecodeHints::containsFormat(BarcodeFormat tocheck) const {
+  DecodeHintType checkAgainst;
+  switch (tocheck) {
+    case BarcodeFormat_AZTEC: checkAgainst = BARCODEFORMAT_AZTEC_HINT; break;
+    case BarcodeFormat_QR_CODE: checkAgainst = BARCODEFORMAT_QR_CODE_HINT; break;
+    case BarcodeFormat_DATA_MATRIX: checkAgainst = BARCODEFORMAT_DATA_MATRIX_HINT; break;
+    case BarcodeFormat_UPC_E: checkAgainst = BARCODEFORMAT_UPC_E_HINT; break;
+    case BarcodeFormat_UPC_A: checkAgainst = BARCODEFORMAT_UPC_A_HINT; break;
+    case BarcodeFormat_EAN_8: checkAgainst = BARCODEFORMAT_EAN_8_HINT; break;
+    case BarcodeFormat_EAN_13: checkAgainst = BARCODEFORMAT_EAN_13_HINT; break;
+    case BarcodeFormat_CODE_128: checkAgainst = BARCODEFORMAT_CODE_128_HINT; break;
+    case BarcodeFormat_CODE_39: checkAgainst = BARCODEFORMAT_CODE_39_HINT; break;
+    case BarcodeFormat_ITF: checkAgainst = BARCODEFORMAT_ITF_HINT; break;
+    default: throw IllegalArgumentException("Unrecognizd barcode format");
+  }
+  return (hints & checkAgainst);
+}
+
+void DecodeHints::setTryHarder(bool toset) {
+  if (toset) {
+    hints |= TRYHARDER_HINT;
+  } else {
+    hints &= ~TRYHARDER_HINT;
+  }
+}
+
+bool DecodeHints::getTryHarder() const {
+  return (hints & TRYHARDER_HINT);
+}
+
+void DecodeHints::setResultPointCallback(Ref<ResultPointCallback> const& _callback) {
+    callback = _callback;
+}
+
+Ref<ResultPointCallback> DecodeHints::getResultPointCallback() const {
+    return callback;
+}
+
+DecodeHintType DecodeHints::getCurrentHint()
+{
+    return hints;
+}
+
+} /* namespace */

=== added file '3rdParty/zxing/DecodeHints.h'
--- 3rdParty/zxing/DecodeHints.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/DecodeHints.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,72 @@
+#ifndef __DECODEHINTS_H_
+#define __DECODEHINTS_H_
+/*
+ *  DecodeHintType.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/BarcodeFormat.h>
+#include <zxing/ResultPointCallback.h>
+
+namespace zxing {
+
+typedef unsigned int DecodeHintType;
+
+class DecodeHints {
+
+ private:
+
+  DecodeHintType hints;
+
+  Ref<ResultPointCallback> callback;
+
+ public:
+
+  static const DecodeHintType BARCODEFORMAT_QR_CODE_HINT = 1 << BarcodeFormat_QR_CODE;
+  static const DecodeHintType BARCODEFORMAT_DATA_MATRIX_HINT = 1 << BarcodeFormat_DATA_MATRIX;
+  static const DecodeHintType BARCODEFORMAT_UPC_E_HINT = 1 << BarcodeFormat_UPC_E;
+  static const DecodeHintType BARCODEFORMAT_UPC_A_HINT = 1 << BarcodeFormat_UPC_A;
+  static const DecodeHintType BARCODEFORMAT_EAN_8_HINT = 1 << BarcodeFormat_EAN_8;
+  static const DecodeHintType BARCODEFORMAT_EAN_13_HINT = 1 << BarcodeFormat_EAN_13;
+  static const DecodeHintType BARCODEFORMAT_CODE_128_HINT = 1 << BarcodeFormat_CODE_128;
+  static const DecodeHintType BARCODEFORMAT_CODE_39_HINT = 1 << BarcodeFormat_CODE_39;
+  static const DecodeHintType BARCODEFORMAT_ITF_HINT = 1 << BarcodeFormat_ITF;
+  static const DecodeHintType BARCODEFORMAT_AZTEC_HINT = 1 << BarcodeFormat_AZTEC;
+  static const DecodeHintType CHARACTER_SET = 1 << 30;
+  static const DecodeHintType TRYHARDER_HINT = 1 << 31;
+
+  static const DecodeHints PRODUCT_HINT;
+  static const DecodeHints ONED_HINT;
+  static const DecodeHints DEFAULT_HINT;
+
+  DecodeHints();
+  DecodeHints(DecodeHintType init);
+
+  void addFormat(BarcodeFormat toadd);
+  bool containsFormat(BarcodeFormat tocheck) const;
+  void setTryHarder(bool toset);
+  bool getTryHarder() const;
+
+  void setResultPointCallback(Ref<ResultPointCallback> const&);
+  Ref<ResultPointCallback> getResultPointCallback() const;
+
+  DecodeHintType getCurrentHint();
+};
+
+}
+
+#endif

=== added file '3rdParty/zxing/Exception.cpp'
--- 3rdParty/zxing/Exception.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/Exception.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,40 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  Exception.cpp
+ *  ZXing
+ *
+ *  Created by Christian Brunschen on 03/06/2008.
+ *  Copyright 2008-2011 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/Exception.h>
+
+namespace zxing {
+
+Exception::Exception() {}
+
+Exception::Exception(const char *msg) :
+    message(msg) {
+}
+
+const char* Exception::what() const throw() {
+  return message.c_str();
+}
+
+Exception::~Exception() throw() {
+}
+
+}

=== added file '3rdParty/zxing/Exception.h'
--- 3rdParty/zxing/Exception.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/Exception.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,40 @@
+#ifndef __EXCEPTION_H__
+#define __EXCEPTION_H__
+
+/*
+ *  Exception.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 <exception>
+
+namespace zxing {
+
+class Exception : public std::exception {
+private:
+  std::string message;
+
+public:
+  Exception();
+  Exception(const char *msg);
+  virtual const char* what() const throw();
+  virtual ~Exception() throw();
+};
+
+}
+#endif // __EXCEPTION_H__

=== added file '3rdParty/zxing/FormatException.cpp'
--- 3rdParty/zxing/FormatException.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/FormatException.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,35 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  FormatException.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/FormatException.h>
+
+namespace zxing {
+
+FormatException::FormatException() {}
+
+FormatException::FormatException(const char *msg) :
+    ReaderException(msg) {
+}
+
+FormatException::~FormatException() throw() {
+}
+
+}

=== added file '3rdParty/zxing/FormatException.h'
--- 3rdParty/zxing/FormatException.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/FormatException.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,35 @@
+#ifndef __FORMAT_EXCEPTION_H__
+#define __FORMAT_EXCEPTION_H__
+
+/*
+ *  FormatException.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>
+
+namespace zxing {
+
+class FormatException : public ReaderException {
+public:
+  FormatException();
+  FormatException(const char *msg);
+  ~FormatException() throw();
+};
+
+}
+#endif // __FORMAT_EXCEPTION_H__

=== added file '3rdParty/zxing/LuminanceSource.cpp'
--- 3rdParty/zxing/LuminanceSource.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/LuminanceSource.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,80 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  LuminanceSource.cpp
+ *  zxing
+ *
+ *  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 <sstream>
+#include <zxing/LuminanceSource.h>
+#include <zxing/common/IllegalArgumentException.h>
+
+namespace zxing {
+
+LuminanceSource::LuminanceSource() {
+}
+
+LuminanceSource::~LuminanceSource() {
+}
+
+bool LuminanceSource::isCropSupported() const {
+  return false;
+}
+
+Ref<LuminanceSource> LuminanceSource::crop(int left, int top, int width, int height) {
+  (void)left;
+  (void)top;
+  (void)width;
+  (void)height;
+  throw IllegalArgumentException("This luminance source does not support cropping.");
+}
+
+bool LuminanceSource::isRotateSupported() const {
+  return false;
+}
+
+Ref<LuminanceSource> LuminanceSource::rotateCounterClockwise() {
+  throw IllegalArgumentException("This luminance source does not support rotation.");
+}
+
+LuminanceSource::operator std::string() {
+  unsigned char* row = 0;
+  std::ostringstream oss;
+  for (int y = 0; y < getHeight(); y++) {
+    row = getRow(y, row);
+    for (int x = 0; x < getWidth(); x++) {
+      int luminance = row[x] & 0xFF;
+      char c;
+      if (luminance < 0x40) {
+        c = '#';
+      } else if (luminance < 0x80) {
+        c = '+';
+      } else if (luminance < 0xC0) {
+        c = '.';
+      } else {
+        c = ' ';
+      }
+      oss << c;
+    }
+    oss << '\n';
+  }
+  delete [] row;
+  return oss.str();
+}
+
+
+
+}

=== added file '3rdParty/zxing/LuminanceSource.h'
--- 3rdParty/zxing/LuminanceSource.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/LuminanceSource.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,52 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __LUMINANCESOURCE_H__
+#define __LUMINANCESOURCE_H__
+/*
+ *  LuminanceSource.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 <string.h>
+
+namespace zxing {
+
+class LuminanceSource : public Counted {
+public:
+  LuminanceSource();
+  virtual ~LuminanceSource();
+
+  virtual int getWidth() const = 0;
+  virtual int getHeight() const = 0;
+
+  // Callers take ownership of the returned memory and must call delete [] on it themselves.
+  virtual unsigned char* getRow(int y, unsigned char* row) = 0;
+  virtual unsigned char* getMatrix() = 0;
+
+  virtual bool isCropSupported() const;
+  virtual Ref<LuminanceSource> crop(int left, int top, int width, int height);
+
+  virtual bool isRotateSupported() const;
+  virtual Ref<LuminanceSource> rotateCounterClockwise();
+
+  operator std::string (); // should be const but don't want to make sure a
+                           // large breaking change right now
+};
+
+}
+
+#endif /* LUMINANCESOURCE_H_ */

=== added file '3rdParty/zxing/MultiFormatReader.cpp'
--- 3rdParty/zxing/MultiFormatReader.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/MultiFormatReader.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,106 @@
+/*
+ *  MultiFormatBarcodeReader.cpp
+ *  ZXing
+ *
+ *  Created by Lukasz Warchol on 10-01-26.
+ *  Modified 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/MultiFormatReader.h>
+#include <zxing/qrcode/QRCodeReader.h>
+#include <zxing/datamatrix/DataMatrixReader.h>
+#include <zxing/aztec/AztecReader.h>
+#include <zxing/oned/MultiFormatUPCEANReader.h>
+#include <zxing/oned/MultiFormatOneDReader.h>
+#include <zxing/ReaderException.h>
+
+namespace zxing {
+  MultiFormatReader::MultiFormatReader() {
+
+  }
+  
+  Ref<Result> MultiFormatReader::decode(Ref<BinaryBitmap> image) {
+    setHints(DecodeHints::DEFAULT_HINT);
+    return decodeInternal(image);
+  }
+
+  Ref<Result> MultiFormatReader::decode(Ref<BinaryBitmap> image, DecodeHints hints) {
+    setHints(hints);
+    return decodeInternal(image);
+  }
+
+  Ref<Result> MultiFormatReader::decodeWithState(Ref<BinaryBitmap> image) {
+    // Make sure to set up the default state so we don't crash
+    if (readers_.size() == 0) {
+      setHints(DecodeHints::DEFAULT_HINT);
+    }
+    return decodeInternal(image);
+  }
+
+  void MultiFormatReader::setHints(DecodeHints hints) {
+    hints_ = hints;
+    readers_.clear();
+    bool tryHarder = hints.getTryHarder();
+
+    bool addOneDReader = hints.containsFormat(BarcodeFormat_UPC_E) ||
+                         hints.containsFormat(BarcodeFormat_UPC_A) ||
+                         hints.containsFormat(BarcodeFormat_EAN_8) ||
+                         hints.containsFormat(BarcodeFormat_EAN_13) ||
+                         hints.containsFormat(BarcodeFormat_CODE_128) ||
+                         hints.containsFormat(BarcodeFormat_CODE_39) ||
+                         hints.containsFormat(BarcodeFormat_ITF);
+    if (addOneDReader && !tryHarder) {
+      readers_.push_back(Ref<Reader>(new zxing::oned::MultiFormatOneDReader(hints)));
+    }
+    if (hints.containsFormat(BarcodeFormat_QR_CODE)) {
+      readers_.push_back(Ref<Reader>(new zxing::qrcode::QRCodeReader()));
+    }
+    if (hints.containsFormat(BarcodeFormat_DATA_MATRIX)) {
+      readers_.push_back(Ref<Reader>(new zxing::datamatrix::DataMatrixReader()));
+    }
+    if (hints.containsFormat(BarcodeFormat_AZTEC)) {
+      readers_.push_back(Ref<Reader>(new zxing::aztec::AztecReader()));
+    }
+    //TODO: add PDF417 here once PDF417 reader is implemented
+    if (addOneDReader && tryHarder) {
+      readers_.push_back(Ref<Reader>(new zxing::oned::MultiFormatOneDReader(hints)));
+    }
+    if (readers_.size() == 0) {
+      if (!tryHarder) {
+        readers_.push_back(Ref<Reader>(new zxing::oned::MultiFormatOneDReader(hints)));
+      }
+      readers_.push_back(Ref<Reader>(new zxing::qrcode::QRCodeReader()));
+      if (tryHarder) {
+        readers_.push_back(Ref<Reader>(new zxing::oned::MultiFormatOneDReader(hints)));
+      }
+    }
+  }
+
+  Ref<Result> MultiFormatReader::decodeInternal(Ref<BinaryBitmap> image) {
+    for (unsigned int i = 0; i < readers_.size(); i++) {
+      try {
+        return readers_[i]->decode(image, hints_);
+      } catch (ReaderException const& re) {
+        // continue
+      }
+    }
+    throw ReaderException("No code detected");
+  }
+  
+  MultiFormatReader::~MultiFormatReader() {
+
+  }
+}

=== added file '3rdParty/zxing/MultiFormatReader.h'
--- 3rdParty/zxing/MultiFormatReader.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/MultiFormatReader.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,49 @@
+#ifndef __MULTI_FORMAT_READER_H__
+#define __MULTI_FORMAT_READER_H__
+
+/*
+ *  MultiFormatBarcodeReader.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/Reader.h>
+#include <zxing/common/BitArray.h>
+#include <zxing/Result.h>
+#include <zxing/DecodeHints.h>
+
+namespace zxing {
+  class MultiFormatReader : public Reader {
+    
+  private:
+    Ref<Result> decodeInternal(Ref<BinaryBitmap> image);
+  
+    std::vector<Ref<Reader> > readers_;
+    DecodeHints hints_;
+
+  public:
+    MultiFormatReader();
+    
+    Ref<Result> decode(Ref<BinaryBitmap> image);
+    Ref<Result> decode(Ref<BinaryBitmap> image, DecodeHints hints);
+    Ref<Result> decodeWithState(Ref<BinaryBitmap> image);
+    void setHints(DecodeHints hints);
+    ~MultiFormatReader();
+  };
+}
+
+#endif

=== added file '3rdParty/zxing/NotFoundException.cpp'
--- 3rdParty/zxing/NotFoundException.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/NotFoundException.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,28 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ * Copyright 20011 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/NotFoundException.h>
+
+namespace zxing {
+
+  NotFoundException::NotFoundException(const char *msg)
+    : ReaderException(msg) {}
+
+  NotFoundException::~NotFoundException() throw() {
+  }
+
+}

=== added file '3rdParty/zxing/NotFoundException.h'
--- 3rdParty/zxing/NotFoundException.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/NotFoundException.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,33 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+
+#ifndef __NOT_FOUND_EXCEPTION_H__
+#define __NOT_FOUND_EXCEPTION_H__
+
+/*
+ * Copyright 20011 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/ReaderException.h>
+
+namespace zxing {
+
+  class NotFoundException : public ReaderException {
+  public:
+    NotFoundException(const char *msg);
+    ~NotFoundException() throw();
+  };
+
+}
+#endif // __NOT_FOUND_EXCEPTION_H__

=== added file '3rdParty/zxing/Reader.cpp'
--- 3rdParty/zxing/Reader.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/Reader.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,31 @@
+/*
+ *  Reader.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/Reader.h>
+
+namespace zxing {
+
+Reader::~Reader() { }
+
+Ref<Result> Reader::decode(Ref<BinaryBitmap> image) {
+  return decode(image, DecodeHints::DEFAULT_HINT);
+}
+
+}

=== added file '3rdParty/zxing/Reader.h'
--- 3rdParty/zxing/Reader.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/Reader.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,40 @@
+#ifndef __READER_H__
+#define __READER_H__
+
+/*
+ *  Reader.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/BinaryBitmap.h>
+#include <zxing/Result.h>
+#include <zxing/DecodeHints.h>
+
+namespace zxing {
+
+ class Reader : public Counted {
+  protected:
+   Reader() {}
+  public:
+   virtual Ref<Result> decode(Ref<BinaryBitmap> image);
+   virtual Ref<Result> decode(Ref<BinaryBitmap> image, DecodeHints hints) = 0;
+   virtual ~Reader();
+};
+
+}
+
+#endif // __READER_H__

=== added file '3rdParty/zxing/ReaderException.cpp'
--- 3rdParty/zxing/ReaderException.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/ReaderException.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,35 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  ReaderException.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 13/05/2008.
+ *  Copyright 2008-2011 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>
+
+namespace zxing {
+
+ReaderException::ReaderException() {}
+
+ReaderException::ReaderException(const char *msg) :
+    Exception(msg) {
+}
+
+ReaderException::~ReaderException() throw() {
+}
+
+}

=== added file '3rdParty/zxing/ReaderException.h'
--- 3rdParty/zxing/ReaderException.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/ReaderException.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,35 @@
+#ifndef __READER_EXCEPTION_H__
+#define __READER_EXCEPTION_H__
+
+/*
+ *  ReaderException.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/Exception.h>
+
+namespace zxing {
+
+class ReaderException : public Exception {
+public:
+  ReaderException();
+  ReaderException(const char *msg);
+  ~ReaderException() throw();
+};
+
+}
+#endif // __READER_EXCEPTION_H__

=== added file '3rdParty/zxing/Result.cpp'
--- 3rdParty/zxing/Result.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/Result.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,64 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  Result.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/Result.h>
+
+namespace zxing {
+using namespace std;
+
+Result::Result(Ref<String> text, ArrayRef<unsigned char> rawBytes, std::vector<Ref<ResultPoint> > resultPoints,
+               BarcodeFormat format) :
+  text_(text), rawBytes_(rawBytes), resultPoints_(resultPoints), format_(format) {
+}
+
+Result::~Result() {
+}
+
+Ref<String> Result::getText() {
+  return text_;
+}
+
+ArrayRef<unsigned char> Result::getRawBytes() {
+  return rawBytes_;
+}
+
+const std::vector<Ref<ResultPoint> >& Result::getResultPoints() const {
+  return resultPoints_;
+}
+
+std::vector<Ref<ResultPoint> >& Result::getResultPoints() {
+  return resultPoints_;
+}
+
+BarcodeFormat Result::getBarcodeFormat() const {
+  return format_;
+}
+
+ostream& operator<<(ostream &out, Result& result) {
+  if (result.text_ != 0) {
+    out << result.text_->getText();
+  } else {
+    out << "[" << result.rawBytes_->size() << " bytes]";
+  }
+  return out;
+}
+
+}

=== added file '3rdParty/zxing/Result.h'
--- 3rdParty/zxing/Result.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/Result.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,54 @@
+#ifndef __RESULT_H__
+#define __RESULT_H__
+
+/*
+ *  Result.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 <vector>
+#include <zxing/common/Array.h>
+#include <zxing/common/Counted.h>
+#include <zxing/common/Str.h>
+#include <zxing/ResultPoint.h>
+#include <zxing/BarcodeFormat.h>
+
+namespace zxing {
+
+class Result : public Counted {
+private:
+  Ref<String> text_;
+  ArrayRef<unsigned char> rawBytes_;
+  std::vector<Ref<ResultPoint> > resultPoints_;
+  BarcodeFormat format_;
+
+public:
+  Result(Ref<String> text, ArrayRef<unsigned char> rawBytes, std::vector<Ref<ResultPoint> > resultPoints,
+         BarcodeFormat format);
+  ~Result();
+  Ref<String> getText();
+  ArrayRef<unsigned char> getRawBytes();
+  const std::vector<Ref<ResultPoint> >& getResultPoints() const;
+  std::vector<Ref<ResultPoint> >& getResultPoints();
+  BarcodeFormat getBarcodeFormat() const;
+
+  friend std::ostream& operator<<(std::ostream &out, Result& result);
+};
+
+}
+#endif // __RESULT_H__

=== added file '3rdParty/zxing/ResultPoint.cpp'
--- 3rdParty/zxing/ResultPoint.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/ResultPoint.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,100 @@
+/*
+ *  ResultPoint.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/ResultPoint.h>
+#include <math.h>
+
+namespace zxing {
+
+ResultPoint::ResultPoint() : posX_(0), posY_(0) {}
+
+ResultPoint::ResultPoint(float x, float y) : posX_(x), posY_(y) {}
+  
+ResultPoint::~ResultPoint() {}
+
+float ResultPoint::getX() const {
+  return posX_;
+}
+    
+float ResultPoint::getY() const {
+  return posY_;
+}
+
+bool ResultPoint::equals(Ref<ResultPoint> other) {
+  return posX_ == other->getX() && posY_ == other->getY();
+}
+
+/**
+ * <p>Orders an array of three ResultPoints in an order [A,B,C] such that AB < AC and
+ * BC < AC and the angle between BC and BA is less than 180 degrees.
+ */
+void ResultPoint::orderBestPatterns(std::vector<Ref<ResultPoint> > &patterns) {
+    // Find distances between pattern centers
+    float zeroOneDistance = distance(patterns[0]->getX(), patterns[1]->getX(),patterns[0]->getY(), patterns[1]->getY());
+    float oneTwoDistance = distance(patterns[1]->getX(), patterns[2]->getX(),patterns[1]->getY(), patterns[2]->getY());
+    float zeroTwoDistance = distance(patterns[0]->getX(), patterns[2]->getX(),patterns[0]->getY(), patterns[2]->getY());
+
+    Ref<ResultPoint> pointA, pointB, pointC;
+    // Assume one closest to other two is B; A and C will just be guesses at first
+    if (oneTwoDistance >= zeroOneDistance && oneTwoDistance >= zeroTwoDistance) {
+      pointB = patterns[0];
+      pointA = patterns[1];
+      pointC = patterns[2];
+    } else if (zeroTwoDistance >= oneTwoDistance && zeroTwoDistance >= zeroOneDistance) {
+      pointB = patterns[1];
+      pointA = patterns[0];
+      pointC = patterns[2];
+    } else {
+      pointB = patterns[2];
+      pointA = patterns[0];
+      pointC = patterns[1];
+    }
+
+    // Use cross product to figure out whether A and C are correct or flipped.
+    // This asks whether BC x BA has a positive z component, which is the arrangement
+    // we want for A, B, C. If it's negative, then we've got it flipped around and
+    // should swap A and C.
+    if (crossProductZ(pointA, pointB, pointC) < 0.0f) {
+      Ref<ResultPoint> temp = pointA;
+      pointA = pointC;
+      pointC = temp;
+    }
+
+    patterns[0] = pointA;
+    patterns[1] = pointB;
+    patterns[2] = pointC;
+}
+
+float ResultPoint::distance(Ref<ResultPoint> point1, Ref<ResultPoint> point2) {
+  return distance(point1->getX(), point1->getY(), point2->getX(), point2->getY());
+}
+
+float ResultPoint::distance(float x1, float x2, float y1, float y2) {
+  float xDiff = x1 - x2;
+  float yDiff = y1 - y2;
+  return (float) sqrt((double) (xDiff * xDiff + yDiff * yDiff));
+}
+
+float ResultPoint::crossProductZ(Ref<ResultPoint> pointA, Ref<ResultPoint> pointB, Ref<ResultPoint> pointC) {
+  float bX = pointB->getX();
+  float bY = pointB->getY();
+  return ((pointC->getX() - bX) * (pointA->getY() - bY)) - ((pointC->getY() - bY) * (pointA->getX() - bX));
+}
+}

=== added file '3rdParty/zxing/ResultPoint.h'
--- 3rdParty/zxing/ResultPoint.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/ResultPoint.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,54 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __RESULT_POINT_H__
+#define __RESULT_POINT_H__
+
+/*
+ *  ResultPoint.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 <vector>
+
+namespace zxing {
+
+class ResultPoint : public Counted {
+protected:
+  float posX_;
+  float posY_;
+  
+public:
+  ResultPoint();
+  ResultPoint(float x, float y);
+  virtual ~ResultPoint();
+
+  virtual float getX() const;
+  virtual float getY() const;
+
+  bool equals(Ref<ResultPoint> other);
+
+  static void orderBestPatterns(std::vector<Ref<ResultPoint> > &patterns);
+  static float distance(Ref<ResultPoint> point1, Ref<ResultPoint> point2);
+  static float distance(float x1, float x2, float y1, float y2);
+
+private:
+  static float crossProductZ(Ref<ResultPoint> pointA, Ref<ResultPoint> pointB, Ref<ResultPoint> pointC);
+};
+
+}
+
+#endif // __RESULT_POINT_H__

=== added file '3rdParty/zxing/ResultPointCallback.cpp'
--- 3rdParty/zxing/ResultPointCallback.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/ResultPointCallback.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,26 @@
+/*
+ *  ResultPointCallback.cpp
+ *  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/ResultPointCallback.h>
+
+namespace zxing {
+
+ResultPointCallback::~ResultPointCallback() {}
+
+}

=== added file '3rdParty/zxing/ResultPointCallback.h'
--- 3rdParty/zxing/ResultPointCallback.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/ResultPointCallback.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,39 @@
+#ifndef __RESULT_POINT_CALLBACK_H__
+#define __RESULT_POINT_CALLBACK_H__
+
+/*
+ *  ResultPointCallback.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>
+
+namespace zxing {
+
+class ResultPoint;
+
+class ResultPointCallback : public Counted {
+protected:
+  ResultPointCallback() {}
+public:
+  virtual void foundPossibleResultPoint(ResultPoint const& point) = 0;
+  virtual ~ResultPointCallback();
+};
+
+}
+
+#endif // __RESULT_POINT_CALLBACK_H__

=== added directory '3rdParty/zxing/aztec'
=== added file '3rdParty/zxing/aztec/AztecDetectorResult.cpp'
--- 3rdParty/zxing/aztec/AztecDetectorResult.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/aztec/AztecDetectorResult.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,45 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  AtztecDetecorResult.cpp
+ *  zxing
+ *
+ *  Created by Lukas Stabe on 08/02/2012.
+ *  Copyright 2012 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/aztec/AztecDetectorResult.h>
+
+namespace zxing {
+    namespace aztec {
+        AztecDetectorResult::AztecDetectorResult(Ref<BitMatrix> bits, std::vector<Ref<ResultPoint> > points, bool compact, int nbDatablocks, int nbLayers)
+        : DetectorResult(bits, points),
+        compact_(compact),
+        nbDatablocks_(nbDatablocks),
+        nbLayers_(nbLayers) {
+        }
+        
+        bool AztecDetectorResult::isCompact() {
+            return compact_;
+        }
+        
+        int AztecDetectorResult::getNBDatablocks() {
+            return nbDatablocks_;
+        }
+        
+        int AztecDetectorResult::getNBLayers() {
+            return nbLayers_;
+        }
+    }
+}

=== added file '3rdParty/zxing/aztec/AztecDetectorResult.h'
--- 3rdParty/zxing/aztec/AztecDetectorResult.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/aztec/AztecDetectorResult.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,42 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  AtztecDetecorResult.h
+ *  zxing
+ *
+ *  Created by Lukas Stabe on 08/02/2012.
+ *  Copyright 2012 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/DetectorResult.h>
+
+#ifndef ZXingWidget_AtztecDetecorResult_h
+#define ZXingWidget_AtztecDetecorResult_h
+
+namespace zxing {
+    namespace aztec {
+        class AztecDetectorResult : public DetectorResult {
+        private:
+            bool compact_;
+            int nbDatablocks_, nbLayers_;
+        public:
+            AztecDetectorResult(Ref<BitMatrix> bits, std::vector<Ref<ResultPoint> > points, bool compact, int nbDatablocks, int nbLayers);
+            bool isCompact();
+            int getNBDatablocks();
+            int getNBLayers();
+        };
+    }
+}
+
+#endif

=== added file '3rdParty/zxing/aztec/AztecReader.cpp'
--- 3rdParty/zxing/aztec/AztecReader.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/aztec/AztecReader.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,64 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  AztecReader.cpp
+ *  zxing
+ *
+ *  Created by Lukas Stabe on 08/02/2012.
+ *  Copyright 2012 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/aztec/AztecReader.h>
+#include <zxing/aztec/detector/Detector.h>
+#include <iostream>
+
+namespace zxing {
+  namespace aztec {
+        
+    AztecReader::AztecReader() : decoder_() {
+      // nothing
+    }
+        
+    Ref<Result> AztecReader::decode(Ref<zxing::BinaryBitmap> image) {
+      Detector detector(image->getBlackMatrix());
+            
+      Ref<AztecDetectorResult> detectorResult(detector.detect());
+            
+      std::vector<Ref<ResultPoint> > points(detectorResult->getPoints());
+            
+      Ref<DecoderResult> decoderResult(decoder_.decode(detectorResult));
+            
+      Ref<Result> result(new Result(decoderResult->getText(),
+                                    decoderResult->getRawBytes(),
+                                    points,
+                                    BarcodeFormat_AZTEC));
+            
+      return result;
+    }
+        
+    Ref<Result> AztecReader::decode(Ref<BinaryBitmap> image, DecodeHints) {
+      //cout << "decoding with hints not supported for aztec" << "\n" << flush;
+      return this->decode(image);
+    }
+        
+    AztecReader::~AztecReader() {
+      // nothing
+    }
+        
+    Decoder& AztecReader::getDecoder() {
+      return decoder_;
+    }
+        
+  }
+}

=== added file '3rdParty/zxing/aztec/AztecReader.h'
--- 3rdParty/zxing/aztec/AztecReader.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/aztec/AztecReader.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,49 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  AztecReader.h
+ *  zxing
+ *
+ *  Created by Lukas Stabe on 08/02/2012.
+ *  Copyright 2012 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/Reader.h>
+#include <zxing/aztec/decoder/Decoder.h>
+#include <zxing/DecodeHints.h>
+
+#ifndef ZXingWidget_AztecReader_h
+#define ZXingWidget_AztecReader_h
+
+namespace zxing {
+    namespace aztec {
+        
+        class AztecReader : public Reader {
+        private:
+            Decoder decoder_;
+            
+        protected:
+            Decoder &getDecoder();
+            
+        public:
+            AztecReader();
+            virtual Ref<Result> decode(Ref<BinaryBitmap> image);
+            virtual Ref<Result> decode(Ref<BinaryBitmap> image, DecodeHints hints);
+            virtual ~AztecReader();
+        };
+        
+    }
+}
+
+#endif

=== added directory '3rdParty/zxing/aztec/decoder'
=== added file '3rdParty/zxing/aztec/decoder/AztecDecoder.cpp'
--- 3rdParty/zxing/aztec/decoder/AztecDecoder.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/aztec/decoder/AztecDecoder.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,496 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  Decoder.cpp
+ *  zxing
+ *
+ *  Created by Lukas Stabe on 08/02/2012.
+ *  Copyright 2012 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/aztec/decoder/Decoder.h>
+#ifndef NO_ICONV
+#include <iconv.h>
+#endif
+#include <iostream>
+#include <zxing/FormatException.h>
+#include <zxing/common/reedsolomon/ReedSolomonDecoder.h>
+#include <zxing/common/reedsolomon/ReedSolomonException.h>
+#include <zxing/common/reedsolomon/GenericGF.h>
+#include <zxing/common/IllegalArgumentException.h>
+
+#include <qglobal.h>
+
+using zxing::aztec::Decoder;
+using zxing::DecoderResult;
+using zxing::String;
+using zxing::BitArray;
+using zxing::BitMatrix;
+using zxing::Ref;
+
+using std::string;
+
+namespace {
+  void add(string& result, unsigned char character) {
+#ifndef NO_ICONV
+    char s[] = { character & 0xff };
+    char* ss = s;
+    size_t sl = sizeof(s);
+    char d[4];
+    char* ds = d;
+    size_t dl = sizeof(d);
+    iconv_t ic = iconv_open("UTF-8", "ISO-8859-1");
+
+
+#if defined(Q_OS_SYMBIAN)
+    iconv(ic, (const char**)&ss, &sl, &ds, &dl); // for Symbian and Mingw
+#else
+    iconv(ic, (char**)&ss, &sl, &ds, &dl); // for Harmattan
+#endif
+    iconv_close(ic);
+    d[sizeof(d)-dl] = 0;
+    result.append(d);
+#else
+    result.push_back(character);
+#endif
+  }
+
+  const int NB_BITS_COMPACT[] = {
+    0, 104, 240, 408, 608
+  };
+        
+  const int NB_BITS[] = {
+    0, 128, 288, 480, 704, 960, 1248, 1568, 1920, 2304, 2720, 3168, 3648, 4160, 4704, 5280, 5888, 6528,
+    7200, 7904, 8640, 9408, 10208, 11040, 11904, 12800, 13728, 14688, 15680, 16704, 17760, 18848, 19968
+  };
+        
+  const int NB_DATABLOCK_COMPACT[] = {
+    0, 17, 40, 51, 76
+  };
+        
+  const int NB_DATABLOCK[] = {
+    0, 21, 48, 60, 88, 120, 156, 196, 240, 230, 272, 316, 364, 416, 470, 528, 588, 652, 720, 790, 864,
+    940, 1020, 920, 992, 1066, 1144, 1224, 1306, 1392, 1480, 1570, 1664
+  };
+        
+  const char* UPPER_TABLE[] = {
+    "CTRL_PS", " ", "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", "CTRL_LL", "CTRL_ML", "CTRL_DL", "CTRL_BS"
+  };
+        
+  const char* LOWER_TABLE[] = {
+    "CTRL_PS", " ", "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", "CTRL_US", "CTRL_ML", "CTRL_DL", "CTRL_BS"
+  };
+        
+  const char* MIXED_TABLE[] = {
+    "CTRL_PS", " ", "\1", "\2", "\3", "\4", "\5", "\6", "\7", "\b", "\t", "\n",
+    "\13", "\f", "\r", "\33", "\34", "\35", "\36", "\37", "@", "\\", "^", "_",
+    "`", "|", "~", "\177", "CTRL_LL", "CTRL_UL", "CTRL_PL", "CTRL_BS"
+  };
+        
+  const char* PUNCT_TABLE[] = {
+    "", "\r", "\r\n", ". ", ", ", ": ", "!", "\"", "#", "$", "%", "&", "'", "(", ")",
+    "*", "+", ",", "-", ".", "/", ":", ";", "<", "=", ">", "?", "[", "]", "{", "}", "CTRL_UL"
+  };
+        
+  const char* DIGIT_TABLE[] = {
+    "CTRL_PS", " ", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ",", ".", "CTRL_UL", "CTRL_US"
+  };
+}
+        
+Decoder::Table Decoder::getTable(char t) {
+  switch (t) {
+  case 'L':
+    return LOWER;
+  case 'P':
+    return PUNCT;
+  case 'M':
+    return MIXED;
+  case 'D':
+    return DIGIT;
+  case 'B':
+    return BINARY;
+  case 'U':
+  default:
+    return UPPER;
+  }
+}
+        
+const char* Decoder::getCharacter(zxing::aztec::Decoder::Table table, int code) {
+  switch (table) {
+  case UPPER:
+    return UPPER_TABLE[code];
+  case LOWER:
+    return LOWER_TABLE[code];
+  case MIXED:
+    return MIXED_TABLE[code];
+  case PUNCT:
+    return PUNCT_TABLE[code];
+  case DIGIT:
+    return DIGIT_TABLE[code];
+  default:
+    return "";
+  }
+}
+        
+Decoder::Decoder() {
+  // nothing
+}
+        
+Ref<DecoderResult> Decoder::decode(Ref<zxing::aztec::AztecDetectorResult> detectorResult) {
+  ddata_ = detectorResult;
+            
+  // std::printf("getting bits\n");
+            
+  Ref<BitMatrix> matrix = detectorResult->getBits();
+            
+  if (!ddata_->isCompact()) {
+    // std::printf("removing lines\n");
+    matrix = removeDashedLines(ddata_->getBits());
+  }
+            
+  // std::printf("extracting bits\n");
+  Ref<BitArray> rawbits = extractBits(matrix);
+            
+  // std::printf("correcting bits\n");
+  Ref<BitArray> aCorrectedBits = correctBits(rawbits);
+            
+  // std::printf("decoding bits\n");
+  Ref<String> result = getEncodedData(aCorrectedBits);
+            
+  // std::printf("constructing array\n");
+  ArrayRef<unsigned char> arrayOut(aCorrectedBits->getSize());
+  for (int i = 0; i < aCorrectedBits->count(); i++) {
+    arrayOut[i] = (unsigned char)aCorrectedBits->get(i);
+  }
+            
+  // std::printf("returning\n");
+            
+  return Ref<DecoderResult>(new DecoderResult(arrayOut, result));
+}
+        
+Ref<String> Decoder::getEncodedData(Ref<zxing::BitArray> correctedBits) {
+  int endIndex = codewordSize_ * ddata_->getNBDatablocks() - invertedBitCount_;
+  if (endIndex > (int)correctedBits->getSize()) {
+    // std::printf("invalid input\n");
+    throw FormatException("invalid input data");
+  }
+            
+  Table lastTable = UPPER;
+  Table table = UPPER;
+  int startIndex = 0;
+  std::string result;
+  bool end = false;
+  bool shift = false;
+  bool switchShift = false;
+  bool binaryShift = false;
+            
+  while (!end) {
+    // std::printf("decoooooding\n");
+                
+    if (shift) {
+      switchShift = true;
+    } else {
+      lastTable = table;
+    }
+                
+    int code;
+    if (binaryShift) {
+      if (endIndex - startIndex < 5) {
+        break;
+      }
+                    
+      int length = readCode(correctedBits, startIndex, 5);
+      startIndex += 5;
+      if (length == 0) {
+        if (endIndex - startIndex < 11) {
+          break;
+        }
+                        
+        length = readCode(correctedBits, startIndex, 11) + 31;
+        startIndex += 11;
+      }
+      for (int charCount = 0; charCount < length; charCount++) {
+        if (endIndex - startIndex < 8) {
+          end = true;
+          break;
+        }
+                        
+        code = readCode(correctedBits, startIndex, 8);
+        add(result, code);
+        startIndex += 8;
+      }
+      binaryShift = false;
+    } else {
+      if (table == BINARY) {
+        if (endIndex - startIndex < 8) {
+          end = true;
+          break;
+        }
+        code = readCode(correctedBits, startIndex, 8);
+        startIndex += 8;
+                        
+        add(result, code);
+      } else {
+        int size = 5;
+                        
+        if (table == DIGIT) {
+          size = 4;
+        }
+                        
+        if (endIndex - startIndex < size) {
+          end = true;
+          break;
+        }
+                        
+        code = readCode(correctedBits, startIndex, size);
+        startIndex += size;
+                        
+        const char *str = getCharacter(table, code);
+        std::string string(str);
+        if ((int)string.find("CTRL_") != -1) {
+          table = getTable(str[5]);
+                            
+          if (str[6] == 'S') {
+            shift = true;
+            if (str[5] == 'B') {
+              binaryShift = true;
+            }
+          }
+        } else {
+          result.append(string);
+        }
+                        
+      }
+    }
+                
+    if (switchShift) {
+      table = lastTable;
+      shift = false;
+      switchShift = false;
+    }
+                
+                
+  }
+            
+  return Ref<String>(new String(result));
+            
+}
+        
+Ref<zxing::BitArray> Decoder::correctBits(Ref<zxing::BitArray> rawbits) {
+  //return rawbits;
+  // std::printf("decoding stuff:%d datablocks in %d layers\n", ddata_->getNBDatablocks(), ddata_->getNBLayers());
+            
+  Ref<GenericGF> gf = GenericGF::AZTEC_DATA_6;
+            
+  if (ddata_->getNBLayers() <= 2) {
+    codewordSize_ = 6;
+    gf = GenericGF::AZTEC_DATA_6;
+  } else if (ddata_->getNBLayers() <= 8) {
+    codewordSize_ = 8;
+    gf = GenericGF::AZTEC_DATA_8;
+  } else if (ddata_->getNBLayers() <= 22) {
+    codewordSize_ = 10;
+    gf = GenericGF::AZTEC_DATA_10;
+  } else {
+    codewordSize_ = 12;
+    gf = GenericGF::AZTEC_DATA_12;
+  }
+            
+  int numDataCodewords = ddata_->getNBDatablocks();
+  int numECCodewords;
+  int offset;
+            
+  if (ddata_->isCompact()) {
+    offset = NB_BITS_COMPACT[ddata_->getNBLayers()] - numCodewords_ * codewordSize_;
+    numECCodewords = NB_DATABLOCK_COMPACT[ddata_->getNBLayers()] - numDataCodewords;
+  } else {
+    offset = NB_BITS[ddata_->getNBLayers()] - numCodewords_ * codewordSize_;
+    numECCodewords = NB_DATABLOCK[ddata_->getNBLayers()] - numDataCodewords;
+  }
+            
+  ArrayRef<int> dataWords(numCodewords_);
+            
+  for (int i = 0; i < numCodewords_; i++) {
+    int flag = 1;
+    for (int j = 1; j <= codewordSize_; j++) {
+      if (rawbits->get(codewordSize_ * i + codewordSize_ - j + offset)) {
+        dataWords[i] += flag;
+      }
+      flag <<= 1;
+    }
+                
+    //
+    //
+    //
+  }
+            
+  try {
+    // std::printf("trying reed solomon, numECCodewords:%d\n", numECCodewords);
+    ReedSolomonDecoder rsDecoder(gf);
+    rsDecoder.decode(dataWords, numECCodewords);
+  } catch (ReedSolomonException& rse) {
+    // std::printf("got reed solomon exception:%s, throwing formatexception\n", rse.what());
+    throw FormatException("rs decoding failed");
+  } catch (IllegalArgumentException& iae) {
+    // std::printf("illegal argument exception: %s", iae.what());
+  }
+            
+  offset = 0;
+  invertedBitCount_ = 0;
+            
+  Ref<BitArray> correctedBits(new BitArray(numDataCodewords * codewordSize_));
+  for (int i = 0; i < numDataCodewords; i++) {
+                
+    bool seriesColor = false;
+    int seriesCount = 0;
+    int flag = 1 << (codewordSize_ - 1);
+                
+    for (int j = 0; j < codewordSize_; j++) {
+                    
+      bool color = (dataWords[i] & flag) == flag;
+                    
+      if (seriesCount == codewordSize_ - 1) {
+                        
+        if (color == seriesColor) {
+          throw FormatException("bit was not inverted");
+        }
+                        
+        seriesColor = false;
+        seriesCount = 0;
+        offset++;
+        invertedBitCount_++;
+                        
+      } else {
+                        
+        if (seriesColor == color) {
+          seriesCount++;
+        } else {
+          seriesCount = 1;
+          seriesColor = color;
+        }
+                        
+        if (color) correctedBits->set(i * codewordSize_ + j - offset);
+                        
+      }
+                    
+      flag = (unsigned int)flag >> 1;
+                    
+    }
+  }
+            
+  return correctedBits;
+}
+        
+Ref<BitArray> Decoder::extractBits(Ref<zxing::BitMatrix> matrix) {
+  std::vector<bool> rawbits;
+            
+  if (ddata_->isCompact()) {
+    if (ddata_->getNBLayers() > 5) { //NB_BITS_COMPACT length
+      throw FormatException("data is too long");
+    }
+    rawbits = std::vector<bool>(NB_BITS_COMPACT[ddata_->getNBLayers()]);
+    numCodewords_ = NB_DATABLOCK_COMPACT[ddata_->getNBLayers()];
+  } else {
+    if (ddata_->getNBLayers() > 33) { //NB_BITS length
+      throw FormatException("data is too long");
+    }
+    rawbits = std::vector<bool>(NB_BITS[ddata_->getNBLayers()]);
+    numCodewords_ = NB_DATABLOCK[ddata_->getNBLayers()];
+  }
+            
+  int layer = ddata_->getNBLayers();
+  int size = matrix->getHeight();
+  int rawbitsOffset = 0;
+  int matrixOffset = 0;
+            
+
+  while (layer != 0) {
+                
+    int flip = 0;
+    for (int i = 0; i < 2 * size - 4; i++) {
+      rawbits[rawbitsOffset + i] = matrix->get(matrixOffset + flip, matrixOffset + i / 2);
+      rawbits[rawbitsOffset + 2 * size - 4 + i] = matrix->get(matrixOffset + i / 2, matrixOffset + size - 1 - flip);
+      flip = (flip + 1) % 2;
+    }
+                
+    flip = 0;
+    for (int i = 2 * size + 1; i > 5; i--) {
+      rawbits[rawbitsOffset + 4 * size - 8 + (2 * size - i) + 1] =
+        matrix->get(matrixOffset + size - 1 - flip, matrixOffset + i / 2 - 1);
+      rawbits[rawbitsOffset + 6 * size - 12 + (2 * size - i) + 1] =
+        matrix->get(matrixOffset + i / 2 - 1, matrixOffset + flip);
+      flip = (flip + 1) % 2;
+    }
+                
+    matrixOffset += 2;
+    rawbitsOffset += 8 * size - 16;
+    layer--;
+    size -= 4;
+                
+  }
+            
+  Ref<BitArray> returnValue(new BitArray(rawbits.size()));
+  for (int i = 0; i < (int)rawbits.size(); i++) {
+    if (rawbits[i]) returnValue->set(i);
+  }
+            
+  return returnValue;
+            
+}
+        
+Ref<BitMatrix> Decoder::removeDashedLines(Ref<zxing::BitMatrix> matrix) {
+  int nbDashed = 1 + 2 * ((matrix->getWidth() - 1) / 2 / 16);
+  Ref<BitMatrix> newMatrix(new BitMatrix(matrix->getWidth() - nbDashed, matrix->getHeight() - nbDashed));
+            
+  int nx = 0;
+            
+  for (int x = 0; x < (int)matrix->getWidth(); x++) {
+                
+    if ((matrix->getWidth() / 2 - x) % 16 == 0) {
+      continue;
+    }
+                
+    int ny = 0;
+    for (int y = 0; y < (int)matrix->getHeight(); y++) {
+                    
+      if ((matrix->getWidth() / 2 - y) % 16 == 0) {
+        continue;
+      }
+                    
+      if (matrix->get(x, y)) {
+        newMatrix->set(nx, ny);
+      }
+      ny++;
+                    
+    }
+    nx++;
+                
+  }
+  return newMatrix;
+}
+        
+int Decoder::readCode(Ref<zxing::BitArray> rawbits, int startIndex, int length) {
+  int res = 0;
+            
+  for (int i = startIndex; i < startIndex + length; i++) {
+    res <<= 1;
+    if (rawbits->get(i)) {
+      res ++;
+    }
+  }
+            
+  return res;
+}

=== added file '3rdParty/zxing/aztec/decoder/Decoder.h'
--- 3rdParty/zxing/aztec/decoder/Decoder.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/aztec/decoder/Decoder.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,63 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  Decoder.h
+ *  zxing
+ *
+ *  Created by Lukas Stabe on 08/02/2012.
+ *  Copyright 2012 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/DecoderResult.h>
+#include <zxing/common/BitMatrix.h>
+#include <zxing/common/Str.h>
+#include <zxing/aztec/AztecDetectorResult.h>
+
+namespace zxing {
+    namespace aztec {
+        
+        class Decoder : public Counted {
+        private:
+            enum Table {
+                UPPER,
+                LOWER,
+                MIXED,
+                DIGIT,
+                PUNCT,
+                BINARY
+            };
+            
+            static Table getTable(char t);
+            static const char* getCharacter(Table table, int code);
+            
+            int numCodewords_;
+            int codewordSize_;
+            Ref<AztecDetectorResult> ddata_;
+            int invertedBitCount_;
+            
+            Ref<String> getEncodedData(Ref<BitArray> correctedBits);
+            Ref<BitArray> correctBits(Ref<BitArray> rawbits);
+            Ref<BitArray> extractBits(Ref<BitMatrix> matrix);
+            static Ref<BitMatrix> removeDashedLines(Ref<BitMatrix> matrix);
+            static int readCode(Ref<BitArray> rawbits, int startIndex, int length);
+            
+            
+        public:
+            Decoder();
+            Ref<DecoderResult> decode(Ref<AztecDetectorResult> detectorResult);
+        };
+        
+    }
+}
+

=== added directory '3rdParty/zxing/aztec/detector'
=== added file '3rdParty/zxing/aztec/detector/AztecDetector.cpp'
--- 3rdParty/zxing/aztec/detector/AztecDetector.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/aztec/detector/AztecDetector.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,541 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  Detector.cpp
+ *  zxing
+ *
+ *  Created by Lukas Stabe on 08/02/2012.
+ *  Copyright 2012 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/aztec/detector/Detector.h>
+#include <zxing/common/GridSampler.h>
+#include <zxing/common/detector/WhiteRectangleDetector.h>
+#include <zxing/common/reedsolomon/ReedSolomonDecoder.h>
+#include <zxing/common/reedsolomon/ReedSolomonException.h>
+#include <zxing/common/reedsolomon/GenericGF.h>
+#include <iostream>
+#include <cmath>
+#include <zxing/NotFoundException.h>
+
+using zxing::aztec::Detector;
+using zxing::aztec::Point;
+using zxing::aztec::AztecDetectorResult;
+using zxing::Ref;
+using zxing::ResultPoint;
+using zxing::BitArray;
+using zxing::BitMatrix;
+                
+Detector::Detector(Ref<BitMatrix> image):
+  image_(image),
+  nbLayers_(0),
+  nbDataBlocks_(0),
+  nbCenterLayers_(0) {
+        
+}
+        
+// using namespace std;
+
+Ref<AztecDetectorResult> Detector::detect() {
+  Ref<Point> pCenter = getMatrixCenter();
+            
+  std::vector<Ref<Point> > bullEyeCornerPoints = getBullEyeCornerPoints(pCenter);
+            
+  extractParameters(bullEyeCornerPoints);
+            
+  std::vector<Ref<ResultPoint> > corners = getMatrixCornerPoints(bullEyeCornerPoints);
+            
+  Ref<BitMatrix> bits = sampleGrid(image_, corners[shift_%4], corners[(shift_+3)%4], corners[(shift_+2)%4], corners[(shift_+1)%4]);
+            
+  // std::printf("------------\ndetected: compact:%s, nbDataBlocks:%d, nbLayers:%d\n------------\n",compact_?"YES":"NO", nbDataBlocks_, nbLayers_);
+            
+  return Ref<AztecDetectorResult>(new AztecDetectorResult(bits, corners, compact_, nbDataBlocks_, nbLayers_));
+}
+        
+void Detector::extractParameters(std::vector<Ref<Point> > bullEyeCornerPoints) {
+  // get the bits around the bull's eye
+  Ref<BitArray> resab = sampleLine(bullEyeCornerPoints[0], bullEyeCornerPoints[1], 2*nbCenterLayers_+1);
+  Ref<BitArray> resbc = sampleLine(bullEyeCornerPoints[1], bullEyeCornerPoints[2], 2*nbCenterLayers_+1);
+  Ref<BitArray> rescd = sampleLine(bullEyeCornerPoints[2], bullEyeCornerPoints[3], 2*nbCenterLayers_+1);
+  Ref<BitArray> resda = sampleLine(bullEyeCornerPoints[3], bullEyeCornerPoints[0], 2*nbCenterLayers_+1);
+        
+  // determin the orientation of the matrix
+  if (resab->get(0) && resab->get(2 * nbCenterLayers_)) {
+    shift_ = 0;
+  } else if (resbc->get(0) && resbc->get(2 * nbCenterLayers_)) {
+    shift_ = 1;
+  } else if (rescd->get(0) && rescd->get(2 * nbCenterLayers_)) {
+    shift_ = 2;
+  } else if (resda->get(0) && resda->get(2 * nbCenterLayers_)) {
+    shift_ = 3;
+  } else {
+    // std::printf("could not detemine orientation\n");
+    throw ReaderException("could not determine orientation");
+  }
+            
+  //d      a
+  //
+  //c      b
+            
+  //flatten the bits in a single array
+  Ref<BitArray> parameterData(new BitArray(compact_?28:40));
+  Ref<BitArray> shiftedParameterData(new BitArray(compact_?28:40));
+            
+  if (compact_) {
+    for (int i = 0; i < 7; i++) {
+      if (resab->get(2+i)) shiftedParameterData->set(i);
+      if (resbc->get(2+i)) shiftedParameterData->set(i+7);
+      if (rescd->get(2+i)) shiftedParameterData->set(i+14);
+      if (resda->get(2+i)) shiftedParameterData->set(i+21);
+    }
+    for (int i = 0; i < 28; i++) {
+      if (shiftedParameterData->get((i+shift_*7)%28)) parameterData->set(i);
+    }
+                
+  } else {
+    for (int i = 0; i < 11; i++) {
+      if (i < 5) {
+        if (resab->get(2+i)) shiftedParameterData->set(i);
+        if (resbc->get(2+i)) shiftedParameterData->set(i+10);
+        if (rescd->get(2+i)) shiftedParameterData->set(i+20);
+        if (resda->get(2+i)) shiftedParameterData->set(i+30);
+      }
+      if (i > 5) {
+        if (resab->get(2+i)) shiftedParameterData->set(i-1);
+        if (resbc->get(2+i)) shiftedParameterData->set(i+10-1);
+        if (rescd->get(2+i)) shiftedParameterData->set(i+20-1);
+        if (resda->get(2+i)) shiftedParameterData->set(i+30-1);
+      }
+    }
+    for (int i = 0; i < 40; i++) {
+      if (shiftedParameterData->get((i+shift_*10)%40)) parameterData->set(i);
+    }
+  }
+            
+  correctParameterData(parameterData, compact_);
+            
+  getParameters(parameterData);
+}
+        
+std::vector<Ref<ResultPoint> > Detector::getMatrixCornerPoints(std::vector<Ref<Point> > bullEyeCornerPoints) {
+  float ratio = (2 * nbLayers_ + (nbLayers_ > 4 ? 1 : 0) + (nbLayers_ - 4) / 8) / (2.0f * nbCenterLayers_);
+            
+  int dx = bullEyeCornerPoints[0]->x - bullEyeCornerPoints[2]->x;
+  dx += dx > 0 ? 1 : -1;
+  int dy = bullEyeCornerPoints[0]->y - bullEyeCornerPoints[2]->y;
+  dy += dy > 0 ? 1 : -1;
+            
+  int targetcx = ROUND(bullEyeCornerPoints[2]->x - ratio * dx);
+  int targetcy = ROUND(bullEyeCornerPoints[2]->y - ratio * dy);
+            
+  int targetax = ROUND(bullEyeCornerPoints[0]->x + ratio * dx);
+  int targetay = ROUND(bullEyeCornerPoints[0]->y + ratio * dy);
+            
+  dx = bullEyeCornerPoints[1]->x - bullEyeCornerPoints[3]->x;
+  dx += dx > 0 ? 1 : -1;
+  dy = bullEyeCornerPoints[1]->y - bullEyeCornerPoints[3]->y;
+  dy += dy > 0 ? 1 : -1;
+            
+  int targetdx = ROUND(bullEyeCornerPoints[3]->x - ratio * dx);
+  int targetdy = ROUND(bullEyeCornerPoints[3]->y - ratio * dy);
+  int targetbx = ROUND(bullEyeCornerPoints[1]->x + ratio * dx);
+  int targetby = ROUND(bullEyeCornerPoints[1]->y + ratio * dy);
+            
+  if (!isValid(targetax, targetay) ||
+      !isValid(targetbx, targetby) ||
+      !isValid(targetcx, targetcy) ||
+      !isValid(targetdx, targetdy)) {
+    throw ReaderException("matrix extends over image bounds");
+  }
+  std::vector<Ref<ResultPoint> > returnValue;
+  returnValue.push_back(Ref<ResultPoint>(new ResultPoint(targetax, targetay)));
+  returnValue.push_back(Ref<ResultPoint>(new ResultPoint(targetbx, targetby)));
+  returnValue.push_back(Ref<ResultPoint>(new ResultPoint(targetcx, targetcy)));
+  returnValue.push_back(Ref<ResultPoint>(new ResultPoint(targetdx, targetdy)));
+                
+  return returnValue;
+            
+}
+        
+void Detector::correctParameterData(Ref<zxing::BitArray> parameterData, bool compact) {
+  int numCodewords;
+  int numDataCodewords;
+            
+  if (compact)  {
+    numCodewords = 7;
+    numDataCodewords = 2;
+  } else {
+    numCodewords = 10;
+    numDataCodewords = 4;
+  }
+            
+  int numECCodewords = numCodewords - numDataCodewords;
+            
+  ArrayRef<int> parameterWords(new Array<int>(numCodewords));
+            
+  int codewordSize = 4;
+  for (int i = 0; i < numCodewords; i++) {
+    int flag = 1;
+    for (int j = 1; j <= codewordSize; j++) {
+      if (parameterData->get(codewordSize*i + codewordSize - j)) {
+        parameterWords[i] += flag;
+      }
+      flag <<= 1;
+    }
+  }
+                        
+  try {
+    // std::printf("parameter data reed solomon\n");
+    ReedSolomonDecoder rsDecoder(GenericGF::AZTEC_PARAM);
+    rsDecoder.decode(parameterWords, numECCodewords);
+  } catch (ReedSolomonException& e) {
+    // std::printf("reed solomon decoding failed\n");
+    throw ReaderException("failed to decode parameter data");
+  }
+            
+  parameterData->clear();
+  for (int i = 0; i < numDataCodewords; i++) {
+    int flag = 1;
+    for (int j = 1; j <= codewordSize; j++) {
+      if ((parameterWords[i] & flag) == flag) {
+        parameterData->set(i*codewordSize+codewordSize-j);
+      }
+      flag <<= 1;
+    }
+  }
+}
+        
+std::vector<Ref<Point> > Detector::getBullEyeCornerPoints(Ref<zxing::aztec::Point> pCenter) {
+  Ref<Point> pina = pCenter;
+  Ref<Point> pinb = pCenter;
+  Ref<Point> pinc = pCenter;
+  Ref<Point> pind = pCenter;
+            
+  bool color = true;
+            
+  for (nbCenterLayers_ = 1; nbCenterLayers_ < 9; nbCenterLayers_++) {
+    Ref<Point> pouta = getFirstDifferent(pina, color, 1, -1);
+    Ref<Point> poutb = getFirstDifferent(pinb, color, 1, 1);
+    Ref<Point> poutc = getFirstDifferent(pinc, color, -1, 1);
+    Ref<Point> poutd = getFirstDifferent(pind, color, -1, -1);
+            
+    //d    a
+    //
+    //c    b
+                
+    if (nbCenterLayers_ > 2) {
+      float q = distance(poutd, pouta) * nbCenterLayers_ / (distance(pind, pina) * (nbCenterLayers_ + 2));
+      if (q < 0.75 || q > 1.25 || !isWhiteOrBlackRectangle(pouta, poutb, poutc, poutd)) {
+        break;
+      }
+    }
+                
+    pina = pouta;
+    pinb = poutb;
+    pinc = poutc;
+    pind = poutd;
+                
+    color = !color;
+  }
+            
+  if (nbCenterLayers_ != 5 && nbCenterLayers_ != 7) {
+    throw ReaderException("encountered wrong bullseye ring count");
+  }
+            
+  compact_ = nbCenterLayers_ == 5;
+            
+            
+            
+  float ratio = 0.75f*2 / (2*nbCenterLayers_-3);
+            
+  int dx = pina->x - pind->x;
+  int dy = pina->y - pinc->y;
+            
+  int targetcx = ROUND(pinc->x - ratio * dx);
+  int targetcy = ROUND(pinc->y - ratio * dy);
+  int targetax = ROUND(pina->x + ratio * dx);
+  int targetay = ROUND(pina->y + ratio * dy);
+            
+  dx = pinb->x - pind->x;
+  dy = pinb->y - pind->y;
+            
+  int targetdx = ROUND(pind->x - ratio * dx);
+  int targetdy = ROUND(pind->y - ratio * dy);
+  int targetbx = ROUND(pinb->x + ratio * dx);
+  int targetby = ROUND(pinb->y + ratio * dy);
+            
+  if (!isValid(targetax, targetay) ||
+      !isValid(targetbx, targetby) ||
+      !isValid(targetcx, targetcy) ||
+      !isValid(targetdx, targetdy)) {
+    throw ReaderException("bullseye extends over image bounds");
+  }
+            
+  std::vector<Ref<Point> > returnValue;
+  returnValue.push_back(Ref<Point>(new Point(targetax, targetay)));
+  returnValue.push_back(Ref<Point>(new Point(targetbx, targetby)));
+  returnValue.push_back(Ref<Point>(new Point(targetcx, targetcy)));
+  returnValue.push_back(Ref<Point>(new Point(targetdx, targetdy)));
+            
+  return returnValue;
+            
+}
+        
+Ref<Point> Detector::getMatrixCenter() {
+  Ref<ResultPoint> pointA, pointB, pointC, pointD;
+  try {
+                
+    std::vector<Ref<ResultPoint> > cornerPoints = WhiteRectangleDetector(image_).detect();
+    pointA = cornerPoints[0];
+    pointB = cornerPoints[1];
+    pointC = cornerPoints[2];
+    pointD = cornerPoints[3];
+                
+  } catch (NotFoundException& e) {
+                
+    int cx = image_->getWidth() / 2;
+    int cy = image_->getHeight() / 2;
+                
+    pointA = getFirstDifferent(Ref<Point>(new Point(cx+15/2, cy-15/2)), false,  1, -1)->toResultPoint();
+    pointB = getFirstDifferent(Ref<Point>(new Point(cx+15/2, cy+15/2)), false,  1,  1)->toResultPoint();
+    pointC = getFirstDifferent(Ref<Point>(new Point(cx-15/2, cy+15/2)), false, -1, -1)->toResultPoint();
+    pointD = getFirstDifferent(Ref<Point>(new Point(cx-15/2, cy-15/2)), false, -1, -1)->toResultPoint();
+                                      
+  }
+            
+  int cx = ROUND((pointA->getX() + pointD->getX() + pointB->getX() + pointC->getX()) / 4);
+  int cy = ROUND((pointA->getY() + pointD->getY() + pointB->getY() + pointC->getY()) / 4);
+            
+  try {
+                
+    std::vector<Ref<ResultPoint> > cornerPoints = WhiteRectangleDetector(image_, 15, cx, cy).detect();
+    pointA = cornerPoints[0];
+    pointB = cornerPoints[1];
+    pointC = cornerPoints[2];
+    pointD = cornerPoints[3];
+                
+  } catch (NotFoundException& e) {
+                
+    pointA = getFirstDifferent(Ref<Point>(new Point(cx+15/2, cy-15/2)), false,  1, -1)->toResultPoint();
+    pointB = getFirstDifferent(Ref<Point>(new Point(cx+15/2, cy+15/2)), false,  1,  1)->toResultPoint();
+    pointC = getFirstDifferent(Ref<Point>(new Point(cx-15/2, cy+15/2)), false, -1, -1)->toResultPoint();
+    pointD = getFirstDifferent(Ref<Point>(new Point(cx-15/2, cy-15/2)), false, -1, -1)->toResultPoint();
+                
+  }
+            
+  cx = ROUND((pointA->getX() + pointD->getX() + pointB->getX() + pointC->getX()) / 4);
+  cy = ROUND((pointA->getY() + pointD->getY() + pointB->getY() + pointC->getY()) / 4);
+            
+  return Ref<Point>(new Point(cx, cy));
+            
+}
+        
+Ref<BitMatrix> Detector::sampleGrid(Ref<zxing::BitMatrix> image,
+                                    Ref<zxing::ResultPoint> topLeft,
+                                    Ref<zxing::ResultPoint> bottomLeft,
+                                    Ref<zxing::ResultPoint> bottomRight,
+                                    Ref<zxing::ResultPoint> topRight) {
+  int dimension;
+  if (compact_) {
+    dimension = 4 * nbLayers_+11;
+  } else {
+    if (nbLayers_ <= 4) {
+      dimension = 4 * nbLayers_ + 15;
+    } else {
+      dimension = 4 * nbLayers_ + 2 * ((nbLayers_-4)/8 + 1) + 15;
+    }
+  }
+            
+  GridSampler sampler = GridSampler::getInstance();
+            
+  return sampler.sampleGrid(image,
+                            dimension,
+                            0.5f,
+                            0.5f,
+                            dimension - 0.5f,
+                            0.5f,
+                            dimension - 0.5f,
+                            dimension - 0.5f,
+                            0.5f,
+                            dimension - 0.5f,
+                            topLeft->getX(),
+                            topLeft->getY(),
+                            topRight->getX(),
+                            topRight->getY(),
+                            bottomRight->getX(),
+                            bottomRight->getY(),
+                            bottomLeft->getX(),
+                            bottomLeft->getY());
+}
+        
+void Detector::getParameters(Ref<zxing::BitArray> parameterData) {
+  nbLayers_ = 0;
+  nbDataBlocks_ = 0;
+            
+  int nbBitsForNbLayers;
+  int nbBitsForNbDatablocks;
+            
+  if (compact_) {
+    nbBitsForNbLayers = 2;
+    nbBitsForNbDatablocks = 6;
+  } else {
+    nbBitsForNbLayers = 5;
+    nbBitsForNbDatablocks = 11;
+  }
+            
+  for (int i = 0; i < nbBitsForNbLayers; i++) {
+    nbLayers_ <<= 1;
+    if (parameterData->get(i)) {
+      nbLayers_ += 1;
+    }
+  }
+            
+  for (int i = nbBitsForNbLayers; i < nbBitsForNbLayers + nbBitsForNbDatablocks; i++) {
+    nbDataBlocks_ <<= 1;
+    if (parameterData->get(i)) {
+      nbDataBlocks_ += 1;
+    }
+  }
+            
+  nbLayers_ ++;
+  nbDataBlocks_ ++;
+}
+        
+Ref<BitArray> Detector::sampleLine(Ref<zxing::aztec::Point> p1, Ref<zxing::aztec::Point> p2, int size) {
+  Ref<BitArray> res(new BitArray(size));
+            
+  float d = distance(p1, p2);
+  float moduleSize = d / (size-1);
+  float dx = moduleSize * (p2->x - p1->x)/d;
+  float dy = moduleSize * (p2->y - p1->y)/d;
+            
+  float px = p1->x;
+  float py = p1->y;
+            
+  for (int i = 0; i < size; i++) {
+    if (image_->get(ROUND(px), ROUND(py))) res->set(i);
+    px += dx;
+    py += dy;
+  }
+            
+  return res;
+}
+        
+bool Detector::isWhiteOrBlackRectangle(Ref<zxing::aztec::Point> p1,
+                                       Ref<zxing::aztec::Point> p2,
+                                       Ref<zxing::aztec::Point> p3,
+                                       Ref<zxing::aztec::Point> p4) {
+  int corr = 3;
+            
+  p1 = new Point(p1->x - corr, p1->y + corr);
+  p2 = new Point(p2->x - corr, p2->y - corr);
+  p3 = new Point(p3->x + corr, p3->y - corr);
+  p4 = new Point(p4->x + corr, p4->y + corr);
+            
+  int cInit = getColor(p4, p1);
+            
+  if (cInit == 0) {
+    return false;
+  }
+            
+  int c = getColor(p1, p2);
+            
+  if (c != cInit) {
+    return false;
+  }
+            
+  c = getColor(p2, p3);
+            
+  if (c != cInit) {
+    return false;
+  }
+            
+  c = getColor(p3, p4);
+            
+  if (c != cInit) {
+    return false;
+  }
+            
+  return true;
+}
+        
+int Detector::getColor(Ref<zxing::aztec::Point> p1, Ref<zxing::aztec::Point> p2) {
+  float d = distance(p1, p2);
+            
+  float dx = (p2->x - p1->x) / d;
+  float dy = (p2->y - p1->y) / d;
+            
+  int error = 0;
+            
+  float px = p1->x;
+  float py = p1->y;
+            
+  bool colorModel = image_->get(p1->x, p1->y);
+            
+  for (int i = 0; i < d; i++) {
+    px += dx;
+    py += dy;
+    if (image_->get(ROUND(px), ROUND(py)) != colorModel) {
+      error ++;
+    }
+  }
+            
+  float errRatio = (float)error/d;
+            
+            
+  if (errRatio > 0.1 && errRatio < 0.9) {
+    return 0;
+  }
+            
+  if (errRatio <= 0.1) {
+    return colorModel?1:-1;
+  } else {
+    return colorModel?-1:1;
+  }
+}
+        
+Ref<Point> Detector::getFirstDifferent(Ref<zxing::aztec::Point> init, bool color, int dx, int dy) {
+  int x = init->x + dx;
+  int y = init->y + dy;
+            
+  while (isValid(x, y) && image_->get(x, y) == color) {
+    x += dx;
+    y += dy;
+  }
+            
+  x -= dx;
+  y -= dy;
+            
+  while (isValid(x, y) && image_->get(x, y) == color) {
+    x += dx;
+  }
+            
+  x -= dx;
+            
+  while (isValid(x, y) && image_->get(x, y) == color) {
+    y += dy;
+  }
+            
+  y -= dy;
+            
+  return Ref<Point>(new Point(x, y));
+}
+        
+bool Detector::isValid(int x, int y) {
+  return x >= 0 && x < (int)image_->getWidth() && y > 0 && y < (int)image_->getHeight();
+}
+        
+float Detector::distance(Ref<zxing::aztec::Point> a, Ref<zxing::aztec::Point> b) {
+  return sqrtf((float)((a->x - b->x) * (a->x - b->x) + (a->y - b->y) * (a->y - b->y)));
+}

=== added file '3rdParty/zxing/aztec/detector/Detector.h'
--- 3rdParty/zxing/aztec/detector/Detector.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/aztec/detector/Detector.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,87 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  Detector.h
+ *  zxing
+ *
+ *  Created by Lukas Stabe on 08/02/2012.
+ *  Copyright 2012 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/BitArray.h>
+#include <zxing/ResultPoint.h>
+#include <zxing/common/BitMatrix.h>
+#include <zxing/DecodeHints.h>
+#include <zxing/aztec/AztecDetectorResult.h>
+
+#define ROUND(a) ((int)(a + 0.5f))
+
+namespace zxing {
+    namespace aztec {
+        
+        class Point : public Counted {
+        public:
+            int x;
+            int y;
+            
+            Ref<ResultPoint> toResultPoint() { 
+                return Ref<ResultPoint>(new ResultPoint(x, y));
+            }
+            
+            Point(int ax, int ay):x(ax),y(ay) {};
+            
+        };
+        
+        class Detector : public Counted {
+            
+        private:
+            Ref<BitMatrix> image_;
+            
+            bool compact_;
+            int nbLayers_;
+            int nbDataBlocks_;
+            int nbCenterLayers_;
+            int shift_;
+            
+            void extractParameters(std::vector<Ref<Point> > bullEyeCornerPoints);
+            std::vector<Ref<ResultPoint> > getMatrixCornerPoints(std::vector<Ref<Point> > bullEyeCornerPoints);
+            static void correctParameterData(Ref<BitArray> parameterData, bool compact);
+            std::vector<Ref<Point> > getBullEyeCornerPoints(Ref<Point> pCenter);
+            Ref<Point> getMatrixCenter();
+            Ref<BitMatrix> sampleGrid(Ref<BitMatrix> image,
+                                      Ref<ResultPoint> topLeft,
+                                      Ref<ResultPoint> bottomLeft,
+                                      Ref<ResultPoint> bottomRight,
+                                      Ref<ResultPoint> topRight);
+            void getParameters(Ref<BitArray> parameterData);
+            Ref<BitArray> sampleLine(Ref<Point> p1, Ref<Point> p2, int size);
+            bool isWhiteOrBlackRectangle(Ref<Point> p1,
+                                         Ref<Point> p2,
+                                         Ref<Point> p3,
+                                         Ref<Point> p4);
+            int getColor(Ref<Point> p1, Ref<Point> p2);
+            Ref<Point> getFirstDifferent(Ref<Point> init, bool color, int dx, int dy);
+            bool isValid(int x, int y);
+            static float distance(Ref<Point> a, Ref<Point> b);
+            
+        public:
+            Detector(Ref<BitMatrix> image);
+            Ref<AztecDetectorResult> detect();
+        };
+        
+    }
+}

=== added directory '3rdParty/zxing/common'
=== added file '3rdParty/zxing/common/Array.cpp'
--- 3rdParty/zxing/common/Array.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/Array.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,22 @@
+/*
+ *  Array.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 07/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/Array.h>
+

=== added file '3rdParty/zxing/common/Array.h'
--- 3rdParty/zxing/common/Array.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/Array.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,208 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __ARRAY_H__
+#define __ARRAY_H__
+
+/*
+ *  Array.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>
+
+#ifdef DEBUG_COUNTING
+#include <iostream>
+#include <typeinfo>
+#endif
+
+#include <zxing/common/Counted.h>
+
+
+namespace zxing {
+
+template<typename T> class Array : public Counted {
+protected:
+public:
+  std::vector<T> values_;
+  Array(size_t n) :
+      Counted(), values_(n, T()) {
+  }
+  Array(T *ts, size_t n) :
+      Counted(), values_(ts, ts+n) {
+  }
+  Array(T v, size_t n) :
+      Counted(), values_(n, v) {
+  }
+  Array(std::vector<T> &v) :
+      Counted(), values_(v) {
+  }
+  Array(Array<T> &other) :
+      Counted(), values_(other.values_) {
+  }
+  Array(Array<T> *other) :
+      Counted(), values_(other->values_) {
+  }
+  virtual ~Array() {
+  }
+  Array<T>& operator=(const Array<T> &other) {
+#ifdef DEBUG_COUNTING
+    cout << "assigning values from Array " << &other << " to this Array " << this << ", ";
+#endif
+    values_ = other.values_;
+#ifdef DEBUG_COUNTING
+    cout << "new size = " << values_.size() << "\n";
+#endif
+    return *this;
+  }
+  Array<T>& operator=(const std::vector<T> &array) {
+#ifdef DEBUG_COUNTING
+    cout << "assigning values from Array " << &array << " to this Array " << this << ", ";
+#endif
+    values_ = array;
+#ifdef DEBUG_COUNTING
+    cout << "new size = " << values_.size() << "\n";
+#endif
+    return *this;
+  }
+  T operator[](size_t i) const {
+    return values_[i];
+  }
+  T& operator[](size_t i) {
+    return values_[i];
+  }
+  size_t size() const {
+    return values_.size();
+  }
+  std::vector<T> values() const {
+    return values_;
+  }
+  std::vector<T>& values() {
+    return values_;
+  }
+};
+
+template<typename T> class ArrayRef : public Counted {
+private:
+public:
+  Array<T> *array_;
+  ArrayRef() :
+      array_(0) {
+#ifdef DEBUG_COUNTING
+    cout << "instantiating empty ArrayRef " << this << "\n";
+#endif
+  }
+  ArrayRef(size_t n) :
+      array_(0) {
+#ifdef DEBUG_COUNTING
+    cout << "instantiating ArrayRef " << this << "with size " << n << "\n";
+#endif
+    reset(new Array<T> (n));
+  }
+  ArrayRef(T *ts, size_t n) :
+      array_(0) {
+#ifdef DEBUG_COUNTING
+    cout << "instantiating ArrayRef " << this << "with " << n << " elements at " << (void *)ts << "\n";
+#endif
+    reset(new Array<T> (ts, n));
+  }
+  ArrayRef(Array<T> *a) :
+      array_(0) {
+#ifdef DEBUG_COUNTING
+    cout << "instantiating ArrayRef " << this << " from pointer:\n";
+#endif
+    reset(a);
+  }
+  ArrayRef(const Array<T> &a) :
+      array_(0) {
+#ifdef DEBUG_COUNTING
+    cout << "instantiating ArrayRef " << this << " from reference to Array " << (void *)&a << ":\n";
+#endif
+    reset(const_cast<Array<T> *>(&a));
+  }
+  ArrayRef(const ArrayRef &other) :
+      Counted(), array_(0) {
+#ifdef DEBUG_COUNTING
+    cout << "instantiating ArrayRef " << this << " from ArrayRef " << &other << ":\n";
+#endif
+    reset(other.array_);
+  }
+
+  template<class Y>
+  ArrayRef(const ArrayRef<Y> &other) :
+      array_(0) {
+#ifdef DEBUG_COUNTING
+    cout << "instantiating ArrayRef " << this << " from ArrayRef " << &other << ":\n";
+#endif
+    reset(static_cast<const Array<T> *>(other.array_));
+  }
+
+  ~ArrayRef() {
+#ifdef DEBUG_COUNTING
+    cout << "destroying ArrayRef " << this << " with " << (array_ ? typeid(*array_).name() : "NULL") << " "
+         << array_ << "\n";
+#endif
+    if (array_) {
+      array_->release();
+    }
+    array_ = 0;
+  }
+
+  T operator[](size_t i) const {
+    return (*array_)[i];
+  }
+  T& operator[](size_t i) {
+    return (*array_)[i];
+  }
+  size_t size() const {
+    return array_->size();
+  }
+
+  void reset(Array<T> *a) {
+#ifdef DEBUG_COUNTING
+    cout << "resetting ArrayRef " << this << " from " << (array_ ? typeid(*array_).name() : "NULL") << " "
+         << array_ << " to " << (a ? typeid(*a).name() : "NULL") << " " << a << "\n";
+#endif
+    if (a) {
+      a->retain();
+    }
+    if (array_) {
+      array_->release();
+    }
+    array_ = a;
+  }
+  void reset(const ArrayRef<T> &other) {
+    reset(other.array_);
+  }
+  ArrayRef<T>& operator=(const ArrayRef<T> &other) {
+    reset(other);
+    return *this;
+  }
+  ArrayRef<T>& operator=(Array<T> *a) {
+    reset(a);
+    return *this;
+  }
+
+  Array<T>& operator*() {
+    return *array_;
+  }
+  Array<T>* operator->() {
+    return array_;
+  }
+};
+
+} // namespace zxing
+
+#endif // __ARRAY_H__

=== added file '3rdParty/zxing/common/BitArray.cpp'
--- 3rdParty/zxing/common/BitArray.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/BitArray.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,127 @@
+// -*- 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 namespace std;
+
+namespace zxing {
+
+
+size_t BitArray::wordsForBits(size_t bits) {
+  int arraySize = (bits + bitsPerWord_ - 1) >> logBits_;
+  return arraySize;
+}
+
+BitArray::BitArray(size_t size) :
+    size_(size), bits_(wordsForBits(size), (const unsigned int)0) {
+}
+
+BitArray::~BitArray() {
+}
+
+size_t BitArray::getSize() {
+  return size_;
+}
+
+void BitArray::setBulk(size_t i, unsigned int newBits) {
+  bits_[i >> logBits_] = newBits;
+}
+
+void BitArray::setRange(int start, int end) {
+  if (end < start) {
+    throw IllegalArgumentException("invalid call to BitArray::setRange");
+  }
+  if (end == start) {
+    return;
+  }
+  end--; // will be easier to treat this as the last actually set bit -- inclusive
+  int firstInt = start >> 5;
+  int lastInt = end >> 5;
+  for (int i = firstInt; i <= lastInt; i++) {
+    int firstBit = i > firstInt ? 0 : start & 0x1F;
+    int lastBit = i < lastInt ? 31 : end & 0x1F;
+    int mask;
+    if (firstBit == 0 && lastBit == 31) {
+      mask = -1;
+    } else {
+      mask = 0;
+      for (int j = firstBit; j <= lastBit; j++) {
+        mask |= 1 << j;
+      }
+    }
+    bits_[i] |= mask;
+  }
+}
+
+void BitArray::clear() {
+  size_t max = bits_.size();
+  for (size_t i = 0; i < max; i++) {
+    bits_[i] = 0;
+  }
+}
+
+bool BitArray::isRange(size_t start, size_t end, bool value) {
+  if (end < start) {
+    throw IllegalArgumentException("end must be after start");
+  }
+  if (end == start) {
+    return true;
+  }
+  // treat the 'end' as inclusive, rather than exclusive
+  end--;
+  size_t firstWord = start >> logBits_;
+  size_t lastWord = end >> logBits_;
+  for (size_t i = firstWord; i <= lastWord; i++) {
+    size_t firstBit = i > firstWord ? 0 : start & bitsMask_;
+    size_t lastBit = i < lastWord ? bitsPerWord_ - 1: end & bitsMask_;
+    unsigned int mask;
+    if (firstBit == 0 && lastBit == bitsPerWord_ - 1) {
+      mask = numeric_limits<unsigned int>::max();
+    } else {
+      mask = 0;
+      for (size_t j = firstBit; j <= lastBit; j++) {
+        mask |= 1 << j;
+      }
+    }
+    if (value) {
+      if ((bits_[i] & mask) != mask) {
+        return false;
+      }
+    } else {
+      if ((bits_[i] & mask) != 0) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+vector<unsigned int>& BitArray::getBitArray() {
+  return bits_;
+}
+
+void BitArray::reverse() {
+  std::vector<unsigned int> newBits(bits_.size(),(const unsigned int) 0);
+  for (size_t i = 0; i < size_; i++) {
+    if (get(size_ - i - 1)) {
+      newBits[i >> logBits_] |= 1<< (i & bitsMask_);
+    }
+  }
+  bits_ = newBits;
+}
+}

=== added file '3rdParty/zxing/common/BitArray.h'
--- 3rdParty/zxing/common/BitArray.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/BitArray.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,70 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __BIT_ARRAY_H__
+#define __BIT_ARRAY_H__
+
+/*
+ *  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/IllegalArgumentException.h>
+#include <vector>
+#include <limits>
+
+namespace zxing {
+
+#define ZX_LOG_DIGITS(digits) \
+    ((digits == 8) ? 3 : \
+     ((digits == 16) ? 4 : \
+      ((digits == 32) ? 5 : \
+       ((digits == 64) ? 6 : \
+        ((digits == 128) ? 7 : \
+         (-1))))))
+
+class BitArray : public Counted {
+private:
+  size_t size_;
+  std::vector<unsigned int> bits_;
+  static const unsigned int bitsPerWord_ =
+    std::numeric_limits<unsigned int>::digits;
+  static const unsigned int logBits_ = ZX_LOG_DIGITS(bitsPerWord_);
+  static const unsigned int bitsMask_ = (1 << logBits_) - 1;
+  static size_t wordsForBits(size_t bits);
+  explicit BitArray();
+
+public:
+  BitArray(size_t size);
+  ~BitArray();
+  size_t getSize();
+
+  bool get(size_t i) {
+    return (bits_[i >> logBits_] & (1 << (i & bitsMask_))) != 0;
+  }
+
+  void set(size_t i) {
+    bits_[i >> logBits_] |= 1 << (i & bitsMask_);
+  }
+
+  void setBulk(size_t i, unsigned int newBits);
+  void setRange(int start, int end);
+  void clear();
+  bool isRange(size_t start, size_t end, bool value);
+  std::vector<unsigned int>& getBitArray();
+  void reverse();
+};
+
+}
+
+#endif // __BIT_ARRAY_H__

=== added file '3rdParty/zxing/common/BitMatrix.cpp'
--- 3rdParty/zxing/common/BitMatrix.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/BitMatrix.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,157 @@
+// -*- 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::Ref;
+
+namespace {
+  size_t wordsForSize(size_t width,
+                      size_t height,
+                      unsigned int bitsPerWord,
+                      unsigned int logBits) {
+    size_t bits = width * height;
+    int arraySize = (bits + bitsPerWord - 1) >> logBits;
+    return arraySize;
+  }
+}
+
+BitMatrix::BitMatrix(size_t dimension) :
+  width_(dimension), height_(dimension), words_(0), bits_(NULL) {
+  words_ = wordsForSize(width_, height_, bitsPerWord, logBits);
+  bits_ = new unsigned int[words_];
+  clear();
+}
+
+BitMatrix::BitMatrix(size_t width, size_t height) :
+  width_(width), height_(height), words_(0), bits_(NULL) {
+  words_ = wordsForSize(width_, height_, bitsPerWord, logBits);
+  bits_ = new unsigned int[words_];
+  clear();
+}
+
+BitMatrix::~BitMatrix() {
+  delete[] bits_;
+}
+
+
+void BitMatrix::flip(size_t x, size_t y) {
+  size_t offset = x + width_ * y;
+  bits_[offset >> logBits] ^= 1 << (offset & bitsMask);
+}
+
+void BitMatrix::clear() {
+  std::fill(bits_, bits_+words_, 0);
+}
+
+void BitMatrix::setRegion(size_t left, size_t top, size_t width, size_t height) {
+  if ((long)top < 0 || (long)left < 0) {
+    throw IllegalArgumentException("topI and leftJ must be nonnegative");
+  }
+  if (height < 1 || width < 1) {
+    throw IllegalArgumentException("height and width must be at least 1");
+  }
+  size_t right = left + width;
+  size_t bottom = top + height;
+  if (right > width_ || bottom > height_) {
+    throw IllegalArgumentException("top + height and left + width must be <= matrix dimension");
+  }
+  for (size_t y = top; y < bottom; y++) {
+    int yOffset = width_ * y;
+    for (size_t x = left; x < right; x++) {
+      size_t offset = x + yOffset;
+      bits_[offset >> logBits] |= 1 << (offset & bitsMask);
+    }
+  }
+}
+
+Ref<BitArray> BitMatrix::getRow(int y, Ref<BitArray> row) {
+  if (row.empty() || row->getSize() < width_) {
+    row = new BitArray(width_);
+  } else {
+    row->clear();
+  }
+  size_t start = y * width_;
+  size_t end = start + width_ - 1; // end is inclusive
+  size_t firstWord = start >> logBits;
+  size_t lastWord = end >> logBits;
+  size_t bitOffset = start & bitsMask;
+  for (size_t i = firstWord; i <= lastWord; i++) {
+    size_t firstBit = i > firstWord ? 0 : start & bitsMask;
+    size_t lastBit = i < lastWord ? bitsPerWord - 1 : end & bitsMask;
+    unsigned int mask;
+    if (firstBit == 0 && lastBit == logBits) {
+      mask = std::numeric_limits<unsigned int>::max();
+    } else {
+      mask = 0;
+      for (size_t j = firstBit; j <= lastBit; j++) {
+        mask |= 1 << j;
+      }
+    }
+    row->setBulk((i - firstWord) << logBits, (bits_[i] & mask) >> bitOffset);
+    if (firstBit == 0 && bitOffset != 0) {
+      unsigned int prevBulk = row->getBitArray()[i - firstWord - 1];
+      prevBulk |= (bits_[i] & mask) << (bitsPerWord - bitOffset);
+      row->setBulk((i - firstWord - 1) << logBits, prevBulk);
+    }
+  }
+  return row;
+}
+
+size_t BitMatrix::getWidth() const {
+  return width_;
+}
+
+size_t BitMatrix::getHeight() const {
+  return height_;
+}
+
+size_t BitMatrix::getDimension() const {
+  return width_;
+}
+
+unsigned int* BitMatrix::getBits() const {
+  return bits_;
+}
+
+namespace zxing {
+  ostream& operator<<(ostream &out, const BitMatrix &bm) {
+    for (size_t y = 0; y < bm.height_; y++) {
+      for (size_t x = 0; x < bm.width_; x++) {
+        out << (bm.get(x, y) ? "X " : "  ");
+      }
+      out << "\n";
+    }
+    return out;
+  }
+}
+
+const char* BitMatrix::description() {
+  ostringstream out;
+  out << *this;
+  return out.str().c_str();
+}

=== added file '3rdParty/zxing/common/BitMatrix.h'
--- 3rdParty/zxing/common/BitMatrix.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/BitMatrix.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,87 @@
+// -*- 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 <limits>
+
+namespace zxing {
+
+class BitMatrix : public Counted {
+private:
+  size_t width_;
+  size_t height_;
+  size_t words_;
+  unsigned 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 unsigned int bitsPerWord =
+    std::numeric_limits<unsigned int>::digits;
+  static const unsigned int logBits = ZX_LOG_DIGITS(bitsPerWord);
+  static const unsigned int bitsMask = (1 << logBits) - 1;
+
+public:
+  BitMatrix(size_t dimension);
+  BitMatrix(size_t width, size_t height);
+
+  ~BitMatrix();
+
+  bool get(size_t x, size_t y) const {
+    size_t offset = x + width_ * y;
+    return ((bits_[offset >> logBits] >> (offset & bitsMask)) & 0x01) != 0;
+  }
+
+  void set(size_t x, size_t y) {
+    size_t offset = x + width_ * y;
+    bits_[offset >> logBits] |= 1 << (offset & bitsMask);
+  }
+
+  void flip(size_t x, size_t y);
+  void clear();
+  void setRegion(size_t left, size_t top, size_t width, size_t height);
+  Ref<BitArray> getRow(int y, Ref<BitArray> row);
+
+  size_t getDimension() const;
+  size_t getWidth() const;
+  size_t getHeight() const;
+
+  unsigned int* getBits() const;
+
+  friend std::ostream& operator<<(std::ostream &out, const BitMatrix &bm);
+  const char *description();
+
+private:
+  BitMatrix(const BitMatrix&);
+  BitMatrix& operator =(const BitMatrix&);
+};
+
+}
+
+#endif // __BIT_MATRIX_H__

=== added file '3rdParty/zxing/common/BitSource.cpp'
--- 3rdParty/zxing/common/BitSource.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/BitSource.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,74 @@
+/*
+ *  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 <zxing/common/IllegalArgumentException.h>
+
+namespace zxing {
+
+int BitSource::readBits(int numBits) {
+  if (numBits < 0 || numBits > 32) {
+    throw IllegalArgumentException("cannot read <1 or >32 bits");
+  } else if (numBits > available()) {
+    throw IllegalArgumentException("reading more bits than are available");
+  }
+
+  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_;
+}
+}

=== added file '3rdParty/zxing/common/BitSource.h'
--- 3rdParty/zxing/common/BitSource.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/BitSource.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,70 @@
+#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 [e-mail] (Sean Owen)
+ * @author [e-mail] (Christian Brunschen)
+ */
+class BitSource : public Counted {
+  typedef unsigned 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 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__

=== added file '3rdParty/zxing/common/CharacterSetECI.cpp'
--- 3rdParty/zxing/common/CharacterSetECI.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/CharacterSetECI.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,104 @@
+// -*- 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, CharacterSetECI*> CharacterSetECI::VALUE_TO_ECI;
+std::map<std::string, 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) {
+  for(int const* values = values_; *values != -1; values++) {
+    VALUE_TO_ECI[*values] = this;
+  }
+  for(char const* const* names = names_; *names; names++) {
+    NAME_TO_ECI[string(*names)] = this;
+  }
+}
+
+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];
+}

=== added file '3rdParty/zxing/common/CharacterSetECI.h'
--- 3rdParty/zxing/common/CharacterSetECI.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/CharacterSetECI.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,53 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+
+#ifndef __CHARACTERSET_ECI__
+#define __CHARACTERSET_ECI__
+
+/*
+ * 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 <map>
+#include <zxing/DecodeHints.h>
+
+namespace zxing {
+  namespace common {
+    class CharacterSetECI;
+  }
+}
+
+class zxing::common::CharacterSetECI {
+private:
+  static std::map<int, CharacterSetECI*> VALUE_TO_ECI;
+  static std::map<std::string, CharacterSetECI*> NAME_TO_ECI;
+  static const bool inited;
+  static bool init_tables();
+
+  int const* const values_;
+  char const* const* const names_;
+
+  CharacterSetECI(int const* values, char const* const* names);
+
+  static void addCharacterSet(int const* value, char const* const* encodingNames);
+
+public:
+  char const* name() const;
+  int getValue() const;
+
+  static CharacterSetECI* getCharacterSetECIByValue(int value);
+  static CharacterSetECI* getCharacterSetECIByName(std::string const& name);
+};
+
+#endif

=== added file '3rdParty/zxing/common/Counted.cpp'
--- 3rdParty/zxing/common/Counted.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/Counted.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,32 @@
+/*
+ *  Counted.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 07/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/Counted.h>
+
+namespace zxing {
+
+using namespace std;
+
+template<class T>
+ostream& operator<<(ostream &out, Ref<T>& ref) {
+  out << "Ref(" << (ref.object_ ? (*ref.object_) : "NULL") << ")";
+  return out;
+}
+}

=== added file '3rdParty/zxing/common/Counted.h'
--- 3rdParty/zxing/common/Counted.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/Counted.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,202 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __COUNTED_H__
+#define __COUNTED_H__
+
+/*
+ *  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.
+ */
+
+//#define DEBUG_COUNTING
+
+#include <iostream>
+
+#ifdef DEBUG_COUNTING
+#include <typeinfo>
+#endif
+
+namespace zxing {
+
+/* base class for reference-counted objects */
+class Counted {
+private:
+  unsigned int count_;
+public:
+  Counted() :
+      count_(0) {
+#ifdef DEBUG_COUNTING
+    cout << "instantiating " << typeid(*this).name() << " " << this <<
+         " @ " << count_ << "\n";
+#endif
+  }
+  virtual ~Counted() {
+  }
+  Counted *retain() {
+#ifdef DEBUG_COUNTING
+    cout << "retaining " << typeid(*this).name() << " " << this <<
+         " @ " << count_;
+#endif
+    count_++;
+#ifdef DEBUG_COUNTING
+    cout << "->" << count_ << "\n";
+#endif
+    return this;
+  }
+  void release() {
+#ifdef DEBUG_COUNTING
+    cout << "releasing " << typeid(*this).name() << " " << this <<
+         " @ " << count_;
+#endif
+    if (count_ == 0 || count_ == 54321) {
+#ifdef DEBUG_COUNTING
+      cout << "\nOverreleasing already-deleted object " << this << "!!!\n";
+#endif
+      throw 4711;
+    }
+    count_--;
+#ifdef DEBUG_COUNTING
+    cout << "->" << count_ << "\n";
+#endif
+    if (count_ == 0) {
+#ifdef DEBUG_COUNTING
+      cout << "deleting " << typeid(*this).name() << " " << this << "\n";
+#endif
+      count_ = 0xDEADF001;
+      delete this;
+    }
+  }
+
+
+  /* return the current count for denugging purposes or similar */
+  int count() const {
+    return count_;
+  }
+};
+
+/* counting reference to reference-counted objects */
+template<typename T> class Ref {
+private:
+public:
+  T *object_;
+  explicit Ref(T *o = 0) :
+      object_(0) {
+#ifdef DEBUG_COUNTING
+    cout << "instantiating Ref " << this << " from pointer" << o << "\n";
+#endif
+    reset(o);
+  }
+
+  explicit Ref(const T &o) :
+      object_(0) {
+#ifdef DEBUG_COUNTING
+    cout << "instantiating Ref " << this << " from reference\n";
+#endif
+    reset(const_cast<T *>(&o));
+  }
+
+  Ref(const Ref &other) :
+      object_(0) {
+#ifdef DEBUG_COUNTING
+    cout << "instantiating Ref " << this << " from Ref " << &other << "\n";
+#endif
+    reset(other.object_);
+  }
+
+  template<class Y>
+  Ref(const Ref<Y> &other) :
+      object_(0) {
+#ifdef DEBUG_COUNTING
+    cout << "instantiating Ref " << this << " from reference\n";
+#endif
+    reset(other.object_);
+  }
+
+  ~Ref() {
+#ifdef DEBUG_COUNTING
+    cout << "destroying Ref " << this << " with " <<
+         (object_ ? typeid(*object_).name() : "NULL") << " " << object_ << "\n";
+#endif
+    if (object_) {
+      object_->release();
+    }
+  }
+
+  void reset(T *o) {
+#ifdef DEBUG_COUNTING
+    cout << "resetting Ref " << this << " from " <<
+         (object_ ? typeid(*object_).name() : "NULL") << " " << object_ <<
+         " to " << (o ? typeid(*o).name() : "NULL") << " " << o << "\n";
+#endif
+    if (o) {
+      o->retain();
+    }
+    if (object_ != 0) {
+      object_->release();
+    }
+    object_ = o;
+  }
+  Ref& operator=(const Ref &other) {
+    reset(other.object_);
+    return *this;
+  }
+  template<class Y>
+  Ref& operator=(const Ref<Y> &other) {
+    reset(other.object_);
+    return *this;
+  }
+  Ref& operator=(T* o) {
+    reset(o);
+    return *this;
+  }
+  template<class Y>
+  Ref& operator=(Y* o) {
+    reset(o);
+    return *this;
+  }
+
+  T& operator*() {
+    return *object_;
+  }
+  T* operator->() const {
+    return object_;
+  }
+  operator T*() const {
+    return object_;
+  }
+
+  bool operator==(const T* that) {
+    return object_ == that;
+  }
+  bool operator==(const Ref &other) const {
+    return object_ == other.object_ || *object_ == *(other.object_);
+  }
+  template<class Y>
+  bool operator==(const Ref<Y> &other) const {
+    return object_ == other.object_ || *object_ == *(other.object_);
+  }
+
+  bool operator!=(const T* that) {
+    return !(*this == that);
+  }
+
+  bool empty() const {
+    return object_ == 0;
+  }
+
+  template<class Y>
+  friend std::ostream& operator<<(std::ostream &out, Ref<Y>& ref);
+};
+}
+
+#endif // __COUNTED_H__

=== added file '3rdParty/zxing/common/DecoderResult.cpp'
--- 3rdParty/zxing/common/DecoderResult.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/DecoderResult.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,46 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  DecoderResult.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 20/05/2008.
+ *  Copyright 2008-2011 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/DecoderResult.h>
+
+using namespace std;
+using namespace zxing;
+
+DecoderResult::DecoderResult(ArrayRef<unsigned char> rawBytes,
+                             Ref<String> text,
+                             ArrayRef< ArrayRef<unsigned char> >& byteSegments,
+                             string const& ecLevel) :
+  rawBytes_(rawBytes),
+  text_(text),
+  byteSegments_(byteSegments),
+  ecLevel_(ecLevel) {}
+
+DecoderResult::DecoderResult(ArrayRef<unsigned char> rawBytes,
+                             Ref<String> text)
+  : rawBytes_(rawBytes), text_(text) {}
+
+ArrayRef<unsigned char> DecoderResult::getRawBytes() {
+  return rawBytes_;
+}
+
+Ref<String> DecoderResult::getText() {
+  return text_;
+}

=== added file '3rdParty/zxing/common/DecoderResult.h'
--- 3rdParty/zxing/common/DecoderResult.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/DecoderResult.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,51 @@
+#ifndef __DECODER_RESULT_H__
+#define __DECODER_RESULT_H__
+
+/*
+ *  DecoderResult.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/Array.h>
+#include <string>
+#include <zxing/common/Str.h>
+
+namespace zxing {
+
+class DecoderResult : public Counted {
+private:
+  ArrayRef<unsigned char> rawBytes_;
+  Ref<String> text_;
+  ArrayRef< ArrayRef<unsigned char> > byteSegments_;
+  std::string ecLevel_;
+
+public:
+  DecoderResult(ArrayRef<unsigned char> rawBytes,
+                Ref<String> text,
+                ArrayRef< ArrayRef<unsigned char> >& byteSegments,
+                std::string const& ecLevel);
+
+  DecoderResult(ArrayRef<unsigned char> rawBytes, Ref<String> text);
+
+  ArrayRef<unsigned char> getRawBytes();
+  Ref<String> getText();
+};
+
+}
+
+#endif // __DECODER_RESULT_H__

=== added file '3rdParty/zxing/common/DetectorResult.cpp'
--- 3rdParty/zxing/common/DetectorResult.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/DetectorResult.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,38 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  DetectorResult.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 14/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/common/DetectorResult.h>
+
+namespace zxing {
+
+DetectorResult::DetectorResult(Ref<BitMatrix> bits, std::vector<Ref<ResultPoint> > points) :
+  bits_(bits), points_(points) {
+}
+
+Ref<BitMatrix> DetectorResult::getBits() {
+  return bits_;
+}
+
+std::vector<Ref<ResultPoint> > DetectorResult::getPoints() {
+  return points_;
+}
+
+}

=== added file '3rdParty/zxing/common/DetectorResult.h'
--- 3rdParty/zxing/common/DetectorResult.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/DetectorResult.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,43 @@
+#ifndef __DETECTOR_RESULT_H__
+#define __DETECTOR_RESULT_H__
+
+/*
+ *  DetectorResult.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/common/BitMatrix.h>
+#include <zxing/ResultPoint.h>
+
+namespace zxing {
+
+class DetectorResult : public Counted {
+private:
+  Ref<BitMatrix> bits_;
+  std::vector<Ref<ResultPoint> > points_;
+
+public:
+        DetectorResult(Ref<BitMatrix> bits, std::vector<Ref<ResultPoint> > points);
+  Ref<BitMatrix> getBits();
+  std::vector<Ref<ResultPoint> > getPoints();
+};
+}
+
+#endif // __DETECTOR_RESULT_H__

=== added file '3rdParty/zxing/common/EdgeDetector.cpp'
--- 3rdParty/zxing/common/EdgeDetector.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/EdgeDetector.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,191 @@
+/*
+ *  EdgeDetector.cpp
+ *  zxing
+ *
+ *  Created by Ralf Kistner on 7/12/2009.
+ *  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/common/EdgeDetector.h>
+#include <algorithm>
+#include <cmath>
+
+using namespace std;
+
+namespace zxing {
+namespace EdgeDetector {
+
+void findEdgePoints(std::vector<Point>& points, const BitMatrix& image, Point start, Point end, bool invert, int skip, float deviation) {
+  float xdist = end.x - start.x;
+  float ydist = end.y - start.y;
+  float length = sqrt(xdist * xdist + ydist * ydist);
+
+
+  int var;
+
+  if (abs(xdist) > abs(ydist)) {
+    // Horizontal
+    if (xdist < 0)
+      skip = -skip;
+
+    var = int(abs(deviation * length / xdist));
+
+    float dy = ydist / xdist * skip;
+    bool left = (skip < 0) ^ invert;
+    int x = int(start.x);
+
+    int steps = int(xdist / skip);
+    for (int i = 0; i < steps; i++) {
+      x += skip;
+      if (x < 0 || x >= (int)image.getWidth())
+        continue; // In case we start off the edge
+      int my = int(start.y + dy * i);
+      int ey = min(my + var + 1, (int)image.getHeight() - 1);
+      int sy = max(my - var, 0);
+      for (int y = sy + 1; y < ey; y++) {
+        if (left) {
+          if (image.get(x, y) && !image.get(x, y + 1)) {
+            points.push_back(Point(x, y + 0.5f));
+          }
+        } else {
+          if (!image.get(x, y) && image.get(x, y + 1)) {
+            points.push_back(Point(x, y + 0.5f));
+          }
+        }
+      }
+    }
+  } else {
+    // Vertical
+    if (ydist < 0)
+      skip = -skip;
+
+    var = int(abs(deviation * length / ydist));
+
+    float dx = xdist / ydist * skip;
+    bool down = (skip > 0) ^ invert;
+    int y = int(start.y);
+
+    int steps = int(ydist / skip);
+    for (int i = 0; i < steps; i++) {
+      y += skip;
+      if (y < 0 || y >= (int)image.getHeight())
+        continue; // In case we start off the edge
+      int mx = int(start.x + dx * i);
+      int ex = min(mx + var + 1, (int)image.getWidth() - 1);
+      int sx = max(mx - var, 0);
+      for (int x = sx + 1; x < ex; x++) {
+        if (down) {
+          if (image.get(x, y) && !image.get(x + 1, y)) {
+            points.push_back(Point(x + 0.5f, y));
+          }
+
+        } else {
+          if (!image.get(x, y) && image.get(x + 1, y)) {
+            points.push_back(Point(x + 0.5f, y));
+          }
+        }
+
+      }
+    }
+
+  }
+}
+
+Line findLine(const BitMatrix& image, Line estimate, bool invert, int deviation, float threshold, int skip) {
+  float t = threshold * threshold;
+
+  Point start = estimate.start;
+  Point end = estimate.end;
+
+  vector<Point> edges;
+  edges.clear();
+  findEdgePoints(edges, image, start, end, invert, skip, deviation);
+
+  int n = edges.size();
+
+  float xdist = end.x - start.x;
+  float ydist = end.y - start.y;
+
+  bool horizontal = abs(xdist) > abs(ydist);
+
+  float max = 0;
+  Line bestLine(start, end);  // prepopulate with the given line, in case we can't find any line for some reason
+
+  for (int i = -deviation; i < deviation; i++) {
+    float x1, y1;
+    if (horizontal) {
+      y1 = start.y + i;
+      x1 = start.x - i * ydist / xdist;
+    } else {
+      y1 = start.y - i * xdist / ydist;
+      x1 = start.x + i;
+    }
+
+    for (int j = -deviation; j < deviation; j++) {
+      float x2, y2;
+      if (horizontal) {
+        y2 = end.y + j;
+        x2 = end.x - j * ydist / xdist;
+      } else {
+        y2 = end.y - j * xdist / ydist;
+        x2 = end.x + j;
+      }
+
+      float dx = x1 - x2;
+      float dy = y1 - y2;
+      float length = sqrt(dx * dx + dy * dy);
+
+      float score = 0;
+
+      for(int k = 0; k < n; k++) {
+        const Point& edge = edges[k];
+        float dist = ((x1 - edge.x) * dy - (y1 - edge.y) * dx) / length;
+        // Similar to least squares method
+        float s = t - dist * dist;
+        if (s > 0)
+          score += s;
+      }
+
+      if (score > max) {
+        max = score;
+        bestLine.start = Point(x1, y1);
+        bestLine.end = Point(x2, y2);
+      }
+    }
+  }
+
+  return bestLine;
+}
+
+Point intersection(Line a, Line b) {
+  float dxa = a.start.x - a.end.x;
+  float dxb = b.start.x - b.end.x;
+  float dya = a.start.y - a.end.y;
+  float dyb = b.start.y - b.end.y;
+
+  float p = a.start.x * a.end.y - a.start.y * a.end.x;
+  float q = b.start.x * b.end.y - b.start.y * b.end.x;
+  float denom = dxa * dyb - dya * dxb;
+  if(denom == 0)  // Lines don't intersect
+    return Point(INFINITY, INFINITY);
+
+  float x = (p * dxb - dxa * q) / denom;
+  float y = (p * dyb - dya * q) / denom;
+
+  return Point(x, y);
+}
+
+} // namespace EdgeDetector
+} // namespace zxing

=== added file '3rdParty/zxing/common/EdgeDetector.h'
--- 3rdParty/zxing/common/EdgeDetector.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/EdgeDetector.h	2014-05-10 17:38:08 +0000
@@ -0,0 +1,38 @@
+#ifndef __EDGEDETECTOR_H__
+#define __EDGEDETECTOR_H__
+/*
+ *  EdgeDetector.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/BitMatrix.h>
+#include <zxing/common/Point.h>
+
+namespace zxing {
+namespace EdgeDetector {
+
+void findEdgePoints(std::vector<Point>& points, const BitMatrix& image, Point start, Point end, bool invert, int skip, float deviation);
+Line findLine(const BitMatrix& image, Line estimate, bool invert, int deviation, float threshold, int skip);
+
+Point intersection(Line a, Line b);
+
+}
+}
+#endif /* EDGEDETECTOR_H_ */

=== added file '3rdParty/zxing/common/GlobalHistogramBinarizer.cpp'
--- 3rdParty/zxing/common/GlobalHistogramBinarizer.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/zxing/common/GlobalHistogramBinarizer.cpp	2014-05-10 17:38:08 +0000
@@ -0,0 +1,209 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  GlobalHistogramBinarizer.cpp
+ *  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/GlobalHistogramBinarizer.h>
+#include <zxing/common/IllegalArgumentException.h>
+#include <zxing/common/Array.h>
+
+namespace zxing {
+using namespace std;
+
+const int LUMINANCE_BITS = 5;
+const int LUMINANCE_SHIFT = 8 - LUMINANCE_BITS;
+const int LUMINANCE_BUCKETS = 1 << LUMINANCE_BITS;
+
+GlobalHistogramBinarizer::GlobalHistogramBinarizer(Ref<LuminanceSource> source) :
+  Binarizer(source), cached_matrix_(NULL), cached_row_(NULL), cached_row_num_(-1) {
+
+}
+
+GlobalHistogramBinarizer::~GlobalHistogramBinarizer() {
+}
+
+
+Ref<BitArray> GlobalHistogramBinarizer::getBlackRow(int y, Ref<BitArray> row) {
+  if (y == cached_row_num_) {
+    if (cached_row_ != NULL) {
+      return cached_row_;
+    } else {
+      throw IllegalArgumentException("Too little dynamic range in luminance");
+    }
+  }
+
+  vector<int> histogram(LUMINANCE_BUCKETS, 0);
+  LuminanceSource& source = *getLuminanceSource();
+  int width = source.getWidth();
+  if (row == NULL || static_cast<int>(row->getSize()) < width) {
+    row = new BitArray(width);
+  } else {
+    row->clear();
+  }
+
+  //TODO(flyashi): cache this instead of allocating and deleting per row
+  unsigned char* row_pixels = NULL;
+  try {
+    row_pixels = new unsigned char[width];
+    row_pixels = source.getRow(y, row_pixels);
+    for (int x = 0; x < width; x++) {
+      histogram[row_pixels[x] >> LUMINANCE_SHIFT]++;
+    }
+    int blackPoint = estimate(histogram);
+
+    BitArray& array = *row;
+    int left = row_pixels[0];
+    int center = row_pixels[1];
+    for (int x = 1; x < width - 1; x++) {
+      int right = row_pixels[x + 1];
+      // A simple -1 4 -1 box filter with a weight of 2.
+      int luminance = ((center << 2) - left - right) >> 1;
+      if (luminance < blackPoint) {
+        array.set(x);
+      }
+      left = center;
+      center = right;
+    }
+
+    cached_row_ = row;
+    cached_row_num_ = y;
+    delete [] row_pixels;
+    return row;
+  } catch (IllegalArgumentException const& iae) {
+    // Cache the fact that this row failed.
+    cached_row_ = NULL;
+    cached_row_num_ = y;
+    delete [] row_pixels;
+    throw iae;
+  }
+}
+
+Ref<BitMatrix> GlobalHistogramBinarizer::getBlackMatrix() {
+  if (cached_matrix_ != NULL) {
+    return cached_matrix_;
+  }
+
+  // Faster than working with the reference
+  LuminanceSource& source = *getLuminanceSource();
+  int width = source.getWidth();
+  int height = source.getHeight();
+  vector<int> histogram(LUMINANCE_BUCKETS, 0);
+
+  // Quickly calculates the histogram by sampling four rows from the image.
+  // This proved to be more robust on the blackbox tests than sampling a
+  // diagonal as we used to do.
+  ArrayRef<unsigned char> ref (width);
+  unsigned char* row = &ref[0];
+  for (int y = 1; y < 5; y++) {
+    int rownum = height * y / 5;
+    int right = (width << 2) / 5;
+    row = source.getRow(rownum, row);
+    for (int x = width / 5; x < right; x++) {
+      histogram[row[x] >> LUMINANCE_SHIFT]++;
+    }
+  }
+
+  int blackPoint = estimate(histogram);
+
+  Ref<BitMatrix> matrix_ref(new BitMatrix(width, height));
+  BitMatrix& matrix = *matrix_ref;