status-im/qzxing
2
0
Fork 0
mirror of https://github.com/status-im/qzxing.git synced 2025-02-16 12:58:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Change all Version* usages to Ref<Version> to avoid valrgind of reporting memory leak on static Version objects. #155

Browse Source
This commit is contained in:
Nikos Ftylitakis 2020-02-12 11:37:14 +02:00
parent f0a78867d6
commit 9d70b9a33b
25 changed files with 201 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
examples/QZXingLive/main.qml
View File

@ -119,7 +119,8 @@ ApplicationWindow
{
timePerFrameDecode = (decodeTime + framesDecoded * timePerFrameDecode) / (framesDecoded + 1);
framesDecoded++;
console.log("frame finished: " + succeeded, decodeTime, timePerFrameDecode, framesDecoded);
if(succeeded)
console.log("frame finished: " + succeeded, decodeTime, timePerFrameDecode, framesDecoded);
}
}

126
src/zxing/zxing/datamatrix/DataMatrixVersion.cpp
View File

@ -61,7 +61,7 @@ ECBlocks::~ECBlocks() {
}
}
vector<Version*> Version::VERSIONS;
vector<Ref<Version>> Version::VERSIONS;
static int N_VERSIONS = Version::buildVersions();
Version::Version(int versionNumber, int symbolSizeRows, int symbolSizeColumns, int dataRegionSizeRows,
@ -112,7 +112,7 @@ ECBlocks* Version::getECBlocks() const {
return ecBlocks_;
}
Version* Version::getVersionForDimensions(int numRows, int numColumns) {
Ref<Version> Version::getVersionForDimensions(int numRows, int numColumns) {
if ((numRows & 0x01) != 0 || (numColumns & 0x01) != 0) {
throw ReaderException("Number of rows and columns must be even");
}
@ -121,7 +121,7 @@ Version* Version::getVersionForDimensions(int numRows, int numColumns) {
// If we interleave the rectangular versions with the square versions we could
// do a binary search.
for (int i = 0; i < N_VERSIONS; ++i){
Version* version = VERSIONS[i];
Ref<Version> version = VERSIONS[i];
if (version->getSymbolSizeRows() == numRows && version->getSymbolSizeColumns() == numColumns) {
return version;
}
@ -133,66 +133,66 @@ Version* Version::getVersionForDimensions(int numRows, int numColumns) {
* See ISO 16022:2006 5.5.1 Table 7
*/
int Version::buildVersions() {
VERSIONS.push_back(new Version(1, 10, 10, 8, 8,
new ECBlocks(5, new ECB(1, 3))));
VERSIONS.push_back(new Version(2, 12, 12, 10, 10,
new ECBlocks(7, new ECB(1, 5))));
VERSIONS.push_back(new Version(3, 14, 14, 12, 12,
new ECBlocks(10, new ECB(1, 8))));
VERSIONS.push_back(new Version(4, 16, 16, 14, 14,
new ECBlocks(12, new ECB(1, 12))));
VERSIONS.push_back(new Version(5, 18, 18, 16, 16,
new ECBlocks(14, new ECB(1, 18))));
VERSIONS.push_back(new Version(6, 20, 20, 18, 18,
new ECBlocks(18, new ECB(1, 22))));
VERSIONS.push_back(new Version(7, 22, 22, 20, 20,
new ECBlocks(20, new ECB(1, 30))));
VERSIONS.push_back(new Version(8, 24, 24, 22, 22,
new ECBlocks(24, new ECB(1, 36))));
VERSIONS.push_back(new Version(9, 26, 26, 24, 24,
new ECBlocks(28, new ECB(1, 44))));
VERSIONS.push_back(new Version(10, 32, 32, 14, 14,
new ECBlocks(36, new ECB(1, 62))));
VERSIONS.push_back(new Version(11, 36, 36, 16, 16,
new ECBlocks(42, new ECB(1, 86))));
VERSIONS.push_back(new Version(12, 40, 40, 18, 18,
new ECBlocks(48, new ECB(1, 114))));
VERSIONS.push_back(new Version(13, 44, 44, 20, 20,
new ECBlocks(56, new ECB(1, 144))));
VERSIONS.push_back(new Version(14, 48, 48, 22, 22,
new ECBlocks(68, new ECB(1, 174))));
VERSIONS.push_back(new Version(15, 52, 52, 24, 24,
new ECBlocks(42, new ECB(2, 102))));
VERSIONS.push_back(new Version(16, 64, 64, 14, 14,
new ECBlocks(56, new ECB(2, 140))));
VERSIONS.push_back(new Version(17, 72, 72, 16, 16,
new ECBlocks(36, new ECB(4, 92))));
VERSIONS.push_back(new Version(18, 80, 80, 18, 18,
new ECBlocks(48, new ECB(4, 114))));
VERSIONS.push_back(new Version(19, 88, 88, 20, 20,
new ECBlocks(56, new ECB(4, 144))));
VERSIONS.push_back(new Version(20, 96, 96, 22, 22,
new ECBlocks(68, new ECB(4, 174))));
VERSIONS.push_back(new Version(21, 104, 104, 24, 24,
new ECBlocks(56, new ECB(6, 136))));
VERSIONS.push_back(new Version(22, 120, 120, 18, 18,
new ECBlocks(68, new ECB(6, 175))));
VERSIONS.push_back(new Version(23, 132, 132, 20, 20,
new ECBlocks(62, new ECB(8, 163))));
VERSIONS.push_back(new Version(24, 144, 144, 22, 22,
new ECBlocks(62, new ECB(8, 156), new ECB(2, 155))));
VERSIONS.push_back(new Version(25, 8, 18, 6, 16,
new ECBlocks(7, new ECB(1, 5))));
VERSIONS.push_back(new Version(26, 8, 32, 6, 14,
new ECBlocks(11, new ECB(1, 10))));
VERSIONS.push_back(new Version(27, 12, 26, 10, 24,
new ECBlocks(14, new ECB(1, 16))));
VERSIONS.push_back(new Version(28, 12, 36, 10, 16,
new ECBlocks(18, new ECB(1, 22))));
VERSIONS.push_back(new Version(29, 16, 36, 14, 16,
new ECBlocks(24, new ECB(1, 32))));
VERSIONS.push_back(new Version(30, 16, 48, 14, 22,
new ECBlocks(28, new ECB(1, 49))));
VERSIONS.push_back(Ref<Version>(new Version(1, 10, 10, 8, 8,
new ECBlocks(5, new ECB(1, 3)))));
VERSIONS.push_back(Ref<Version>(new Version(2, 12, 12, 10, 10,
new ECBlocks(7, new ECB(1, 5)))));
VERSIONS.push_back(Ref<Version>(new Version(3, 14, 14, 12, 12,
new ECBlocks(10, new ECB(1, 8)))));
VERSIONS.push_back(Ref<Version>(new Version(4, 16, 16, 14, 14,
new ECBlocks(12, new ECB(1, 12)))));
VERSIONS.push_back(Ref<Version>(new Version(5, 18, 18, 16, 16,
new ECBlocks(14, new ECB(1, 18)))));
VERSIONS.push_back(Ref<Version>(new Version(6, 20, 20, 18, 18,
new ECBlocks(18, new ECB(1, 22)))));
VERSIONS.push_back(Ref<Version>(new Version(7, 22, 22, 20, 20,
new ECBlocks(20, new ECB(1, 30)))));
VERSIONS.push_back(Ref<Version>(new Version(8, 24, 24, 22, 22,
new ECBlocks(24, new ECB(1, 36)))));
VERSIONS.push_back(Ref<Version>(new Version(9, 26, 26, 24, 24,
new ECBlocks(28, new ECB(1, 44)))));
VERSIONS.push_back(Ref<Version>(new Version(10, 32, 32, 14, 14,
new ECBlocks(36, new ECB(1, 62)))));
VERSIONS.push_back(Ref<Version>(new Version(11, 36, 36, 16, 16,
new ECBlocks(42, new ECB(1, 86)))));
VERSIONS.push_back(Ref<Version>(new Version(12, 40, 40, 18, 18,
new ECBlocks(48, new ECB(1, 114)))));
VERSIONS.push_back(Ref<Version>(new Version(13, 44, 44, 20, 20,
new ECBlocks(56, new ECB(1, 144)))));
VERSIONS.push_back(Ref<Version>(new Version(14, 48, 48, 22, 22,
new ECBlocks(68, new ECB(1, 174)))));
VERSIONS.push_back(Ref<Version>(new Version(15, 52, 52, 24, 24,
new ECBlocks(42, new ECB(2, 102)))));
VERSIONS.push_back(Ref<Version>(new Version(16, 64, 64, 14, 14,
new ECBlocks(56, new ECB(2, 140)))));
VERSIONS.push_back(Ref<Version>(new Version(17, 72, 72, 16, 16,
new ECBlocks(36, new ECB(4, 92)))));
VERSIONS.push_back(Ref<Version>(new Version(18, 80, 80, 18, 18,
new ECBlocks(48, new ECB(4, 114)))));
VERSIONS.push_back(Ref<Version>(new Version(19, 88, 88, 20, 20,
new ECBlocks(56, new ECB(4, 144)))));
VERSIONS.push_back(Ref<Version>(new Version(20, 96, 96, 22, 22,
new ECBlocks(68, new ECB(4, 174)))));
VERSIONS.push_back(Ref<Version>(new Version(21, 104, 104, 24, 24,
new ECBlocks(56, new ECB(6, 136)))));
VERSIONS.push_back(Ref<Version>(new Version(22, 120, 120, 18, 18,
new ECBlocks(68, new ECB(6, 175)))));
VERSIONS.push_back(Ref<Version>(new Version(23, 132, 132, 20, 20,
new ECBlocks(62, new ECB(8, 163)))));
VERSIONS.push_back(Ref<Version>(new Version(24, 144, 144, 22, 22,
new ECBlocks(62, new ECB(8, 156), new ECB(2, 155)))));
VERSIONS.push_back(Ref<Version>(new Version(25, 8, 18, 6, 16,
new ECBlocks(7, new ECB(1, 5)))));
VERSIONS.push_back(Ref<Version>(new Version(26, 8, 32, 6, 14,
new ECBlocks(11, new ECB(1, 10)))));
VERSIONS.push_back(Ref<Version>(new Version(27, 12, 26, 10, 24,
new ECBlocks(14, new ECB(1, 16)))));
VERSIONS.push_back(Ref<Version>(new Version(28, 12, 36, 10, 16,
new ECBlocks(18, new ECB(1, 22)))));
VERSIONS.push_back(Ref<Version>(new Version(29, 16, 36, 14, 16,
new ECBlocks(24, new ECB(1, 32)))));
VERSIONS.push_back(Ref<Version>(new Version(30, 16, 48, 14, 22,
new ECBlocks(28, new ECB(1, 49)))));
return int(VERSIONS.size());
}
}

4
src/zxing/zxing/datamatrix/Version.h
View File

@ -64,7 +64,7 @@ private:
int dataRegionSizeColumns, ECBlocks *ecBlocks);
public:
static std::vector<Version*> VERSIONS;
static std::vector<Ref<Version>> VERSIONS;
~Version();
int getVersionNumber() const;
@ -75,7 +75,7 @@ public:
int getTotalCodewords() const;
ECBlocks* getECBlocks() const;
static int buildVersions();
Version *getVersionForDimensions(int numRows, int numColumns);
Ref<Version>getVersionForDimensions(int numRows, int numColumns);
private:
Version(const Version&);

4
src/zxing/zxing/datamatrix/decoder/BitMatrixParser.h
View File

@ -33,14 +33,14 @@ namespace datamatrix {
class BitMatrixParser : public Counted {
private:
Ref<BitMatrix> bitMatrix_;
Version* parsedVersion_;
Ref<Version> parsedVersion_;
Ref<BitMatrix> readBitMatrix_;
int copyBit(size_t x, size_t y, int versionBits);
public:
BitMatrixParser(Ref<BitMatrix> bitMatrix);
Version* readVersion(Ref<BitMatrix> bitMatrix);
Ref<Version> readVersion(Ref<BitMatrix> bitMatrix);
ArrayRef<zxing::byte> readCodewords();
bool readModule(int row, int column, int numRows, int numColumns);

2
src/zxing/zxing/datamatrix/decoder/DataBlock.h
View File

@ -37,7 +37,7 @@ private:
DataBlock(int numDataCodewords, ArrayRef<zxing::byte> codewords);
public:
static std::vector<Ref<DataBlock> > getDataBlocks(ArrayRef<zxing::byte> rawCodewords, Version *version);
static std::vector<Ref<DataBlock> > getDataBlocks(ArrayRef<zxing::byte> rawCodewords, Ref<Version>version);
int getNumDataCodewords();
ArrayRef<zxing::byte> getCodewords();

4
src/zxing/zxing/datamatrix/decoder/DataMatrixBitMatrixParser.cpp
View File

@ -42,7 +42,7 @@ BitMatrixParser::BitMatrixParser(Ref<BitMatrix> bitMatrix) : bitMatrix_(NULL),
readBitMatrix_ = new BitMatrix(bitMatrix_->getWidth(), bitMatrix_->getHeight());
}
Version* BitMatrixParser::readVersion(Ref<BitMatrix> bitMatrix) {
Ref<Version> BitMatrixParser::readVersion(Ref<BitMatrix> bitMatrix) {
if (parsedVersion_ != 0) {
return parsedVersion_;
}
@ -50,7 +50,7 @@ Version* BitMatrixParser::readVersion(Ref<BitMatrix> bitMatrix) {
int numRows = bitMatrix->getHeight();
int numColumns = bitMatrix->getWidth();
Version* version = parsedVersion_->getVersionForDimensions(numRows, numColumns);
Ref<Version> version = parsedVersion_->getVersionForDimensions(numRows, numColumns);
if (version != 0) {
return version;
}

2
src/zxing/zxing/datamatrix/decoder/DataMatrixDataBlock.cpp
View File

@ -38,7 +38,7 @@ ArrayRef<zxing::byte> DataBlock::getCodewords() {
return codewords_;
}
std::vector<Ref<DataBlock> > DataBlock::getDataBlocks(ArrayRef<zxing::byte> rawCodewords, Version *version) {
std::vector<Ref<DataBlock> > DataBlock::getDataBlocks(ArrayRef<zxing::byte> rawCodewords, Ref<Version>version) {
// Figure out the number and size of data blocks used by this version and
// error correction level
ECBlocks* ecBlocks = version->getECBlocks();

2
src/zxing/zxing/datamatrix/decoder/DataMatrixDecoder.cpp
View File

@ -65,7 +65,7 @@ void Decoder::correctErrors(ArrayRef<zxing::byte> codewordBytes, int numDataCode
Ref<DecoderResult> Decoder::decode(Ref<BitMatrix> bits) {
// Construct a parser and read version, error-correction level
BitMatrixParser parser(bits);
Version *version = parser.readVersion(bits);
Ref<Version>version = parser.readVersion(bits);
// Read codewords
ArrayRef<zxing::byte> codewords(parser.readCodewords());

170
src/zxing/zxing/qrcode/QRVersion.cpp
View File

@ -88,7 +88,7 @@ unsigned int Version::VERSION_DECODE_INFO[] = { 0x07C94, 0x085BC, 0x09A99, 0x0A4
0x27541, 0x28C69
};
int Version::N_VERSION_DECODE_INFOS = 34;
vector<Version*> Version::VERSIONS;
vector<Ref<Version>> Version::VERSIONS;
static int N_VERSIONS = Version::buildVersions();
int Version::getVersionNumber() const {
@ -111,7 +111,7 @@ ECBlocks& Version::getECBlocksForLevel(const ErrorCorrectionLevel &ecLevel) cons
return *ecBlocks_[ecLevel.ordinal()];
}
Version* Version::getProvisionalVersionForDimension(int dimension) {
Ref<Version> Version::getProvisionalVersionForDimension(int dimension) {
if (dimension % 4 != 1) {
throw FormatException();
}
@ -123,7 +123,7 @@ Version* Version::getProvisionalVersionForDimension(int dimension) {
}
}
Version* Version::getVersionForNumber(int versionNumber) {
Ref<Version> Version::getVersionForNumber(int versionNumber) {
if (versionNumber < 1 || versionNumber > N_VERSIONS) {
throw ReaderException("versionNumber must be between 1 and 40");
}
@ -156,7 +156,7 @@ Version::~Version() {
}
}
Version* Version::decodeVersionInformation(unsigned int versionBits) {
Ref<Version> Version::decodeVersionInformation(unsigned int versionBits) {
int bestDifference = numeric_limits<int>::max();
size_t bestVersion = 0;
for (int i = 0; i < N_VERSION_DECODE_INFOS; i++) {
@ -179,7 +179,7 @@ Version* Version::decodeVersionInformation(unsigned int versionBits) {
return getVersionForNumber(int(bestVersion));
}
// If we didn't find a close enough match, fail
return NULL;
return Ref<Version>();
}
Ref<BitMatrix> Version::buildFunctionPattern() {
@ -235,62 +235,62 @@ static vector<int> *intArray(size_t n...) {
}
int Version::buildVersions() {
VERSIONS.push_back(new Version(1, intArray(0),
VERSIONS.push_back(Ref<Version>( new Version(1, intArray(0),
new ECBlocks(7, new ECB(1, 19)),
new ECBlocks(10, new ECB(1, 16)),
new ECBlocks(13, new ECB(1, 13)),
new ECBlocks(17, new ECB(1, 9))));
VERSIONS.push_back(new Version(2, intArray(2, 6, 18),
new ECBlocks(17, new ECB(1, 9)))));
VERSIONS.push_back(Ref<Version>( new Version(2, intArray(2, 6, 18),
new ECBlocks(10, new ECB(1, 34)),
new ECBlocks(16, new ECB(1, 28)),
new ECBlocks(22, new ECB(1, 22)),
new ECBlocks(28, new ECB(1, 16))));
VERSIONS.push_back(new Version(3, intArray(2, 6, 22),
new ECBlocks(28, new ECB(1, 16)))));
VERSIONS.push_back(Ref<Version>( new Version(3, intArray(2, 6, 22),
new ECBlocks(15, new ECB(1, 55)),
new ECBlocks(26, new ECB(1, 44)),
new ECBlocks(18, new ECB(2, 17)),
new ECBlocks(22, new ECB(2, 13))));
VERSIONS.push_back(new Version(4, intArray(2, 6, 26),
new ECBlocks(22, new ECB(2, 13)))));
VERSIONS.push_back(Ref<Version>( new Version(4, intArray(2, 6, 26),
new ECBlocks(20, new ECB(1, 80)),
new ECBlocks(18, new ECB(2, 32)),
new ECBlocks(26, new ECB(2, 24)),
new ECBlocks(16, new ECB(4, 9))));
VERSIONS.push_back(new Version(5, intArray(2, 6, 30),
new ECBlocks(16, new ECB(4, 9)))));
VERSIONS.push_back(Ref<Version>( new Version(5, intArray(2, 6, 30),
new ECBlocks(26, new ECB(1, 108)),
new ECBlocks(24, new ECB(2, 43)),
new ECBlocks(18, new ECB(2, 15),
new ECB(2, 16)),
new ECBlocks(22, new ECB(2, 11),
new ECB(2, 12))));
VERSIONS.push_back(new Version(6, intArray(2, 6, 34),
new ECB(2, 12)))));
VERSIONS.push_back(Ref<Version>( new Version(6, intArray(2, 6, 34),
new ECBlocks(18, new ECB(2, 68)),
new ECBlocks(16, new ECB(4, 27)),
new ECBlocks(24, new ECB(4, 19)),
new ECBlocks(28, new ECB(4, 15))));
VERSIONS.push_back(new Version(7, intArray(3, 6, 22, 38),
new ECBlocks(28, new ECB(4, 15)))));
VERSIONS.push_back(Ref<Version>( new Version(7, intArray(3, 6, 22, 38),
new ECBlocks(20, new ECB(2, 78)),
new ECBlocks(18, new ECB(4, 31)),
new ECBlocks(18, new ECB(2, 14),
new ECB(4, 15)),
new ECBlocks(26, new ECB(4, 13),
new ECB(1, 14))));
VERSIONS.push_back(new Version(8, intArray(3, 6, 24, 42),
new ECB(1, 14)))));
VERSIONS.push_back(Ref<Version>( new Version(8, intArray(3, 6, 24, 42),
new ECBlocks(24, new ECB(2, 97)),
new ECBlocks(22, new ECB(2, 38),
new ECB(2, 39)),
new ECBlocks(22, new ECB(4, 18),
new ECB(2, 19)),
new ECBlocks(26, new ECB(4, 14),
new ECB(2, 15))));
VERSIONS.push_back(new Version(9, intArray(3, 6, 26, 46),
new ECB(2, 15)))));
VERSIONS.push_back(Ref<Version>( new Version(9, intArray(3, 6, 26, 46),
new ECBlocks(30, new ECB(2, 116)),
new ECBlocks(22, new ECB(3, 36),
new ECB(2, 37)),
new ECBlocks(20, new ECB(4, 16),
new ECB(4, 17)),
new ECBlocks(24, new ECB(4, 12),
new ECB(4, 13))));
VERSIONS.push_back(new Version(10, intArray(3, 6, 28, 50),
new ECB(4, 13)))));
VERSIONS.push_back(Ref<Version>( new Version(10, intArray(3, 6, 28, 50),
new ECBlocks(18, new ECB(2, 68),
new ECB(2, 69)),
new ECBlocks(26, new ECB(4, 43),
@ -298,16 +298,16 @@ int Version::buildVersions() {
new ECBlocks(24, new ECB(6, 19),
new ECB(2, 20)),
new ECBlocks(28, new ECB(6, 15),
new ECB(2, 16))));
VERSIONS.push_back(new Version(11, intArray(3, 6, 30, 54),
new ECB(2, 16)))));
VERSIONS.push_back(Ref<Version>( new Version(11, intArray(3, 6, 30, 54),
new ECBlocks(20, new ECB(4, 81)),
new ECBlocks(30, new ECB(1, 50),
new ECB(4, 51)),
new ECBlocks(28, new ECB(4, 22),
new ECB(4, 23)),
new ECBlocks(24, new ECB(3, 12),
new ECB(8, 13))));
VERSIONS.push_back(new Version(12, intArray(3, 6, 32, 58),
new ECB(8, 13)))));
VERSIONS.push_back(Ref<Version>( new Version(12, intArray(3, 6, 32, 58),
new ECBlocks(24, new ECB(2, 92),
new ECB(2, 93)),
new ECBlocks(22, new ECB(6, 36),
@ -315,16 +315,16 @@ int Version::buildVersions() {
new ECBlocks(26, new ECB(4, 20),
new ECB(6, 21)),
new ECBlocks(28, new ECB(7, 14),
new ECB(4, 15))));
VERSIONS.push_back(new Version(13, intArray(3, 6, 34, 62),
new ECB(4, 15)))));
VERSIONS.push_back(Ref<Version>( new Version(13, intArray(3, 6, 34, 62),
new ECBlocks(26, new ECB(4, 107)),
new ECBlocks(22, new ECB(8, 37),
new ECB(1, 38)),
new ECBlocks(24, new ECB(8, 20),
new ECB(4, 21)),
new ECBlocks(22, new ECB(12, 11),
new ECB(4, 12))));
VERSIONS.push_back(new Version(14, intArray(4, 6, 26, 46, 66),
new ECB(4, 12)))));
VERSIONS.push_back(Ref<Version>( new Version(14, intArray(4, 6, 26, 46, 66),
new ECBlocks(30, new ECB(3, 115),
new ECB(1, 116)),
new ECBlocks(24, new ECB(4, 40),
@ -332,8 +332,8 @@ int Version::buildVersions() {
new ECBlocks(20, new ECB(11, 16),
new ECB(5, 17)),
new ECBlocks(24, new ECB(11, 12),
new ECB(5, 13))));
VERSIONS.push_back(new Version(15, intArray(4, 6, 26, 48, 70),
new ECB(5, 13)))));
VERSIONS.push_back(Ref<Version>( new Version(15, intArray(4, 6, 26, 48, 70),
new ECBlocks(22, new ECB(5, 87),
new ECB(1, 88)),
new ECBlocks(24, new ECB(5, 41),
@ -341,8 +341,8 @@ int Version::buildVersions() {
new ECBlocks(30, new ECB(5, 24),
new ECB(7, 25)),
new ECBlocks(24, new ECB(11, 12),
new ECB(7, 13))));
VERSIONS.push_back(new Version(16, intArray(4, 6, 26, 50, 74),
new ECB(7, 13)))));
VERSIONS.push_back(Ref<Version>( new Version(16, intArray(4, 6, 26, 50, 74),
new ECBlocks(24, new ECB(5, 98),
new ECB(1, 99)),
new ECBlocks(28, new ECB(7, 45),
@ -350,8 +350,8 @@ int Version::buildVersions() {
new ECBlocks(24, new ECB(15, 19),
new ECB(2, 20)),
new ECBlocks(30, new ECB(3, 15),
new ECB(13, 16))));
VERSIONS.push_back(new Version(17, intArray(4, 6, 30, 54, 78),
new ECB(13, 16)))));
VERSIONS.push_back(Ref<Version>( new Version(17, intArray(4, 6, 30, 54, 78),
new ECBlocks(28, new ECB(1, 107),
new ECB(5, 108)),
new ECBlocks(28, new ECB(10, 46),
@ -359,8 +359,8 @@ int Version::buildVersions() {
new ECBlocks(28, new ECB(1, 22),
new ECB(15, 23)),
new ECBlocks(28, new ECB(2, 14),
new ECB(17, 15))));
VERSIONS.push_back(new Version(18, intArray(4, 6, 30, 56, 82),
new ECB(17, 15)))));
VERSIONS.push_back(Ref<Version>( new Version(18, intArray(4, 6, 30, 56, 82),
new ECBlocks(30, new ECB(5, 120),
new ECB(1, 121)),
new ECBlocks(26, new ECB(9, 43),
@ -368,8 +368,8 @@ int Version::buildVersions() {
new ECBlocks(28, new ECB(17, 22),
new ECB(1, 23)),
new ECBlocks(28, new ECB(2, 14),
new ECB(19, 15))));
VERSIONS.push_back(new Version(19, intArray(4, 6, 30, 58, 86),
new ECB(19, 15)))));
VERSIONS.push_back(Ref<Version>( new Version(19, intArray(4, 6, 30, 58, 86),
new ECBlocks(28, new ECB(3, 113),
new ECB(4, 114)),
new ECBlocks(26, new ECB(3, 44),
@ -377,8 +377,8 @@ int Version::buildVersions() {
new ECBlocks(26, new ECB(17, 21),
new ECB(4, 22)),
new ECBlocks(26, new ECB(9, 13),
new ECB(16, 14))));
VERSIONS.push_back(new Version(20, intArray(4, 6, 34, 62, 90),
new ECB(16, 14)))));
VERSIONS.push_back(Ref<Version>( new Version(20, intArray(4, 6, 34, 62, 90),
new ECBlocks(28, new ECB(3, 107),
new ECB(5, 108)),
new ECBlocks(26, new ECB(3, 41),
@ -386,23 +386,23 @@ int Version::buildVersions() {
new ECBlocks(30, new ECB(15, 24),
new ECB(5, 25)),
new ECBlocks(28, new ECB(15, 15),
new ECB(10, 16))));
VERSIONS.push_back(new Version(21, intArray(5, 6, 28, 50, 72, 94),
new ECB(10, 16)))));
VERSIONS.push_back(Ref<Version>( new Version(21, intArray(5, 6, 28, 50, 72, 94),
new ECBlocks(28, new ECB(4, 116),
new ECB(4, 117)),
new ECBlocks(26, new ECB(17, 42)),
new ECBlocks(28, new ECB(17, 22),
new ECB(6, 23)),
new ECBlocks(30, new ECB(19, 16),
new ECB(6, 17))));
VERSIONS.push_back(new Version(22, intArray(5, 6, 26, 50, 74, 98),
new ECB(6, 17)))));
VERSIONS.push_back(Ref<Version>( new Version(22, intArray(5, 6, 26, 50, 74, 98),
new ECBlocks(28, new ECB(2, 111),
new ECB(7, 112)),
new ECBlocks(28, new ECB(17, 46)),
new ECBlocks(30, new ECB(7, 24),
new ECB(16, 25)),
new ECBlocks(24, new ECB(34, 13))));
VERSIONS.push_back(new Version(23, intArray(5, 6, 30, 54, 78, 102),
new ECBlocks(24, new ECB(34, 13)))));
VERSIONS.push_back(Ref<Version>( new Version(23, intArray(5, 6, 30, 54, 78, 102),
new ECBlocks(30, new ECB(4, 121),
new ECB(5, 122)),
new ECBlocks(28, new ECB(4, 47),
@ -410,8 +410,8 @@ int Version::buildVersions() {
new ECBlocks(30, new ECB(11, 24),
new ECB(14, 25)),
new ECBlocks(30, new ECB(16, 15),
new ECB(14, 16))));
VERSIONS.push_back(new Version(24, intArray(5, 6, 28, 54, 80, 106),
new ECB(14, 16)))));
VERSIONS.push_back(Ref<Version>( new Version(24, intArray(5, 6, 28, 54, 80, 106),
new ECBlocks(30, new ECB(6, 117),
new ECB(4, 118)),
new ECBlocks(28, new ECB(6, 45),
@ -419,8 +419,8 @@ int Version::buildVersions() {
new ECBlocks(30, new ECB(11, 24),
new ECB(16, 25)),
new ECBlocks(30, new ECB(30, 16),
new ECB(2, 17))));
VERSIONS.push_back(new Version(25, intArray(5, 6, 32, 58, 84, 110),
new ECB(2, 17)))));
VERSIONS.push_back(Ref<Version>( new Version(25, intArray(5, 6, 32, 58, 84, 110),
new ECBlocks(26, new ECB(8, 106),
new ECB(4, 107)),
new ECBlocks(28, new ECB(8, 47),
@ -428,8 +428,8 @@ int Version::buildVersions() {
new ECBlocks(30, new ECB(7, 24),
new ECB(22, 25)),
new ECBlocks(30, new ECB(22, 15),
new ECB(13, 16))));
VERSIONS.push_back(new Version(26, intArray(5, 6, 30, 58, 86, 114),
new ECB(13, 16)))));
VERSIONS.push_back(Ref<Version>( new Version(26, intArray(5, 6, 30, 58, 86, 114),
new ECBlocks(28, new ECB(10, 114),
new ECB(2, 115)),
new ECBlocks(28, new ECB(19, 46),
@ -437,8 +437,8 @@ int Version::buildVersions() {
new ECBlocks(28, new ECB(28, 22),
new ECB(6, 23)),
new ECBlocks(30, new ECB(33, 16),
new ECB(4, 17))));
VERSIONS.push_back(new Version(27, intArray(5, 6, 34, 62, 90, 118),
new ECB(4, 17)))));
VERSIONS.push_back(Ref<Version>( new Version(27, intArray(5, 6, 34, 62, 90, 118),
new ECBlocks(30, new ECB(8, 122),
new ECB(4, 123)),
new ECBlocks(28, new ECB(22, 45),
@ -446,8 +446,8 @@ int Version::buildVersions() {
new ECBlocks(30, new ECB(8, 23),
new ECB(26, 24)),
new ECBlocks(30, new ECB(12, 15),
new ECB(28, 16))));
VERSIONS.push_back(new Version(28, intArray(6, 6, 26, 50, 74, 98, 122),
new ECB(28, 16)))));
VERSIONS.push_back(Ref<Version>( new Version(28, intArray(6, 6, 26, 50, 74, 98, 122),
new ECBlocks(30, new ECB(3, 117),
new ECB(10, 118)),
new ECBlocks(28, new ECB(3, 45),
@ -455,8 +455,8 @@ int Version::buildVersions() {
new ECBlocks(30, new ECB(4, 24),
new ECB(31, 25)),
new ECBlocks(30, new ECB(11, 15),
new ECB(31, 16))));
VERSIONS.push_back(new Version(29, intArray(6, 6, 30, 54, 78, 102, 126),
new ECB(31, 16)))));
VERSIONS.push_back(Ref<Version>( new Version(29, intArray(6, 6, 30, 54, 78, 102, 126),
new ECBlocks(30, new ECB(7, 116),
new ECB(7, 117)),
new ECBlocks(28, new ECB(21, 45),
@ -464,8 +464,8 @@ int Version::buildVersions() {
new ECBlocks(30, new ECB(1, 23),
new ECB(37, 24)),
new ECBlocks(30, new ECB(19, 15),
new ECB(26, 16))));
VERSIONS.push_back(new Version(30, intArray(6, 6, 26, 52, 78, 104, 130),
new ECB(26, 16)))));
VERSIONS.push_back(Ref<Version>( new Version(30, intArray(6, 6, 26, 52, 78, 104, 130),
new ECBlocks(30, new ECB(5, 115),
new ECB(10, 116)),
new ECBlocks(28, new ECB(19, 47),
@ -473,8 +473,8 @@ int Version::buildVersions() {
new ECBlocks(30, new ECB(15, 24),
new ECB(25, 25)),
new ECBlocks(30, new ECB(23, 15),
new ECB(25, 16))));
VERSIONS.push_back(new Version(31, intArray(6, 6, 30, 56, 82, 108, 134),
new ECB(25, 16)))));
VERSIONS.push_back(Ref<Version>( new Version(31, intArray(6, 6, 30, 56, 82, 108, 134),
new ECBlocks(30, new ECB(13, 115),
new ECB(3, 116)),
new ECBlocks(28, new ECB(2, 46),
@ -482,16 +482,16 @@ int Version::buildVersions() {
new ECBlocks(30, new ECB(42, 24),
new ECB(1, 25)),
new ECBlocks(30, new ECB(23, 15),
new ECB(28, 16))));
VERSIONS.push_back(new Version(32, intArray(6, 6, 34, 60, 86, 112, 138),
new ECB(28, 16)))));
VERSIONS.push_back(Ref<Version>( new Version(32, intArray(6, 6, 34, 60, 86, 112, 138),
new ECBlocks(30, new ECB(17, 115)),
new ECBlocks(28, new ECB(10, 46),
new ECB(23, 47)),
new ECBlocks(30, new ECB(10, 24),
new ECB(35, 25)),
new ECBlocks(30, new ECB(19, 15),
new ECB(35, 16))));
VERSIONS.push_back(new Version(33, intArray(6, 6, 30, 58, 86, 114, 142),
new ECB(35, 16)))));
VERSIONS.push_back(Ref<Version>( new Version(33, intArray(6, 6, 30, 58, 86, 114, 142),
new ECBlocks(30, new ECB(17, 115),
new ECB(1, 116)),
new ECBlocks(28, new ECB(14, 46),
@ -499,8 +499,8 @@ int Version::buildVersions() {
new ECBlocks(30, new ECB(29, 24),
new ECB(19, 25)),
new ECBlocks(30, new ECB(11, 15),
new ECB(46, 16))));
VERSIONS.push_back(new Version(34, intArray(6, 6, 34, 62, 90, 118, 146),
new ECB(46, 16)))));
VERSIONS.push_back(Ref<Version>( new Version(34, intArray(6, 6, 34, 62, 90, 118, 146),
new ECBlocks(30, new ECB(13, 115),
new ECB(6, 116)),
new ECBlocks(28, new ECB(14, 46),
@ -508,8 +508,8 @@ int Version::buildVersions() {
new ECBlocks(30, new ECB(44, 24),
new ECB(7, 25)),
new ECBlocks(30, new ECB(59, 16),
new ECB(1, 17))));
VERSIONS.push_back(new Version(35, intArray(7, 6, 30, 54, 78,
new ECB(1, 17)))));
VERSIONS.push_back(Ref<Version>( new Version(35, intArray(7, 6, 30, 54, 78,
102, 126, 150),
new ECBlocks(30, new ECB(12, 121),
new ECB(7, 122)),
@ -518,8 +518,8 @@ int Version::buildVersions() {
new ECBlocks(30, new ECB(39, 24),
new ECB(14, 25)),
new ECBlocks(30, new ECB(22, 15),
new ECB(41, 16))));
VERSIONS.push_back(new Version(36, intArray(7, 6, 24, 50, 76,
new ECB(41, 16)))));
VERSIONS.push_back(Ref<Version>( new Version(36, intArray(7, 6, 24, 50, 76,
102, 128, 154),
new ECBlocks(30, new ECB(6, 121),
new ECB(14, 122)),
@ -528,8 +528,8 @@ int Version::buildVersions() {
new ECBlocks(30, new ECB(46, 24),
new ECB(10, 25)),
new ECBlocks(30, new ECB(2, 15),
new ECB(64, 16))));
VERSIONS.push_back(new Version(37, intArray(7, 6, 28, 54, 80,
new ECB(64, 16)))));
VERSIONS.push_back(Ref<Version>( new Version(37, intArray(7, 6, 28, 54, 80,
106, 132, 158),
new ECBlocks(30, new ECB(17, 122),
new ECB(4, 123)),
@ -538,8 +538,8 @@ int Version::buildVersions() {
new ECBlocks(30, new ECB(49, 24),
new ECB(10, 25)),
new ECBlocks(30, new ECB(24, 15),
new ECB(46, 16))));
VERSIONS.push_back(new Version(38, intArray(7, 6, 32, 58, 84,
new ECB(46, 16)))));
VERSIONS.push_back(Ref<Version>( new Version(38, intArray(7, 6, 32, 58, 84,
110, 136, 162),
new ECBlocks(30, new ECB(4, 122),
new ECB(18, 123)),
@ -548,8 +548,8 @@ int Version::buildVersions() {
new ECBlocks(30, new ECB(48, 24),
new ECB(14, 25)),
new ECBlocks(30, new ECB(42, 15),
new ECB(32, 16))));
VERSIONS.push_back(new Version(39, intArray(7, 6, 26, 54, 82,
new ECB(32, 16)))));
VERSIONS.push_back(Ref<Version>( new Version(39, intArray(7, 6, 26, 54, 82,
110, 138, 166),
new ECBlocks(30, new ECB(20, 117),
new ECB(4, 118)),
@ -558,8 +558,8 @@ int Version::buildVersions() {
new ECBlocks(30, new ECB(43, 24),
new ECB(22, 25)),
new ECBlocks(30, new ECB(10, 15),
new ECB(67, 16))));
VERSIONS.push_back(new Version(40, intArray(7, 6, 30, 58, 86,
new ECB(67, 16)))));
VERSIONS.push_back(Ref<Version>( new Version(40, intArray(7, 6, 30, 58, 86,
114, 142, 170),
new ECBlocks(30, new ECB(19, 118),
new ECB(6, 119)),
@ -568,7 +568,7 @@ int Version::buildVersions() {
new ECBlocks(30, new ECB(34, 24),
new ECB(34, 25)),
new ECBlocks(30, new ECB(20, 15),
new ECB(61, 16))));
new ECB(61, 16)))));
return int(VERSIONS.size());
}

10
src/zxing/zxing/qrcode/Version.h
View File

@ -54,7 +54,7 @@ public:
~ECBlocks();
};
class Version {
class Version : public Counted {
private:
int versionNumber_;
@ -67,7 +67,7 @@ private:
public:
static unsigned int VERSION_DECODE_INFO[];
static int N_VERSION_DECODE_INFOS;
static std::vector<Version* > VERSIONS;
static std::vector<Ref<Version> > VERSIONS;
~Version();
int getVersionNumber() const;
@ -75,9 +75,9 @@ public:
int getTotalCodewords();
int getDimensionForVersion();
ECBlocks &getECBlocksForLevel(const ErrorCorrectionLevel &ecLevel) const;
static Version* getProvisionalVersionForDimension(int dimension);
static Version* getVersionForNumber(int versionNumber);
static Version* decodeVersionInformation(unsigned int versionBits);
static Ref<Version> getProvisionalVersionForDimension(int dimension);
static Ref<Version> getVersionForNumber(int versionNumber);
static Ref<Version> decodeVersionInformation(unsigned int versionBits);
Ref<BitMatrix> buildFunctionPattern();
static int buildVersions();
};

4
src/zxing/zxing/qrcode/decoder/BitMatrixParser.h
View File

@ -33,7 +33,7 @@ namespace qrcode {
class BitMatrixParser : public Counted {
private:
Ref<BitMatrix> bitMatrix_;
Version *parsedVersion_;
Ref<Version>parsedVersion_;
Ref<FormatInformation> parsedFormatInfo_;
bool mirror_;
@ -42,7 +42,7 @@ private:
public:
BitMatrixParser(Ref<BitMatrix> bitMatrix);
Ref<FormatInformation> readFormatInformation();
Version *readVersion();
Ref<Version>readVersion();
ArrayRef<zxing::byte> readCodewords();
void remask();
void setMirror(boolean mirror);

2
src/zxing/zxing/qrcode/decoder/DataBlock.h
View File

@ -38,7 +38,7 @@ private:
public:
static std::vector<Ref<DataBlock> >
getDataBlocks(ArrayRef<zxing::byte> rawCodewords, Version *version, ErrorCorrectionLevel &ecLevel);
getDataBlocks(ArrayRef<zxing::byte> rawCodewords, Ref<Version>version, ErrorCorrectionLevel &ecLevel);
int getNumDataCodewords();
ArrayRef<zxing::byte> getCodewords();

2
src/zxing/zxing/qrcode/decoder/DecodedBitStreamParser.h
View File

@ -61,7 +61,7 @@ private:
public:
static Ref<DecoderResult> decode(ArrayRef<zxing::byte> bytes,
Version *version,
Ref<Version>version,
ErrorCorrectionLevel const& ecLevel,
Hashtable const& hints);
};

2
src/zxing/zxing/qrcode/decoder/Mode.h
View File

@ -55,7 +55,7 @@ public:
static Mode HANZI;
static Mode& forBits(int bits);
int getCharacterCountBits(const Version *version) const;
int getCharacterCountBits(const Ref<Version>version) const;
int getBits() const { return bits_; }
Mode& operator=(const Mode& other);

4
src/zxing/zxing/qrcode/decoder/QRBitMatrixParser.cpp
View File

@ -74,7 +74,7 @@ Ref<FormatInformation> BitMatrixParser::readFormatInformation() {
throw ReaderException("Could not decode format information");
}
Version *BitMatrixParser::readVersion() {
Ref<Version>BitMatrixParser::readVersion() {
if (parsedVersion_ != 0) {
return parsedVersion_;
}
@ -118,7 +118,7 @@ Version *BitMatrixParser::readVersion() {
ArrayRef<zxing::byte> BitMatrixParser::readCodewords() {
Ref<FormatInformation> formatInfo = readFormatInformation();
Version *version = readVersion();
Ref<Version>version = readVersion();
// Get the data mask for the format used in this QR Code. This will exclude

2
src/zxing/zxing/qrcode/decoder/QRDataBlock.cpp
View File

@ -39,7 +39,7 @@ ArrayRef<zxing::byte> DataBlock::getCodewords() {
}
std::vector<Ref<DataBlock> > DataBlock::getDataBlocks(ArrayRef<zxing::byte> rawCodewords, Version *version,
std::vector<Ref<DataBlock> > DataBlock::getDataBlocks(ArrayRef<zxing::byte> rawCodewords, Ref<Version>version,
ErrorCorrectionLevel &ecLevel) {

2
src/zxing/zxing/qrcode/decoder/QRDecodedBitStreamParser.cpp
View File

@ -351,7 +351,7 @@ int parseECIValue(BitSource& bits) {
Ref<DecoderResult>
DecodedBitStreamParser::decode(ArrayRef<zxing::byte> bytes,
Version* version,
Ref<Version> version,
ErrorCorrectionLevel const& ecLevel,
Hashtable const& hints) {
Ref<BitSource> bits_ (new BitSource(bytes));

2
src/zxing/zxing/qrcode/decoder/QRDecoder.cpp
View File

@ -69,7 +69,7 @@ Ref<DecoderResult> Decoder::decode(Ref<BitMatrix> bits) {
// std::cerr << *bits << std::endl;
Version *version = parser.readVersion();
Ref<Version>version = parser.readVersion();
ErrorCorrectionLevel &ecLevel = parser.readFormatInformation()->getErrorCorrectionLevel();

2
src/zxing/zxing/qrcode/decoder/QRMode.cpp
View File

@ -96,7 +96,7 @@ Mode& Mode::forBits(int bits) {
}
}
int Mode::getCharacterCountBits(const Version *version) const
int Mode::getCharacterCountBits(const Ref<Version>version) const
{
int number = version->getVersionNumber();
if (number <= 9) {

2
src/zxing/zxing/qrcode/detector/QRDetector.cpp
View File

@ -80,7 +80,7 @@ Ref<DetectorResult> Detector::processFinderPatternInfo(Ref<FinderPatternInfo> in
throw zxing::ReaderException("bad module size");
}
int dimension = computeDimension(topLeft, topRight, bottomLeft, moduleSize);
Version *provisionalVersion = Version::getProvisionalVersionForDimension(dimension);
Ref<Version>provisionalVersion = Version::getProvisionalVersionForDimension(dimension);
int modulesBetweenFPCenters = provisionalVersion->getDimensionForVersion() - 7;
Ref<AlignmentPattern> alignmentPattern;

12
src/zxing/zxing/qrcode/encoder/Encoder.h
View File

@ -40,7 +40,7 @@ public:
/**
* Append length info. On success, store the result in "bits".
*/
static void appendLengthInfo(int numLetters, const Version& version, const Mode& mode, BitArray& bits);
static void appendLengthInfo(int numLetters, const Ref<Version> version, const Mode& mode, BitArray& bits);
/**
* Append "bytes" in "mode" mode (encoding) into "bits". On success, store the result in "bits".
@ -92,10 +92,10 @@ protected:
private:
static int chooseMaskPattern(Ref<BitArray> bits,
ErrorCorrectionLevel& ecLevel,
Version* version,
Ref<Version> version,
Ref<ByteMatrix> matrix);
static Version* chooseVersion(int numInputBits, const ErrorCorrectionLevel &ecLevel) ;
static Ref<Version> chooseVersion(int numInputBits, const ErrorCorrectionLevel &ecLevel) ;
static void appendECI(const zxing::common::CharacterSetECI& eci, BitArray& bits);
@ -106,9 +106,9 @@ private:
static int calculateMaskPenalty(const ByteMatrix& matrix);
static int calculateBitsNeeded(const Mode &mode, const BitArray &headerBits, const BitArray &dataBits, const
Version* version);
static bool willFit(int numInputBits, Version* version, const ErrorCorrectionLevel &ecLevel);
static Version* recommendVersion(ErrorCorrectionLevel &ecLevel,
Ref<Version> version);
static bool willFit(int numInputBits, Ref<Version> version, const ErrorCorrectionLevel &ecLevel);
static Ref<Version> recommendVersion(ErrorCorrectionLevel &ecLevel,
Mode &mode,
BitArray &headerBits,
BitArray &dataBits);

4
src/zxing/zxing/qrcode/encoder/QRCode.cpp
View File

@ -25,7 +25,7 @@ Ref<ErrorCorrectionLevel> QRCode::getECLevel() const
return ecLevel_ptr_;
}
Version* QRCode::getVersion() const
Ref<Version> QRCode::getVersion() const
{
return version_ptr_;
}
@ -88,7 +88,7 @@ void QRCode::setECLevel(Ref<ErrorCorrectionLevel> value)
ecLevel_ptr_ = value;
}
void QRCode::setVersion(Version* version)
void QRCode::setVersion(Ref<Version> version)
{
version_ptr_ = version;
}

6
src/zxing/zxing/qrcode/encoder/QRCode.h
View File

@ -17,7 +17,7 @@ private:
Mode mode_;
Ref<ErrorCorrectionLevel> ecLevel_ptr_;
Version* version_ptr_;
Ref<Version> version_ptr_;
int maskPattern_;
Ref<ByteMatrix> matrix_ptr_;
@ -28,13 +28,13 @@ public:
~QRCode();
Mode getMode() const;
Ref<ErrorCorrectionLevel> getECLevel() const;
Version* getVersion() const;
Ref<Version> getVersion() const;
int getMaskPattern() const;
Ref<ByteMatrix> getMatrix() const;
std::string toString() const;
void setMode(const Mode &value);
void setECLevel(Ref<ErrorCorrectionLevel> value);
void setVersion(Version* version);
void setVersion(Ref<Version> version);
void setMaskPattern(int value);
void setMatrix(Ref<ByteMatrix> value);

22
src/zxing/zxing/qrcode/encoder/QREncoder.cpp
View File

@ -76,7 +76,7 @@ Ref<QRCode> Encoder::encode(const std::wstring& content, ErrorCorrectionLevel &e
BitArray dataBits;
appendBytes(content, mode, dataBits, encoding);
Version* version;
Ref<Version> version;
if (hints != ZXING_NULLPTR/* && hints->containsKey(EncodeHintType.QR_VERSION)*/) {
version = Version::getVersionForNumber(1); //should version number be passed as argument?
int bitsNeeded = calculateBitsNeeded(mode, headerBits, dataBits, version);
@ -91,7 +91,7 @@ Ref<QRCode> Encoder::encode(const std::wstring& content, ErrorCorrectionLevel &e
headerAndDataBits.appendBitArray(headerBits);
// Find "length" of main segment and write it
int numLetters = (mode == Mode::BYTE) ? dataBits.getSizeInBytes() : int(content.length());
appendLengthInfo(numLetters, *version, mode, headerAndDataBits);
appendLengthInfo(numLetters, version, mode, headerAndDataBits);
// Put data together into the overall payload
headerAndDataBits.appendBitArray(dataBits);
@ -128,7 +128,7 @@ Ref<QRCode> Encoder::encode(const std::wstring& content, ErrorCorrectionLevel &e
//return NULL;
}
bool Encoder::willFit(int numInputBits, Version* version, const ErrorCorrectionLevel &ecLevel) {
bool Encoder::willFit(int numInputBits, Ref<Version> version, const ErrorCorrectionLevel &ecLevel) {
// In the following comments, we use numbers of Version 7-H.
// numBytes = 196
int numBytes = version->getTotalCodewords();
@ -209,7 +209,7 @@ Mode Encoder::chooseMode(const std::wstring& content, const std::string& encodin
int Encoder::chooseMaskPattern(Ref<BitArray> bits,
ErrorCorrectionLevel& ecLevel,
Version* version,
Ref<Version> version,
Ref<ByteMatrix> matrix)
{
@ -227,11 +227,11 @@ int Encoder::chooseMaskPattern(Ref<BitArray> bits,
return bestMaskPattern;
}
Version* Encoder::chooseVersion(int numInputBits, const ErrorCorrectionLevel &ecLevel)
Ref<Version> Encoder::chooseVersion(int numInputBits, const ErrorCorrectionLevel &ecLevel)
{
// In the following comments, we use numbers of Version 7-H.
for (int versionNum = 1; versionNum <= 40; versionNum++) {
Version* version = Version::getVersionForNumber(versionNum);
Ref<Version> version = Version::getVersionForNumber(versionNum);
if (willFit(numInputBits, version, ecLevel)) {
return version;
}
@ -448,9 +448,9 @@ void Encoder::appendModeInfo(const Mode& mode, BitArray& bits)
/**
* Append length info. On success, store the result in "bits".
*/
void Encoder::appendLengthInfo(int numLetters, const Version& version, const Mode& mode, BitArray& bits)
void Encoder::appendLengthInfo(int numLetters, const Ref<Version> version, const Mode& mode, BitArray& bits)
{
int numBits = mode.getCharacterCountBits(&version);
int numBits = mode.getCharacterCountBits(version);
if (numLetters >= (1 << numBits)) {
std::string message = zxing::common::StringUtils::intToStr(numLetters);
message += " is bigger than ";
@ -579,12 +579,12 @@ void Encoder::appendECI(const zxing::common::CharacterSetECI& eci, BitArray& bit
}
int Encoder::calculateBitsNeeded(const Mode &mode, const BitArray &headerBits, const BitArray &dataBits, const
Version* version)
Ref<Version> version)
{
return headerBits.getSize() + mode.getCharacterCountBits(version) + dataBits.getSize();
}
Version* Encoder::recommendVersion(ErrorCorrectionLevel &ecLevel,
Ref<Version> Encoder::recommendVersion(ErrorCorrectionLevel &ecLevel,
Mode &mode,
BitArray &headerBits,
BitArray &dataBits)
@ -593,7 +593,7 @@ Version* Encoder::recommendVersion(ErrorCorrectionLevel &ecLevel,
// bits it takes to know version. First we take a guess at version by assuming version will be
// the minimum, 1:
int provisionalBitsNeeded = calculateBitsNeeded(mode, headerBits, dataBits, Version::getVersionForNumber(1));
Version* provisionalVersion = chooseVersion(provisionalBitsNeeded, ecLevel);
Ref<Version> provisionalVersion = chooseVersion(provisionalBitsNeeded, ecLevel);
// Use that guess to calculate the right version. I am still not sure this works in 100% of cases.
int bitsNeeded = calculateBitsNeeded(mode, headerBits, dataBits, provisionalVersion);

6
tests/src/QZXingTests/zxing/qrcode/encoder/EncoderTests.cpp
View File

@ -137,19 +137,19 @@ void EncoderTests::testAppendLengthInfo()
{
BitArray bits;
EncoderHack::appendLengthInfo(1, // 1 letter (1/1).
*Version::getVersionForNumber(1),
Version::getVersionForNumber(1),
Mode::NUMERIC,
bits);
assertEquals(" ........ .X", bits.toString()); // 10 bits.
bits = BitArray();
EncoderHack::appendLengthInfo(2, // 2 letters (2/1).
*Version::getVersionForNumber(10),
Version::getVersionForNumber(10),
Mode::ALPHANUMERIC,
bits);
assertEquals(" ........ .X.", bits.toString()); // 11 bits.
bits = BitArray();
EncoderHack::appendLengthInfo(255, // 255 letter (255/1).
*Version::getVersionForNumber(27),
Version::getVersionForNumber(27),
Mode::BYTE,
bits);
assertEquals(" ........ XXXXXXXX", bits.toString()); // 16 bits.