Revision 16:79e57fcd26b3, committed 2018-12-11

Comitter:

TomoYamanaka

Date:

Tue Dec 11 12:07:40 2018 +0900

Parent:

15:30d929a6a82b

Child:

17:548cfbfba6d8

Commit message:

Delete unnecessary files.

Changed in this revision

--- a/zxing_lib/ImageReaderSource.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,77 +0,0 @@
-// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
-#ifndef __IMAGE_READER_SOURCE_H_
-#define __IMAGE_READER_SOURCE_H_
-/*
- *  Copyright 2010-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 "mbed.h"
-#include <iostream>
-#include <fstream>
-#include <string>
-#include <zxing/LuminanceSource.h>
-#include <zxing/common/Counted.h>
-#include <zxing/Binarizer.h>
-#include <zxing/MultiFormatReader.h>
-#include <zxing/Result.h>
-#include <zxing/ReaderException.h>
-#include <zxing/common/GlobalHistogramBinarizer.h>
-#include <zxing/common/HybridBinarizer.h>
-#include <exception>
-#include <zxing/Exception.h>
-#include <zxing/common/IllegalArgumentException.h>
-#include <zxing/BinaryBitmap.h>
-#include <zxing/DecodeHints.h>
-
-#include <zxing/qrcode/QRCodeReader.h>
-#include <zxing/multi/qrcode/QRCodeMultiReader.h>
-#include <zxing/multi/ByQuadrantReader.h>
-#include <zxing/multi/MultipleBarcodeReader.h>
-#include <zxing/multi/GenericMultipleBarcodeReader.h>
-
-using std::string;
-using std::ostringstream;
-using zxing::Ref;
-using zxing::ArrayRef;
-using zxing::LuminanceSource;
-
-using namespace std;
-using namespace zxing;
-using namespace zxing::multi;
-using namespace zxing::qrcode;
-
-
-class ImageReaderSource : public zxing::LuminanceSource {
-private:
-  typedef LuminanceSource Super;
-
-  const zxing::ArrayRef<char> image;
-  const int comps;
-
-  char convertPixel(const char* pixel) const;
-
-public:
-  static zxing::Ref<LuminanceSource> create(char* buf, int buf_size, int width, int height);
-
-  ImageReaderSource(zxing::ArrayRef<char> image, int width, int height, int comps);
-
-  zxing::ArrayRef<char> getRow(int y, zxing::ArrayRef<char> row) const;
-  zxing::ArrayRef<char> getMatrix() const;
-};
-
-extern int ex_decode(uint8_t* buf, int buf_size, int width, int height, vector<Ref<Result> > * results, DecodeHints &hints);
-
-
-#endif /* __IMAGE_READER_SOURCE_H_ */

Binary file zxing_lib/TOOLCHAIN_ARM_STD/zxing_lib.ar has changed

--- a/zxing_lib/zxing/BarcodeFormat.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,60 +0,0 @@
-// -*- 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 {
-
-class BarcodeFormat {
-public:
-  // if you update the enum, update BarcodeFormat.cpp
-
-  enum Value {
-    NONE,
-    AZTEC,
-    CODABAR,
-    CODE_39,
-    CODE_93,
-    CODE_128,
-    DATA_MATRIX,
-    EAN_8,
-    EAN_13,
-    ITF,
-    MAXICODE,
-    PDF_417,
-    QR_CODE,
-    RSS_14,
-    RSS_EXPANDED,
-    UPC_A,
-    UPC_E,
-    UPC_EAN_EXTENSION
-  };
-
-  BarcodeFormat(Value v) : value(v) {}  
-  const Value value;
-  operator Value () const {return value;}
-
-  static char const* barcodeFormatNames[];
-};
-
-}
-
-#endif // __BARCODE_FORMAT_H__

--- a/zxing_lib/zxing/Binarizer.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,50 +0,0 @@
-#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;
-
-  int getWidth() const;
-  int getHeight() const;
-
-};
-
-}
-#endif /* BINARIZER_H_ */

--- a/zxing_lib/zxing/BinaryBitmap.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,56 +0,0 @@
-#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_;
-		
-	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_ */

