zxing_cpp 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b419584e04c824a4e3075c1a38e558753aaca225
-  data.tar.gz: d5775f7156f64249e2f3097c5df41872fdbacf96
+  metadata.gz: 27d404f02e304a2cc3855d6ba0bb4548d5f28c2d
+  data.tar.gz: d9b4fb14bd03951572190e9ddb86bfda39204e73
 SHA512:
-  metadata.gz: f96bf92589a3e14a42dfe36dacc0d2c439945cdf049ff97a69bbbddd5983c33a7f0ffae8a17c4026e3fddd687eb349f469b44ea19f9863c93c7e66a0e57c57bf
-  data.tar.gz: 09b88b47d439346d20a4a36666bf6b4d95839040d6a910a6bde11646f1fcfb7d8697f6614918ba5c9b3951abe8fd9dddf0760485df36689fa8b675fba100bdbc
+  metadata.gz: 7eee23288c0e7ee238911ce047d518f158bb9e765996681c4dba5c6784ec791f5723f04d307e4dc85d088c26d3052d0417c0e28fb2846189bb6557edfb3a9fc9
+  data.tar.gz: 51dd2a2318a7380920fd45e649b3ac82ee574c76d22335e6a1587ecbc36411eb8540c007cfae344ff2f18b92fac856a73bcbde1bb88210fdb9ac77311f824d9c

data/README.rdoc

