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

[David Planella]

Initial merge of the QZXing plugin into the app's code.

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.

Unmerged revisions

45. By David Planella on 2014-05-10

Fixed tabs/pages navigation

44. By David Planella on 2014-04-17

Removed old project files no longer needed for the cmake build

43. By David Planella on 2014-04-17

Initial conversion to CMake

42. By David Planella on 2013-11-27

Disable automatic orientation for now

41. By David Planella on 2013-11-27

Some more source tree layout reorg for the QML files

40. By David Planella on 2013-11-27

Improved video output, it now displays full-screen

39. By David Planella on 2013-11-27

Temporarily removed cropping on capturing image

38. By David Planella on 2013-11-27

Slight reorg of QML files

37. By David Planella on 2013-11-27

Removed hardcoded desktop file name on the script to run on device

36. By David Planella on 2013-11-27

Reorganized code to include the zxing plugin in the same source tree as the app

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2014-05-10 17:37:18 +0000
@@ -0,0 +1,7 @@
+qreator.qmlproject.user
+qreator-touch.qmlproject.user
+jsqrcode
+plugins
+.excludes
+qreator.pro.user
+CMakeLists.txt.user

=== renamed file '.bzrignore' => '.bzrignore.moved'
=== 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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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:37:18 +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));