--- a/zxing_lib/zxing/DecodeHints.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,89 +0,0 @@
-// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
-#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;
-DecodeHints operator | (DecodeHints const&, DecodeHints const&);
-
-class DecodeHints {
- private:
-  DecodeHintType hints;
-  Ref<ResultPointCallback> callback;
-
- public:
-  static const DecodeHintType AZTEC_HINT = 1 << BarcodeFormat::AZTEC;
-  static const DecodeHintType CODABAR_HINT = 1 << BarcodeFormat::CODABAR;
-  static const DecodeHintType CODE_39_HINT = 1 << BarcodeFormat::CODE_39;
-  static const DecodeHintType CODE_93_HINT = 1 << BarcodeFormat::CODE_93;
-  static const DecodeHintType CODE_128_HINT = 1 << BarcodeFormat::CODE_128;
-  static const DecodeHintType DATA_MATRIX_HINT = 1 << BarcodeFormat::DATA_MATRIX;
-  static const DecodeHintType EAN_8_HINT = 1 << BarcodeFormat::EAN_8;
-  static const DecodeHintType EAN_13_HINT = 1 << BarcodeFormat::EAN_13;
-  static const DecodeHintType ITF_HINT = 1 << BarcodeFormat::ITF;
-  static const DecodeHintType MAXICODE_HINT = 1 << BarcodeFormat::MAXICODE;
-  static const DecodeHintType PDF_417_HINT = 1 << BarcodeFormat::PDF_417;
-  static const DecodeHintType QR_CODE_HINT = 1 << BarcodeFormat::QR_CODE;
-  static const DecodeHintType RSS_14_HINT = 1 << BarcodeFormat::RSS_14;
-  static const DecodeHintType RSS_EXPANDED_HINT = 1 << BarcodeFormat::RSS_EXPANDED;
-  static const DecodeHintType UPC_A_HINT = 1 << BarcodeFormat::UPC_A;
-  static const DecodeHintType UPC_E_HINT = 1 << BarcodeFormat::UPC_E;
-  static const DecodeHintType UPC_EAN_EXTENSION_HINT = 1 << BarcodeFormat::UPC_EAN_EXTENSION;
-
-#if defined(__ICCARM__)             //
-  static const DecodeHintType TRYHARDER_HINT = 0x80000000;
-#else
-  static const DecodeHintType TRYHARDER_HINT = 1 << 31;
-#endif                              //
-  static const DecodeHintType CHARACTER_SET = 1 << 30;
-  // static const DecodeHintType ALLOWED_LENGTHS = 1 << 29;
-  // static const DecodeHintType ASSUME_CODE_39_CHECK_DIGIT = 1 << 28;
-  static const DecodeHintType  ASSUME_GS1 = 1 << 27;
-  // static const DecodeHintType NEED_RESULT_POINT_CALLBACK = 1 << 26;
-  
-  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;
-  bool isEmpty() const {return (hints==0);}
-  void clear() {hints=0;}
-  void setTryHarder(bool toset);
-  bool getTryHarder() const;
-
-  void setResultPointCallback(Ref<ResultPointCallback> const&);
-  Ref<ResultPointCallback> getResultPointCallback() const;
-
-  friend DecodeHints operator | (DecodeHints const&, DecodeHints const&);
-};
-
-}
-
-#endif

--- a/zxing_lib/zxing/Exception.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,51 +0,0 @@
-// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
-#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:
-  char const* const message;
-
-public:
-  Exception() throw() : message(0) {}
-  Exception(const char* msg) throw() : message(copy(msg)) {}
-  Exception(Exception const& that) throw() : std::exception(that), message(copy(that.message)) {}
-  ~Exception() throw() {
-    if(message) {
-      deleteMessage();
-    }
-  }
-  char const* what() const throw() {return message ? message : "";}
-
-private:
-  static char const* copy(char const*);
-  void deleteMessage();
-};
-
-}
-
-#endif // __EXCEPTION_H__

--- a/zxing_lib/zxing/LuminanceSource.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,59 +0,0 @@
-// -*- 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 <zxing/common/Array.h>
-#include <string.h>
-
-namespace zxing {
-
-class LuminanceSource : public Counted {
- private:
-  const int width;
-  const int height;
-
- public:
-  LuminanceSource(int width, int height);
-  virtual ~LuminanceSource();
-
-  int getWidth() const { return width; }
-  int getHeight() const { return height; }
-
-  // Callers take ownership of the returned memory and must call delete [] on it themselves.
-  virtual ArrayRef<char> getRow(int y, ArrayRef<char> row) const = 0;
-  virtual ArrayRef<char> getMatrix() const = 0;
-
-  virtual bool isCropSupported() const;
-  virtual Ref<LuminanceSource> crop(int left, int top, int width, int height) const;
-
-  virtual bool isRotateSupported() const;
-
-  virtual Ref<LuminanceSource> invert() const;
-  
-  virtual Ref<LuminanceSource> rotateCounterClockwise() const;
-
-  operator std::string () const;
-};
-
-}
-
-#endif /* LUMINANCESOURCE_H_ */

--- a/zxing_lib/zxing/MultiFormatReader.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,48 +0,0 @@
-#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

--- a/zxing_lib/zxing/Reader.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,40 +0,0 @@
-#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__

--- a/zxing_lib/zxing/ReaderException.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,37 +0,0 @@
-// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
-#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() throw() {}
-  ReaderException(char const* msg) throw() : Exception(msg) {}
-  ~ReaderException() throw() {}
-};
-
-}
-
-#endif // __READER_EXCEPTION_H__