@@ -23,14 +23,14 @@ The {bug tracker}[https://github.com/glassechidna/zxing_cpp.rb/issues] is availa
   require 'zxing'
   result = ZXing.decode "myimage.png"
 
-zxing.rb also comes with a command that decodes images: zxd:
+zxing_cpp also comes with a command that decodes images: zxd:
 
   $ zxd filename.png
   <decoded contents>
 
 +zxd+ can take multiple arguments and the arguments can be URLs.
 
-zxing.rb provides access to many of the classes of ZXing classes like
+zxing_cpp provides access to many of the classes of ZXing classes like
 readers, luminance sources, binarizers, so you can mix and match your
 own applications much as you would with a native Java or C++ app. See
 +zxd+ and +test/vendor.rb+ for examples.
@@ -90,25 +90,24 @@ is yet to be written.
 * Ruby (>= 1.9)
 * CMake (>= 2.8.0)
 
-zxing.rb bundles a version of the ZXing C++ library (zxing-cpp).
+zxing_cpp bundles a version of the ZXing C++ library (zxing-cpp).
 
 == INSTALL:
 
-The gem has yet to be submitted to RubyGems. For now you must clone
-the repo and execute:
+If you're using RubyGems (probably), then simply add the following to your <tt>Gemfile</tt>:
 
-  rake gem
-  gem install pkg/zxing_cpp-0.1.0.gem
+    gem 'zxing_cpp'
 
-or add it zxing_cpp to your Gemfile:
+Alternatively, you could clone the {zxing_cpp repo}[https://github.com/glassechidna/zxing_cpp.rb] and execute:
 
-  gem 'zxing_cpp', git: 'https://github.com/glassechidna/zxing_cpp.rb.git', submodules: true
+  rake gem
+  gem install pkg/zxing_cpp-0.1.0.gem
 
 == DEVELOPMENT:
 
   rake test
 
-<tt>rake test</tt> runs the zxing.rb unit tests.
+<tt>rake test</tt> runs the zxing_cpp unit tests.
 
 == LICENSE:
 

data/ext/zxing/zxing-cpp/CMakeLists.txt

@@ -68,6 +68,11 @@ file(GLOB_RECURSE ZXING_FILES
 )
 add_executable(zxing ${ZXING_FILES})
 target_link_libraries(zxing libzxing)
+install(TARGETS zxing libzxing
+	LIBRARY DESTINATION lib
+	RUNTIME DESTINATION bin
+	ARCHIVE DESTINATION lib)
+install(DIRECTORY core/src/zxing/ DESTINATION include/zxing FILES_MATCHING PATTERN "*.h")
 
 # Add testrunner executable.
 find_package(CPPUNIT)

data/ext/zxing/zxing-cpp/README.md

@@ -26,7 +26,8 @@ Usage with CLion or Qt Creator:
 
 Usage with Makefiles, Visual Studio, etc. (see `cmake --help` for a complete list of generators):
 
-  1. `cd` to `cpp/build`
+  1. `mkdir build`
+  2. `cd` to `build`
   3. Unix: run `cmake -G "Unix Makefiles" ..`
   3. Windows: run `cmake -G "Visual Studio 10" ..`
   
@@ -42,9 +43,3 @@ To profile the code (very useful to optimize the code):
   1. Install Valgrind
   2. Run `valgrind --tool=callgrind build/zxing - path/to/test/data/*.jpg > report.html`
   3. Analyze output using KCachegrind
-
-To run the black box tests and check for changes:
-
-  1. Build `zxing-img`, e.g., scons zxing
-  2. Run the tests: `bash blackboxtest.sh 2>&1 | tee bb.results`
-  3. Diff them with the known results: `diff bb.results blackboxtest.results`

data/ext/zxing/zxing-cpp/cli/src/ImageReaderSource.cpp

@@ -75,6 +75,7 @@ Ref<LuminanceSource> ImageReaderSource::create(string const& filename) {
     char *buffer = reinterpret_cast<char*>(jpgd::decompress_jpeg_image_from_file(
         filename.c_str(), &width, &height, &comps, 4));
     image = zxing::ArrayRef<char>(buffer, 4 * width * height);
+    free(buffer);
   }
   if (!image) {
     ostringstream msg;

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

@@ -24,8 +24,8 @@ 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;
+std::map<int, zxing::Ref<CharacterSetECI> > CharacterSetECI::VALUE_TO_ECI;
+std::map<std::string, zxing::Ref<CharacterSetECI> > CharacterSetECI::NAME_TO_ECI;
 
 const bool CharacterSetECI::inited = CharacterSetECI::init_tables();
 
@@ -72,11 +72,12 @@ bool CharacterSetECI::init_tables() {
 CharacterSetECI::CharacterSetECI(int const* values,
                                  char const* const* names) 
   : values_(values), names_(names) {
+  zxing::Ref<CharacterSetECI> this_ref(this);
   for(int const* values = values_; *values != -1; values++) {
-    VALUE_TO_ECI[*values] = this;
+    VALUE_TO_ECI[*values] = this_ref;
   }
   for(char const* const* names = names_; *names; names++) {
-    NAME_TO_ECI[string(*names)] = this;
+    NAME_TO_ECI[string(*names)] = this_ref;
   }
 }
 

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

@@ -25,10 +25,10 @@
 namespace zxing {
 namespace common {
 
-class CharacterSetECI {
+class CharacterSetECI : public Counted {
 private:
-  static std::map<int, CharacterSetECI*> VALUE_TO_ECI;
-  static std::map<std::string, CharacterSetECI*> NAME_TO_ECI;
+  static std::map<int, zxing::Ref<CharacterSetECI> > VALUE_TO_ECI;
+  static std::map<std::string, zxing::Ref<CharacterSetECI> > NAME_TO_ECI;
   static const bool inited;
   static bool init_tables();
 

data/ext/zxing/zxing-cpp/core/src/zxing/common/detector/MonochromeRectangleDetector.cpp

@@ -22,6 +22,7 @@
 #include <zxing/NotFoundException.h>
 #include <zxing/common/detector/MonochromeRectangleDetector.h>
 #include <sstream>
+#include <algorithm>  // vs12, std::min und std:max
 
 using std::vector;
 using zxing::Ref;

data/ext/zxing/zxing-cpp/core/src/zxing/common/reedsolomon/GenericGF.cpp

@@ -67,10 +67,10 @@ void GenericGF::initialize() {
   }
   //logTable[0] == 0 but this should never be used
   zero =
-    Ref<GenericGFPoly>(new GenericGFPoly(Ref<GenericGF>(this), ArrayRef<int>(new Array<int>(1))));
+    Ref<GenericGFPoly>(new GenericGFPoly(*this, ArrayRef<int>(new Array<int>(1))));
   zero->getCoefficients()[0] = 0;
   one =
-    Ref<GenericGFPoly>(new GenericGFPoly(Ref<GenericGF>(this), ArrayRef<int>(new Array<int>(1))));
+    Ref<GenericGFPoly>(new GenericGFPoly(*this, ArrayRef<int>(new Array<int>(1))));
   one->getCoefficients()[0] = 1;
   initialized = true;
 }
@@ -103,7 +103,7 @@ Ref<GenericGFPoly> GenericGF::buildMonomial(int degree, int coefficient) {
   ArrayRef<int> coefficients(new Array<int>(degree + 1));
   coefficients[0] = coefficient;
     
-  return Ref<GenericGFPoly>(new GenericGFPoly(Ref<GenericGF>(this), coefficients));
+  return Ref<GenericGFPoly>(new GenericGFPoly(*this, coefficients));
 }
   
 int GenericGF::addOrSubtract(int a, int b) {

data/ext/zxing/zxing-cpp/core/src/zxing/common/reedsolomon/GenericGFPoly.cpp

@@ -31,7 +31,7 @@ using zxing::Ref;
 // VC++
 using zxing::GenericGF;
 
-GenericGFPoly::GenericGFPoly(Ref<GenericGF> field,
+GenericGFPoly::GenericGFPoly(GenericGF &field,
                              ArrayRef<int> coefficients)
   :  field_(field) {
   if (coefficients->size() == 0) {
@@ -45,7 +45,7 @@ GenericGFPoly::GenericGFPoly(Ref<GenericGF> field,
       firstNonZero++;
     }
     if (firstNonZero == coefficientsLength) {
-      coefficients_ = field->getZero()->getCoefficients();
+      coefficients_ = field.getZero()->getCoefficients();
     } else {
       coefficients_ = ArrayRef<int>(new Array<int>(coefficientsLength-firstNonZero));
       for (int i = 0; i < (int)coefficients_->size(); i++) {
@@ -90,13 +90,13 @@ int GenericGFPoly::evaluateAt(int a) {
   }
   int result = coefficients_[0];
   for (int i = 1; i < size; i++) {
-    result = GenericGF::addOrSubtract(field_->multiply(a, result), coefficients_[i]);
+    result = GenericGF::addOrSubtract(field_.multiply(a, result), coefficients_[i]);
   }
   return result;
 }
   
 Ref<GenericGFPoly> GenericGFPoly::addOrSubtract(Ref<zxing::GenericGFPoly> other) {
-  if (!(field_.object_ == other->field_.object_)) {
+  if (!(&field_ == &other->field_)) {
     throw IllegalArgumentException("GenericGFPolys do not have same GenericGF field");
   }
   if (isZero()) {
@@ -130,12 +130,12 @@ Ref<GenericGFPoly> GenericGFPoly::addOrSubtract(Ref<zxing::GenericGFPoly> other)
 }
   
 Ref<GenericGFPoly> GenericGFPoly::multiply(Ref<zxing::GenericGFPoly> other) {
-  if (!(field_.object_ == other->field_.object_)) {
+  if (!(&field_ == &other->field_)) {
     throw IllegalArgumentException("GenericGFPolys do not have same GenericGF field");
   }
     
   if (isZero() || other->isZero()) {
-    return field_->getZero();
+    return field_.getZero();
   }
     
   ArrayRef<int> aCoefficients = coefficients_;
@@ -149,7 +149,7 @@ Ref<GenericGFPoly> GenericGFPoly::multiply(Ref<zxing::GenericGFPoly> other) {
     int aCoeff = aCoefficients[i];
     for (int j = 0; j < bLength; j++) {
       product[i+j] = GenericGF::addOrSubtract(product[i+j], 
-                                              field_->multiply(aCoeff, bCoefficients[j]));
+                                              field_.multiply(aCoeff, bCoefficients[j]));
     }
   }
     
@@ -158,7 +158,7 @@ Ref<GenericGFPoly> GenericGFPoly::multiply(Ref<zxing::GenericGFPoly> other) {
   
 Ref<GenericGFPoly> GenericGFPoly::multiply(int scalar) {
   if (scalar == 0) {
-    return field_->getZero();
+    return field_.getZero();
   }
   if (scalar == 1) {
     return Ref<GenericGFPoly>(this);
@@ -166,7 +166,7 @@ Ref<GenericGFPoly> GenericGFPoly::multiply(int scalar) {
   int size = coefficients_->size();
   ArrayRef<int> product(new Array<int>(size));
   for (int i = 0; i < size; i++) {
-    product[i] = field_->multiply(coefficients_[i], scalar);
+    product[i] = field_.multiply(coefficients_[i], scalar);
   }
   return Ref<GenericGFPoly>(new GenericGFPoly(field_, product));
 }
@@ -176,42 +176,42 @@ Ref<GenericGFPoly> GenericGFPoly::multiplyByMonomial(int degree, int coefficient
     throw IllegalArgumentException("degree must not be less then 0");
   }
   if (coefficient == 0) {
-    return field_->getZero();
+    return field_.getZero();
   }
   int size = coefficients_->size();
   ArrayRef<int> product(new Array<int>(size+degree));
   for (int i = 0; i < size; i++) {
-    product[i] = field_->multiply(coefficients_[i], coefficient);
+    product[i] = field_.multiply(coefficients_[i], coefficient);
   }
   return Ref<GenericGFPoly>(new GenericGFPoly(field_, product));
 }
   
 std::vector<Ref<GenericGFPoly> > GenericGFPoly::divide(Ref<GenericGFPoly> other) {
-  if (!(field_.object_ == other->field_.object_)) {
+  if (!(&field_ == &other->field_)) {
     throw IllegalArgumentException("GenericGFPolys do not have same GenericGF field");
   }
   if (other->isZero()) {
     throw IllegalArgumentException("divide by 0");
   }
     
-  Ref<GenericGFPoly> quotient = field_->getZero();
+  Ref<GenericGFPoly> quotient = field_.getZero();
   Ref<GenericGFPoly> remainder = Ref<GenericGFPoly>(this);
     
   int denominatorLeadingTerm = other->getCoefficient(other->getDegree());
-  int inverseDenominatorLeadingTerm = field_->inverse(denominatorLeadingTerm);
+  int inverseDenominatorLeadingTerm = field_.inverse(denominatorLeadingTerm);
     
   while (remainder->getDegree() >= other->getDegree() && !remainder->isZero()) {
     int degreeDifference = remainder->getDegree() - other->getDegree();
-    int scale = field_->multiply(remainder->getCoefficient(remainder->getDegree()),
-                                 inverseDenominatorLeadingTerm);
+    int scale = field_.multiply(remainder->getCoefficient(remainder->getDegree()),
+                                inverseDenominatorLeadingTerm);
     Ref<GenericGFPoly> term = other->multiplyByMonomial(degreeDifference, scale);
-    Ref<GenericGFPoly> iterationQuotiont = field_->buildMonomial(degreeDifference,
-                                                                 scale);
+    Ref<GenericGFPoly> iterationQuotiont = field_.buildMonomial(degreeDifference,
+                                                                scale);
     quotient = quotient->addOrSubtract(iterationQuotiont);
     remainder = remainder->addOrSubtract(term);
   }
     
-  std::vector<Ref<GenericGFPoly> > returnValue;
+  std::vector<Ref<GenericGFPoly> > returnValue(2);
   returnValue[0] = quotient;
   returnValue[1] = remainder;
   return returnValue;

data/ext/zxing/zxing-cpp/core/src/zxing/common/reedsolomon/GenericGFPoly.h

@@ -32,11 +32,11 @@ class GenericGF;
   
 class GenericGFPoly : public Counted {
 private:
-  Ref<GenericGF> field_;
+  GenericGF &field_;
   ArrayRef<int> coefficients_;
     
 public:
-  GenericGFPoly(Ref<GenericGF> field, ArrayRef<int> coefficients);
+  GenericGFPoly(GenericGF &field, ArrayRef<int> coefficients);
   ArrayRef<int> getCoefficients();
   int getDegree();
   bool isZero();

data/ext/zxing/zxing-cpp/core/src/zxing/common/reedsolomon/ReedSolomonDecoder.cpp

@@ -40,7 +40,7 @@ ReedSolomonDecoder::~ReedSolomonDecoder() {
 }
 
 void ReedSolomonDecoder::decode(ArrayRef<int> received, int twoS) {
-  Ref<GenericGFPoly> poly(new GenericGFPoly(field, received));
+  Ref<GenericGFPoly> poly(new GenericGFPoly(*field, received));
   ArrayRef<int> syndromeCoefficients(twoS);
   bool noError = true;
   for (int i = 0; i < twoS; i++) {
@@ -53,7 +53,7 @@ void ReedSolomonDecoder::decode(ArrayRef<int> received, int twoS) {
   if (noError) {
     return;
   }
-  Ref<GenericGFPoly> syndrome(new GenericGFPoly(field, syndromeCoefficients));
+  Ref<GenericGFPoly> syndrome(new GenericGFPoly(*field, syndromeCoefficients));
   vector<Ref<GenericGFPoly> > sigmaOmega =
     runEuclideanAlgorithm(field->buildMonomial(twoS, 1), syndrome, twoS);
   Ref<GenericGFPoly> sigma = sigmaOmega[0];

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

@@ -399,16 +399,15 @@ void DecodedBitStreamParser::decodeBase256Segment(Ref<BitSource> bits, ostringst
     throw FormatException("NegativeArraySizeException");
   }
 
-  char* bytes = new char[count];
   for (int i = 0; i < count; i++) {
     // Have seen this particular error in the wild, such as at
     // http://www.bcgen.com/demo/IDAutomationStreamingDataMatrix.aspx?MODE=3&D=Fred&PFMT=3&PT=F&X=0.3&O=0&LM=0.2
     if (bits->available() < 8) {
       throw FormatException("byteSegments");
     }
-    bytes[i] = unrandomize255State(bits->readBits(8), codewordPosition++);
-    byteSegments.push_back(bytes[i]);
-    result << (char)bytes[i];
+    char byte = unrandomize255State(bits->readBits(8), codewordPosition++);
+    byteSegments.push_back(byte);
+    result << byte;
   }
 }
 }

data/ext/zxing/zxing-cpp/core/src/zxing/datamatrix/detector/Detector.cpp

@@ -27,6 +27,7 @@
 #include <zxing/NotFoundException.h>
 #include <sstream>
 #include <cstdlib>
+#include <algorithm>  // vs12, std::min und std:max
 
 using std::abs;
 using zxing::Ref;

data/ext/zxing/zxing-cpp/core/src/zxing/multi/GenericMultipleBarcodeReader.cpp

@@ -128,7 +128,7 @@ Ref<Result> GenericMultipleBarcodeReader::translateResultPoints(Ref<Result> resu
   if (oldResultPoints->empty()) {
     return result;
   }
-  ArrayRef< Ref<ResultPoint> > newResultPoints;
+  ArrayRef< Ref<ResultPoint> > newResultPoints(new zxing::Array< Ref<ResultPoint> >());
   for (int i = 0; i < oldResultPoints->size(); i++) {
     Ref<ResultPoint> oldPoint = oldResultPoints[i];
     newResultPoints->values().push_back(Ref<ResultPoint>(new ResultPoint(oldPoint->getX() + xOffset, oldPoint->getY() + yOffset)));

data/ext/zxing/zxing-cpp/core/src/zxing/oned/Code128Reader.cpp

@@ -26,6 +26,7 @@
 #include <math.h>
 #include <string.h>
 #include <sstream>
+#include <algorithm>  // vs12, std::min und std:max
 
 using std::vector;
 using std::string;

data/ext/zxing/zxing-cpp/core/src/zxing/oned/Code39Reader.cpp

@@ -23,6 +23,7 @@
 #include <zxing/ChecksumException.h>
 #include <math.h>
 #include <limits.h>
+#include <algorithm>  // vs12, std::min und std:max
 
 using std::vector;
 using zxing::Ref;
@@ -132,7 +133,7 @@ Ref<Result> Code39Reader::decodeRow(int rowNumber, Ref<BitArray> row) {
   int whiteSpaceAfterEnd = nextStart - lastStart - lastPatternSize;
   // If 50% of last pattern size, following last pattern, is not whitespace,
   // fail (but if it's whitespace to the very end of the image, that's OK)
-  if (nextStart != end && (whiteSpaceAfterEnd >> 1) < lastPatternSize) {
+  if (nextStart != end && (whiteSpaceAfterEnd << 1) < lastPatternSize) {
     throw NotFoundException();
   }
 

data/ext/zxing/zxing-cpp/core/src/zxing/oned/Code93Reader.cpp

@@ -239,16 +239,26 @@ Ref<String> Code93Reader::decodeExtended(string const& encoded)  {
           throw FormatException::getFormatInstance();
         }
         break;
-      case 'b':
-        // %A to %E map to control codes ESC to US
-        if (next >= 'A' && next <= 'E') {
-          decodedChar = (char) (next - 38);
-        } else if (next >= 'F' && next <= 'W') {
-          decodedChar = (char) (next - 11);
-        } else {
-          throw FormatException::getFormatInstance();
-        }
-        break;
+	  case 'b':
+		if (next >= 'A' && next <= 'E') {
+		  // %A to %E map to control codes ESC to USep
+		  decodedChar = (char) (next - 38);
+		} else if (next >= 'F' && next <= 'J') {
+		  // %F to %J map to ; < = > ?
+		  decodedChar = (char) (next - 11);
+		} else if (next >= 'K' && next <= 'O') {
+		  // %K to %O map to [ \ ] ^ _
+		  decodedChar = (char) (next + 16);
+		} else if (next >= 'P' && next <= 'S') {
+		  // %P to %S map to { | } ~
+		  decodedChar = (char) (next + 43);
+		} else if (next >= 'T' && next <= 'Z') {
+		  // %T to %Z all map to DEL (127)
+		  decodedChar = 127;
+		} else {
+		  throw FormatException::getFormatInstance();
+		}
+		break;
       case 'c':
         // /A to /O map to ! to , and /Z maps to :
         if (next >= 'A' && next <= 'O') {

data/ext/zxing/zxing-cpp/core/src/zxing/oned/OneDReader.cpp

@@ -22,6 +22,7 @@
 #include <zxing/NotFoundException.h>
 #include <math.h>
 #include <limits.h>
+#include <algorithm>  // vs12, std::min und std:max
 
 using std::vector;
 using zxing::Ref;

data/ext/zxing/zxing-cpp/core/src/zxing/oned/UPCAReader.cpp

@@ -19,7 +19,7 @@
  */
 
 #include "UPCAReader.h"
-#include <zxing/ReaderException.h>
+#include <zxing/FormatException.h>
 
 using zxing::oned::UPCAReader;
 using zxing::Ref;
@@ -29,6 +29,7 @@ using zxing::Result;
 using zxing::BitArray;
 using zxing::BinaryBitmap;
 using zxing::DecodeHints;
+using zxing::FormatException;
 
 UPCAReader::UPCAReader() : ean13Reader() {}
 
@@ -53,17 +54,15 @@ int UPCAReader::decodeMiddle(Ref<BitArray> row,
 }
 
 Ref<Result> UPCAReader::maybeReturnResult(Ref<Result> result) {
-  if (result.empty()) {
-    return result;
-  }
   const std::string& text = (result->getText())->getText();
   if (text[0] == '0') {
     Ref<String> resultString(new String(text.substr(1)));
     Ref<Result> res(new Result(resultString, result->getRawBytes(), result->getResultPoints(),
                                BarcodeFormat::UPC_A));
     return res;
+  } else {
+    throw FormatException();
   }
-  return Ref<Result>();
 }
 
 zxing::BarcodeFormat UPCAReader::getBarcodeFormat(){

data/ext/zxing/zxing-cpp/core/src/zxing/pdf417/detector/Detector.cpp

@@ -21,6 +21,7 @@
 #include <zxing/common/GridSampler.h>
 #include <zxing/common/detector/JavaMath.h>
 #include <zxing/common/detector/MathUtils.h>
+#include <algorithm>  // vs12, std::min und std:max
 
 using std::max;
 using std::abs;

data/ext/zxing/zxing-cpp/core/src/zxing/pdf417/detector/LinesSampler.cpp

@@ -20,11 +20,12 @@
 #include <zxing/pdf417/decoder/BitMatrixParser.h>
 #include <zxing/NotFoundException.h>
 #include <zxing/common/Point.h>
+#include <algorithm>  // vs12, std::min und std:max
+#include <cmath>
 
 using std::map;
 using std::vector;
 using std::min;
-using std::abs;
 using zxing::pdf417::detector::LinesSampler;
 using zxing::pdf417::decoder::BitMatrixParser;
 using zxing::Ref;
@@ -61,7 +62,7 @@ class VoteResult {
     this->vote = vote;
   }
 };
-  
+
 VoteResult getValueWithMaxVotes(map<int, int>& votes) {
   VoteResult result;
   int maxVotes = 0;
@@ -703,7 +704,7 @@ Point LinesSampler::intersection(Line a, Line b) {
   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(abs(denom) < 1e-12)  // Lines don't intersect (replaces "denom == 0")
+  if(std::abs(denom) < 1e-12)  // Lines don't intersect (replaces "denom == 0")
     return Point(std::numeric_limits<float>::infinity(),
                  std::numeric_limits<float>::infinity());
 

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

@@ -221,6 +221,7 @@ void DecodedBitStreamParser::decodeNumericSegment(Ref<BitSource> bits, std::stri
   while (count >= 3) {
     // Each 10 bits encodes three digits
     if (bits->available() < 10) {
+      delete[] bytes;
       throw ReaderException("format exception");
     }
     int threeDigitsBits = bits->readBits(10);
@@ -237,6 +238,7 @@ void DecodedBitStreamParser::decodeNumericSegment(Ref<BitSource> bits, std::stri
   }
   if (count == 2) {
     if (bits->available() < 7) {
+      delete[] bytes;
       throw ReaderException("format exception");
     }
     // Two digits left over to read, encoded in 7 bits
@@ -251,6 +253,7 @@ void DecodedBitStreamParser::decodeNumericSegment(Ref<BitSource> bits, std::stri
     bytes[i++] = ALPHANUMERIC_CHARS[twoDigitsBits % 10];
   } else if (count == 1) {
     if (bits->available() < 4) {
+      delete[] bytes;
       throw ReaderException("format exception");
     }
     // One digit left over to read

data/ext/zxing/zxing-cpp/core/src/zxing/qrcode/detector/Detector.cpp

@@ -30,6 +30,7 @@
 #include <zxing/common/detector/MathUtils.h>
 #include <sstream>
 #include <cstdlib>
+#include <algorithm>  // vs12, std::min und std:max
 
 using std::ostringstream;
 using std::abs;

data/lib/zxing/rmagick/image.rb

@@ -1,9 +1,14 @@
-require 'RMagick'
+begin
+  # Support both newer 'rmagick' require and deprecated 'RMagick' require:
+  require 'rmagick'
+rescue LoadError => e
+  require 'RMagick'
+end
 
 module ZXing; end
 module ZXing::RMagick; end
 
-class ZXing::RMagick::Image 
+class ZXing::RMagick::Image
   include ZXing::Image
   LuminanceSource = ZXing::FFI::Common::GreyscaleLuminanceSource
 

data/lib/zxing/version.rb

@@ -1,5 +1,5 @@
 module ZXing
-  VERSION = "0.1.0" unless defined?(::ZXing::VERSION)
+  VERSION = "0.1.1" unless defined?(::ZXing::VERSION)
 
   VERSION_INFO = {}
   VERSION_INFO['warnings']              = []

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zxing_cpp
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Benjamin Dobell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-19 00:00:00.000000000 Z
+date: 2016-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -461,7 +461,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: A barcode and QR code library.