--- a/zxing_lib/zxing/Result.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,55 +0,0 @@
-#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 <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<char> rawBytes_;
-  ArrayRef< Ref<ResultPoint> > resultPoints_;
-  BarcodeFormat format_;
-
-public:
-  Result(Ref<String> text,
-         ArrayRef<char> rawBytes,
-         ArrayRef< Ref<ResultPoint> > resultPoints,
-         BarcodeFormat format);
-  ~Result();
-  Ref<String> getText();
-  ArrayRef<char> getRawBytes();
-  ArrayRef< Ref<ResultPoint> > const& getResultPoints() const;
-  ArrayRef< Ref<ResultPoint> >& getResultPoints();
-  BarcodeFormat getBarcodeFormat() const;
-
-  friend std::ostream& operator<<(std::ostream &out, Result& result);
-};
-
-}
-#endif // __RESULT_H__

--- a/zxing_lib/zxing/ResultPoint.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,55 +0,0 @@
-// -*- 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:
-  const float posX_;
-  const float posY_;
-  
-public:
-  ResultPoint();
-  ResultPoint(float x, float y);
-  ResultPoint(int x, int 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__

--- a/zxing_lib/zxing/ResultPointCallback.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,39 +0,0 @@
-#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__

--- a/zxing_lib/zxing/ZXing.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,135 +0,0 @@
-// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
-/*
- *  Copyright 2013 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.
- */
-#ifndef __ZXING_H_
-#define __ZXING_H_
-
-#define ZXING_ARRAY_LEN(v) ((int)(sizeof(v)/sizeof(v[0])))
-#define ZX_LOG_DIGITS(digits) \
-    ((digits == 8) ? 3 : \
-     ((digits == 16) ? 4 : \
-      ((digits == 32) ? 5 : \
-       ((digits == 64) ? 6 : \
-        ((digits == 128) ? 7 : \
-         (-1))))))
-
-#ifndef ZXING_DEBUG
-#define ZXING_DEBUG 0
-#endif
-
-namespace zxing {
-typedef char byte;
-typedef bool boolean;
-}
-
-#include <limits>
-
-#if defined(_WIN32) || defined(_WIN64)
-
-#include <float.h>
-
-namespace zxing {
-inline bool isnan(float v) {return _isnan(v) != 0;}
-inline bool isnan(double v) {return _isnan(v) != 0;}
-inline float nan() {return std::numeric_limits<float>::quiet_NaN();}
-}
-
-#else
-
-#include <cmath>
-
-namespace zxing {
-#if defined(__ICCARM__) || defined( __CC_ARM )  //
-#else                                           //
-inline bool isnan(float v) {return std::isnan(v);}
-inline bool isnan(double v) {return std::isnan(v);}
-#endif                                          //
-inline float nan() {return std::numeric_limits<float>::quiet_NaN();}
-}
-#endif
-
-#if ZXING_DEBUG
-
-#include <iostream>
-#include <string>
-
-using std::cout;
-using std::cerr;
-using std::endl;
-using std::flush;
-using std::string;
-using std::ostream;
-
-#if ZXING_DEBUG_TIMER
-
-#include <sys/time.h>
-
-namespace zxing {
-
-class DebugTimer {
-public:
-  DebugTimer(char const* string_) : chars(string_) {
-    gettimeofday(&start, 0);
-  }
-
-  DebugTimer(std::string const& string_) : chars(0), string(string_) {
-    gettimeofday(&start, 0);
-  }
-
-  void mark(char const* string) {
-    struct timeval end;
-    gettimeofday(&end, 0);
-    int diff =
-      (end.tv_sec - start.tv_sec)*1000*1000+(end.tv_usec - start.tv_usec);
-    
-    cerr << diff << " " << string << '\n';
-  }
-
-  void mark(std::string string) {
-    mark(string.c_str());
-  }
-
-  ~DebugTimer() {
-    if (chars) {
-      mark(chars);
-    } else {
-      mark(string.c_str());
-    }
-  }
-
-private:
-  char const* const chars;
-  std::string string;
-  struct timeval start;
-};
-
-}
-
-#define ZXING_TIME(string) DebugTimer __timer__ (string)
-#define ZXING_TIME_MARK(string) __timer__.mark(string)
-
-#endif
-
-#endif // ZXING_DEBUG
-
-#ifndef ZXING_TIME
-#define ZXING_TIME(string) (void)0
-#endif
-#ifndef ZXING_TIME_MARK
-#define ZXING_TIME_MARK(string) (void)0
-#endif
-
-#endif

--- a/zxing_lib/zxing/common/Array.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,170 +0,0 @@
-// -*- 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>
-
-#include <zxing/common/Counted.h>
-
-namespace zxing {
-
-template<typename T> class Array : public Counted {
-protected:
-public:
-  std::vector<T> values_;
-  Array() {}
-  Array(int n) :
-      Counted(), values_(n, T()) {
-  }
-  Array(T const* ts, int n) :
-      Counted(), values_(ts, ts+n) {
-  }
-  Array(T const* ts, T const* te) :
-      Counted(), values_(ts, te) {
-  }
-  Array(T v, int 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) {
-    values_ = other.values_;
-    return *this;
-  }
-  Array<T>& operator=(const std::vector<T> &array) {
-    values_ = array;
-    return *this;
-  }
-  T const& operator[](int i) const {
-    return values_[i];
-  }
-  T& operator[](int i) {
-    return values_[i];
-  }
-  int size() const {
-    return values_.size();
-  }
-  bool empty() const {
-    return values_.size() == 0;
-  }
-  std::vector<T> const& 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) {
-  }
-  explicit ArrayRef(int n) :
-      array_(0) {
-    reset(new Array<T> (n));
-  }
-  ArrayRef(T *ts, int n) :
-      array_(0) {
-    reset(new Array<T> (ts, n));
-  }
-  ArrayRef(Array<T> *a) :
-      array_(0) {
-    reset(a);
-  }
-  ArrayRef(const ArrayRef &other) :
-      Counted(), array_(0) {
-    reset(other.array_);
-  }
-
-  template<class Y>
-  ArrayRef(const ArrayRef<Y> &other) :
-      array_(0) {
-    reset(static_cast<const Array<T> *>(other.array_));
-  }
-
-  ~ArrayRef() {
-    if (array_) {
-      array_->release();
-    }
-    array_ = 0;
-  }
-
-  T const& operator[](int i) const {
-    return (*array_)[i];
-  }
-
-  T& operator[](int i) {
-    return (*array_)[i];
-  }
-
-  void reset(Array<T> *a) {
-    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*() const {
-    return *array_;
-  }
-
-  Array<T>* operator->() const {
-    return array_;
-  }
-
-  operator bool () const {
-    return array_ != 0;
-  }
-  bool operator ! () const {
-    return array_ == 0;
-  }
-};
-
-} // namespace zxing
-
-#endif // __ARRAY_H__

--- a/zxing_lib/zxing/common/BitArray.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,81 +0,0 @@
-// -*- 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/ZXing.h>
-#include <zxing/common/Counted.h>
-#include <zxing/common/IllegalArgumentException.h>
-#include <zxing/common/Array.h>
-#include <vector>
-#include <limits>
-#include <iostream>
-
-namespace zxing {
-
-class BitArray : public Counted {
-public:
-  static const int bitsPerWord = std::numeric_limits<unsigned int>::digits;
-
-private:
-  int size;
-  ArrayRef<int> bits;
-  static const int logBits = ZX_LOG_DIGITS(bitsPerWord);
-  static const int bitsMask = (1 << logBits) - 1;
-
-public:
-  BitArray(int size);
-  ~BitArray();
-  int getSize() const;
-
-  bool get(int i) const {
-    return (bits[i >> logBits] & (1 << (i & bitsMask))) != 0;
-  }
-
-  void set(int i) {
-    bits[i >> logBits] |= 1 << (i & bitsMask);
-  }
-
-  int getNextSet(int from);
-  int getNextUnset(int from);
-
-  void setBulk(int i, int newBits);
-  void setRange(int start, int end);
-  void clear();
-  bool isRange(int start, int end, bool value);
-  std::vector<int>& getBitArray();
-  
-  void reverse();
-
-  class Reverse {
-   private:
-    Ref<BitArray> array;
-   public:
-    Reverse(Ref<BitArray> array);
-    ~Reverse();
-  };
-
-private:
-  static int makeArraySize(int size);
-};
-
-std::ostream& operator << (std::ostream&, BitArray const&);
-
-}
-
-#endif // __BIT_ARRAY_H__

--- a/zxing_lib/zxing/common/BitMatrix.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,94 +0,0 @@
-// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
-#ifndef __BIT_MATRIX_H__
-#define __BIT_MATRIX_H__
-
-/*
- *  BitMatrix.h
- *  zxing
- *
- *  Copyright 2010 ZXing authors All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <zxing/common/Counted.h>
-#include <zxing/common/BitArray.h>
-#include <zxing/common/Array.h>
-#include <limits>
-#if defined(__ICCARM__)             //
-#include <stddef.h> /*for size_t*/  //
-#endif                              //
-
-namespace zxing {
-
-class BitMatrix : public Counted {
-public:
-  static const int bitsPerWord = std::numeric_limits<unsigned int>::digits;
-
-private:
-  int width;
-  int height;
-  int rowSize;
-  ArrayRef<int> bits;
-
-#define ZX_LOG_DIGITS(digits) \
-    ((digits == 8) ? 3 : \
-     ((digits == 16) ? 4 : \
-      ((digits == 32) ? 5 : \
-       ((digits == 64) ? 6 : \
-        ((digits == 128) ? 7 : \
-         (-1))))))
-
-  static const int logBits = ZX_LOG_DIGITS(bitsPerWord);
-  static const int bitsMask = (1 << logBits) - 1;
-
-public:
-  BitMatrix(int dimension);
-  BitMatrix(int width, int height);
-
-  ~BitMatrix();
-
-  bool get(int x, int y) const {
-    int offset = y * rowSize + (x >> logBits);
-    return ((((unsigned)bits[offset]) >> (x & bitsMask)) & 1) != 0;
-  }
-
-  void set(int x, int y) {
-    int offset = y * rowSize + (x >> logBits);
-    bits[offset] |= 1 << (x & bitsMask);
-  }
-
-  void flip(int x, int y);
-  void clear();
-  void setRegion(int left, int top, int width, int height);
-  Ref<BitArray> getRow(int y, Ref<BitArray> row);
-
-  int getWidth() const;
-  int getHeight() const;
-
-  ArrayRef<int> getTopLeftOnBit() const;
-  ArrayRef<int> getBottomRightOnBit() const;
-
-  friend std::ostream& operator<<(std::ostream &out, const BitMatrix &bm);
-  const char *description();
-
-private:
-  inline void init(int, int);
-
-  BitMatrix(const BitMatrix&);
-  BitMatrix& operator =(const BitMatrix&);
-};
-
-}
-
-#endif // __BIT_MATRIX_H__

--- a/zxing_lib/zxing/common/Counted.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,140 +0,0 @@
-// -*- 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.
- */
-
-#include <iostream>
-
-namespace zxing {
-
-/* base class for reference-counted objects */
-class Counted {
-private:
-  unsigned int count_;
-public:
-  Counted() :
-      count_(0) {
-  }
-  virtual ~Counted() {
-  }
-  Counted *retain() {
-    count_++;
-    return this;
-  }
-  void release() {
-    count_--;
-    if (count_ == 0) {
-      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) {
-    reset(o);
-  }
-  Ref(const Ref &other) :
-      object_(0) {
-    reset(other.object_);
-  }
-
-  template<class Y>
-  Ref(const Ref<Y> &other) :
-      object_(0) {
-    reset(other.object_);
-  }
-
-  ~Ref() {
-    if (object_) {
-      object_->release();
-    }
-  }
-
-  void reset(T *o) {
-    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;
-  }
-};
-
-}
-
-#endif // __COUNTED_H__

--- a/zxing_lib/zxing/common/DecoderResult.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,51 +0,0 @@
-#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<char> rawBytes_;
-  Ref<String> text_;
-  ArrayRef< ArrayRef<char> > byteSegments_;
-  std::string ecLevel_;
-
-public:
-  DecoderResult(ArrayRef<char> rawBytes,
-                Ref<String> text,
-                ArrayRef< ArrayRef<char> >& byteSegments,
-                std::string const& ecLevel);
-
-  DecoderResult(ArrayRef<char> rawBytes, Ref<String> text);
-
-  ArrayRef<char> getRawBytes();
-  Ref<String> getText();
-};
-
-}
-
-#endif // __DECODER_RESULT_H__

--- a/zxing_lib/zxing/common/GlobalHistogramBinarizer.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,48 +0,0 @@
-// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
-#ifndef __GLOBALHISTOGRAMBINARIZER_H__
-#define __GLOBALHISTOGRAMBINARIZER_H__
-/*
- *  GlobalHistogramBinarizer.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/Binarizer.h>
-#include <zxing/common/BitArray.h>
-#include <zxing/common/BitMatrix.h>
-#include <zxing/common/Array.h>
-
-namespace zxing {
-	
-class GlobalHistogramBinarizer : public Binarizer {
-private:
-  ArrayRef<char> luminances;
-  ArrayRef<int> buckets;
-public:
-  GlobalHistogramBinarizer(Ref<LuminanceSource> source);
-  virtual ~GlobalHistogramBinarizer();
-		
-  virtual Ref<BitArray> getBlackRow(int y, Ref<BitArray> row);
-  virtual Ref<BitMatrix> getBlackMatrix();
-  static int estimateBlackPoint(ArrayRef<int> const& buckets);
-  Ref<Binarizer> createBinarizer(Ref<LuminanceSource> source);
-private:
-  void initArrays(int luminanceSize);
-};
-
-}
-	
-#endif /* GLOBALHISTOGRAMBINARIZER_H_ */

--- a/zxing_lib/zxing/common/HybridBinarizer.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,67 +0,0 @@
-// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
-#ifndef __HYBRIDBINARIZER_H__
-#define __HYBRIDBINARIZER_H__
-/*
- *  HybridBinarizer.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/Binarizer.h>
-#include <zxing/common/GlobalHistogramBinarizer.h>
-#include <zxing/common/BitArray.h>
-#include <zxing/common/BitMatrix.h>
-
-namespace zxing {
-	
-	class HybridBinarizer : public GlobalHistogramBinarizer {
-	 private:
-    Ref<BitMatrix> matrix_;
-	  Ref<BitArray> cached_row_;
-
-	public:
-		HybridBinarizer(Ref<LuminanceSource> source);
-		virtual ~HybridBinarizer();
-		
-		virtual Ref<BitMatrix> getBlackMatrix();
-		Ref<Binarizer> createBinarizer(Ref<LuminanceSource> source);
-  private:
-    // We'll be using one-D arrays because C++ can't dynamically allocate 2D
-    // arrays
-    ArrayRef<int> calculateBlackPoints(ArrayRef<char> luminances,
-                                       int subWidth,
-                                       int subHeight,
-                                       int width,
-                                       int height);
-    void calculateThresholdForBlock(ArrayRef<char> luminances,
-                                    int subWidth,
-                                    int subHeight,
-                                    int width,
-                                    int height,
-                                    ArrayRef<int> blackPoints,
-                                    Ref<BitMatrix> const& matrix);
-    void thresholdBlock(ArrayRef<char>luminances,
-                        int xoffset,
-                        int yoffset,
-                        int threshold,
-                        int stride,
-                        Ref<BitMatrix> const& matrix);
-	};
-
-}
-
-#endif

--- a/zxing_lib/zxing/common/IllegalArgumentException.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,36 +0,0 @@
-#ifndef __ILLEGAL_ARGUMENT_EXCEPTION_H__
-#define __ILLEGAL_ARGUMENT_EXCEPTION_H__
-
-/*
- *  IllegalArgumentException.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 IllegalArgumentException : public Exception {
-public:
-  IllegalArgumentException();
-  IllegalArgumentException(const char *msg);
-  ~IllegalArgumentException() throw();
-};
-
-}
-
-#endif // __ILLEGAL_ARGUMENT_EXCEPTION_H__

--- a/zxing_lib/zxing/common/Str.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,51 +0,0 @@
-// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
-#ifndef __STR_H__
-#define __STR_H__
-
-/*
- *  Str.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 <iostream>
-#include <zxing/common/Counted.h>
-
-namespace zxing {
-
-class String;
-std::ostream& operator << (std::ostream& out, String const& s);
-
-class String : public Counted {
-private:
-  std::string text_;
-public:
-  explicit String(const std::string &text);
-  explicit String(int);
-  char charAt(int) const;
-  Ref<String> substring(int) const;
-  const std::string& getText() const;
-  int size() const;
-  void append(std::string const& tail);
-  void append(char c);
-  int length() const;
-  friend std::ostream& zxing::operator << (std::ostream& out, String const& s);
-};
-
-}
-
-#endif // __COMMON__STRING_H__

--- a/zxing_lib/zxing/common/reedsolomon/GenericGF.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,73 +0,0 @@
-// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
-/*
- *  GenericGF.h
- *  zxing
- *
- *  Created by Lukas Stabe on 13/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.
- */
-
-#ifndef GENERICGF_H
-#define GENERICGF_H
-
-#include <vector>
-#include <zxing/common/Counted.h>
-
-namespace zxing {
-  class GenericGFPoly;
-  
-  class GenericGF : public Counted {
-    
-  private:
-    std::vector<int> expTable;
-    std::vector<int> logTable;
-    Ref<GenericGFPoly> zero;
-    Ref<GenericGFPoly> one;
-    int size;
-    int primitive;
-    int generatorBase;
-    bool initialized;
-    
-    void initialize();
-    void checkInit();
-    
-  public:
-    static Ref<GenericGF> AZTEC_DATA_12;
-    static Ref<GenericGF> AZTEC_DATA_10;
-    static Ref<GenericGF> AZTEC_DATA_8;
-    static Ref<GenericGF> AZTEC_DATA_6;
-    static Ref<GenericGF> AZTEC_PARAM;
-    static Ref<GenericGF> QR_CODE_FIELD_256;
-    static Ref<GenericGF> DATA_MATRIX_FIELD_256;
-    static Ref<GenericGF> MAXICODE_FIELD_64;
-    
-    GenericGF(int primitive, int size, int b);
-    
-    Ref<GenericGFPoly> getZero();
-    Ref<GenericGFPoly> getOne();
-    int getSize();
-    int getGeneratorBase();
-    Ref<GenericGFPoly> buildMonomial(int degree, int coefficient);
-    
-    static int addOrSubtract(int a, int b);
-    int exp(int a);
-    int log(int a);
-    int inverse(int a);
-    int multiply(int a, int b);
-  };
-}
-
-#endif //GENERICGF_H
-

--- a/zxing_lib/zxing/common/reedsolomon/GenericGFPoly.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,56 +0,0 @@
-// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
-/*
- *  GenericGFPoly.h
- *  zxing
- *
- *  Created by Lukas Stabe on 13/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.
- */
-
-#ifndef GENERICGFPOLY_H
-#define GENERICGFPOLY_H
-
-#include <vector>
-#include <zxing/common/Array.h>
-#include <zxing/common/Counted.h>
-
-namespace zxing {
-
-class GenericGF;
-  
-class GenericGFPoly : public Counted {
-private:
-  GenericGF &field_;
-  ArrayRef<int> coefficients_;
-    
-public:
-  GenericGFPoly(GenericGF &field, ArrayRef<int> coefficients);
-  ArrayRef<int> getCoefficients();
-  int getDegree();
-  bool isZero();
-  int getCoefficient(int degree);
-  int evaluateAt(int a);
-  Ref<GenericGFPoly> addOrSubtract(Ref<GenericGFPoly> other);
-  Ref<GenericGFPoly> multiply(Ref<GenericGFPoly> other);
-  Ref<GenericGFPoly> multiply(int scalar);
-  Ref<GenericGFPoly> multiplyByMonomial(int degree, int coefficient);
-  std::vector<Ref<GenericGFPoly> > divide(Ref<GenericGFPoly> other);
-    
-
-};
-
-}
-
-#endif //GENERICGFPOLY_H

--- a/zxing_lib/zxing/common/reedsolomon/ReedSolomonDecoder.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,49 +0,0 @@
-#ifndef __REED_SOLOMON_DECODER_H__
-#define __REED_SOLOMON_DECODER_H__
-
-/*
- *  ReedSolomonDecoder.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 <memory>
-#include <vector>
-#include <zxing/common/Counted.h>
-#include <zxing/common/Array.h>
-#include <zxing/common/reedsolomon/GenericGFPoly.h>
-#include <zxing/common/reedsolomon/GenericGF.h>
-
-namespace zxing {
-class GenericGFPoly;
-class GenericGF;
-
-class ReedSolomonDecoder {
-private:
-  Ref<GenericGF> field;
-public:
-  ReedSolomonDecoder(Ref<GenericGF> fld);
-  ~ReedSolomonDecoder();
-  void decode(ArrayRef<int> received, int twoS);
-  std::vector<Ref<GenericGFPoly> > runEuclideanAlgorithm(Ref<GenericGFPoly> a, Ref<GenericGFPoly> b, int R);
-
-private:
-  ArrayRef<int> findErrorLocations(Ref<GenericGFPoly> errorLocator);
-  ArrayRef<int> findErrorMagnitudes(Ref<GenericGFPoly> errorEvaluator, ArrayRef<int> errorLocations);
-};
-}
-
-#endif // __REED_SOLOMON_DECODER_H__

--- a/zxing_lib/zxing/multi/ByQuadrantReader.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,42 +0,0 @@
-#ifndef __BY_QUADRANT_READER_H__
-#define __BY_QUADRANT_READER_H__
-
-/*
- *  Copyright 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/Reader.h>
-#include <zxing/BinaryBitmap.h>
-#include <zxing/Result.h>
-#include <zxing/DecodeHints.h>
-
-namespace zxing {
-namespace multi {
-
-class ByQuadrantReader : public Reader {
-  private:
-    Reader& delegate_;
-
-  public:
-    ByQuadrantReader(Reader& delegate);
-    virtual ~ByQuadrantReader();
-    virtual Ref<Result> decode(Ref<BinaryBitmap> image);
-    virtual Ref<Result> decode(Ref<BinaryBitmap> image, DecodeHints hints);
-};
-
-}
-}
-
-#endif // __BY_QUADRANT_READER_H__

--- a/zxing_lib/zxing/multi/GenericMultipleBarcodeReader.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,51 +0,0 @@
-// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
-#ifndef __GENERIC_MULTIPLE_BARCODE_READER_H__
-#define __GENERIC_MULTIPLE_BARCODE_READER_H__
-
-/*
- *  Copyright 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/multi/MultipleBarcodeReader.h>
-#include <zxing/Reader.h>
-
-namespace zxing {
-namespace multi {
-
-class GenericMultipleBarcodeReader : public MultipleBarcodeReader {
- private:
-  static Ref<Result> translateResultPoints(Ref<Result> result, 
-                                           int xOffset, 
-                                           int yOffset);
-  void doDecodeMultiple(Ref<BinaryBitmap> image, 
-                        DecodeHints hints, 
-                        std::vector<Ref<Result> >& results, 
-                        int xOffset, 
-                        int yOffset,
-                        int currentDepth);
-  Reader& delegate_;
-  static const int MIN_DIMENSION_TO_RECUR = 100;
-  static const int MAX_DEPTH = 4;
-
- public:
-  GenericMultipleBarcodeReader(Reader& delegate);
-  virtual ~GenericMultipleBarcodeReader();
-  virtual std::vector<Ref<Result> > decodeMultiple(Ref<BinaryBitmap> image, DecodeHints hints);
-};
-
-}
-}
-
-#endif // __GENERIC_MULTIPLE_BARCODE_READER_H__

--- a/zxing_lib/zxing/multi/MultipleBarcodeReader.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,41 +0,0 @@
-#ifndef __MULTIPLE_BARCODE_READER_H__
-#define __MULTIPLE_BARCODE_READER_H__
-
-/*
- *  Copyright 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/Counted.h>
-#include <zxing/Result.h>
-#include <zxing/BinaryBitmap.h>
-#include <zxing/DecodeHints.h>
-#include <vector>
-
-namespace zxing {
-namespace multi {
-
-class MultipleBarcodeReader : public Counted {
-  protected:
-    MultipleBarcodeReader() {}
-  public:
-    virtual std::vector<Ref<Result> > decodeMultiple(Ref<BinaryBitmap> image);
-    virtual std::vector<Ref<Result> > decodeMultiple(Ref<BinaryBitmap> image, DecodeHints hints) = 0;
-    virtual ~MultipleBarcodeReader();
-};
-
-}
-}
-
-#endif // __MULTIPLE_BARCODE_READER_H__

--- a/zxing_lib/zxing/multi/qrcode/QRCodeMultiReader.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,36 +0,0 @@
-#ifndef __QRCODE_MULTI_READER_H__
-#define __QRCODE_MULTI_READER_H__
-
-/*
- *  Copyright 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/multi/MultipleBarcodeReader.h>
-#include <zxing/qrcode/QRCodeReader.h>
-
-namespace zxing {
-namespace multi {
-
-class QRCodeMultiReader: public zxing::qrcode::QRCodeReader, public MultipleBarcodeReader {
-  public:
-    QRCodeMultiReader();
-    virtual ~QRCodeMultiReader();
-    virtual std::vector<Ref<Result> > decodeMultiple(Ref<BinaryBitmap> image, DecodeHints hints);
-};
-
-}
-}
-
-#endif // __QRCODE_MULTI_READER_H__

--- a/zxing_lib/zxing/qrcode/QRCodeReader.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,48 +0,0 @@
-// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
-#ifndef __QR_CODE_READER_H__
-#define __QR_CODE_READER_H__
-
-/*
- *  QRCodeReader.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/qrcode/decoder/Decoder.h>
-#include <zxing/DecodeHints.h>
-
-namespace zxing {
-namespace qrcode {
-		
-class QRCodeReader : public Reader {
- private:
-  Decoder decoder_;
-			
- protected:
-  Decoder& getDecoder();
-
- public:
-  QRCodeReader();
-  virtual ~QRCodeReader();
-			
-  Ref<Result> decode(Ref<BinaryBitmap> image, DecodeHints hints);
-};
-
-}
-}
-
-#endif // __QR_CODE_READER_H__

--- a/zxing_lib/zxing/qrcode/decoder/Decoder.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,46 +0,0 @@
-#ifndef __DECODER_H__
-#define __DECODER_H__
-
-/*
- *  Decoder.h
- *  zxing
- *
- *  Copyright 2010 ZXing authors All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <zxing/common/reedsolomon/ReedSolomonDecoder.h>
-#include <zxing/common/Counted.h>
-#include <zxing/common/Array.h>
-#include <zxing/common/DecoderResult.h>
-#include <zxing/common/BitMatrix.h>
-
-namespace zxing {
-namespace qrcode {
-
-class Decoder {
-private:
-  ReedSolomonDecoder rsDecoder_;
-
-  void correctErrors(ArrayRef<char> bytes, int numDataCodewords);
-
-public:
-  Decoder();
-  Ref<DecoderResult> decode(Ref<BitMatrix> bits);
-};
-
-}
-}
-
-#endif // __DECODER_H__

--- a/zxing_lib/zxing_config.h	Tue Dec 11 02:53:53 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,21 +0,0 @@
-
-/**** User Selection *********/
-
-//#define ZXING_EXCLUDE_1DCODE                      /* define : 1D barcodes can not be scanned */
-#undef ZXING_EXCLUDE_1DCODE                         /* undef  : 1D barcodes can be scanned */
-                                                    
-//#define ZXING_EXCLUDE_QRCODE                      /* define : QR-code can not be scanned */
-#undef ZXING_EXCLUDE_QRCODE                         /* undef  : QR-code can be scanned */
-                                                    
-//#define ZXING_EXCLUDE_MATRIX                      /* define : Matrix can not be scanned */
-#undef ZXING_EXCLUDE_MATRIX                         /* undef  : Matrix can be scanned */
-                                                    
-//#define ZXING_EXCLUDE_AZTEC                       /* define : Aztec can not be scanned */
-#undef ZXING_EXCLUDE_AZTEC                          /* undef  : Aztec can be scanned */
-                                                    
-//#define ZXING_EXCLUDE_PDF417                      /* define : PDF417 can not be scanned */
-#undef ZXING_EXCLUDE_PDF417                         /* undef  : PDF417 can be scanned */
-
-//#define ZXING_MULTI_QUADRANT                      /* define : Zxing can multi decode */
-#undef ZXING_MULTI_QUADRANT                         /* undef  : Zxing can not multi decode */
-