text
stringlengths 9
39.2M
| dir
stringlengths 26
295
| lang
stringclasses 185
values | created_date
timestamp[us] | updated_date
timestamp[us] | repo_name
stringlengths 1
97
| repo_full_name
stringlengths 7
106
| star
int64 1k
183k
| len_tokens
int64 1
13.8M
|
|---|---|---|---|---|---|---|---|---|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
#ifndef __ONED_READER_H__
#define __ONED_READER_H__
/*
* OneDReader.h
* ZXing
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/Reader.h>
namespace zxing {
namespace oned {
class OneDReader : public Reader {
private:
Ref<Result> doDecode(Ref<BinaryBitmap> image, DecodeHints hints);
protected:
struct Range {
private:
int data[2];
public:
Range() {}
Range(int zero, int one) {
data[0] = zero;
data[1] = one;
}
int& operator [] (int index) {
return data[index];
}
int const& operator [] (int index) const {
return data[index];
}
};
static float patternMatchVariance(std::vector<int>& counters,
std::vector<int> const& pattern,
float maxIndividualVariance);
static float patternMatchVariance(std::vector<int>& counters,
int const pattern[],
float maxIndividualVariance);
public:
OneDReader();
virtual Ref<Result> decode(Ref<BinaryBitmap> image, DecodeHints hints);
// Implementations must not throw any exceptions. If a barcode is not found on this row,
// a empty ref should be returned e.g. return Ref<Result>();
virtual Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row) = 0;
static void recordPattern(Ref<BitArray> row,
int start,
std::vector<int>& counters);
virtual ~OneDReader();
};
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/OneDReader.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 398
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/ZXing.h>
#include <zxing/oned/OneDReader.h>
#include <zxing/ReaderException.h>
#include <zxing/oned/OneDResultPoint.h>
#include <zxing/NotFoundException.h>
#include <math.h>
#include <limits.h>
#include <algorithm>
#include <cfloat>
using std::vector;
using zxing::Ref;
using zxing::Result;
using zxing::NotFoundException;
using zxing::oned::OneDReader;
// VC++
using zxing::BinaryBitmap;
using zxing::BitArray;
using zxing::DecodeHints;
OneDReader::OneDReader() {}
Ref<Result> OneDReader::decode(Ref<BinaryBitmap> image, DecodeHints hints) {
try {
return doDecode(image, hints);
} catch (NotFoundException const& nfe) {
// std::cerr << "trying harder" << std::endl;
bool tryHarder = hints.getTryHarder();
if (tryHarder && image->isRotateSupported()) {
// std::cerr << "v rotate" << std::endl;
Ref<BinaryBitmap> rotatedImage(image->rotateCounterClockwise());
// std::cerr << "^ rotate" << std::endl;
Ref<Result> result = doDecode(rotatedImage, hints);
// Doesn't have java metadata stuff
ArrayRef< Ref<ResultPoint> >& points (result->getResultPoints());
if (points && !points->empty()) {
int height = rotatedImage->getHeight();
for (int i = 0; i < points->size(); i++) {
points[i].reset(new OneDResultPoint(height - points[i]->getY() - 1, points[i]->getX()));
}
}
// std::cerr << "tried harder" << std::endl;
return result;
} else {
// std::cerr << "tried harder nfe" << std::endl;
throw nfe;
}
}
}
#include <typeinfo>
Ref<Result> OneDReader::doDecode(Ref<BinaryBitmap> image, DecodeHints hints) {
int width = image->getWidth();
int height = image->getHeight();
Ref<BitArray> row(new BitArray(width));
int middle = height / 2;
bool tryHarder = hints.getTryHarder();
int rowStep = std::max(1, height >> (tryHarder ? 8 : 5));
using namespace std;
// cerr << "rS " << rowStep << " " << height << " " << tryHarder << endl;
int maxLines;
if (tryHarder) {
maxLines = height; // Look at the whole image, not just the center
} else {
maxLines = 15; // 15 rows spaced 1/32 apart is roughly the middle half of the image
}
for (int x = 0; x < maxLines; x++) {
// Scanning from the middle out. Determine which row we're looking at next:
int rowStepsAboveOrBelow = (x + 1) / 2;
bool isAbove = (x & 0x01) == 0; // i.e. is x even?
int rowNumber = middle + rowStep * (isAbove ? rowStepsAboveOrBelow : -rowStepsAboveOrBelow);
if (false) {
std::cerr << "rN "
<< rowNumber << " "
<< height << " "
<< middle << " "
<< rowStep << " "
<< isAbove << " "
<< rowStepsAboveOrBelow
<< std::endl;
}
if (rowNumber < 0 || rowNumber >= height) {
// Oops, if we run off the top or bottom, stop
break;
}
// Estimate black point for this row and load it:
try {
row = image->getBlackRow(rowNumber, row);
} catch (NotFoundException const& ignored) {
(void)ignored;
continue;
}
// While we have the image data in a BitArray, it's fairly cheap to reverse it in place to
// handle decoding upside down barcodes.
for (int attempt = 0; attempt < 2; attempt++) {
if (attempt == 1) {
row->reverse(); // reverse the row and continue
}
// Java hints stuff missing
try {
// Look for a barcode
// std::cerr << "rn " << rowNumber << " " << typeid(*this).name() << std::endl;
Ref<Result> result = decodeRow(rowNumber, row);
// We found our barcode
if (attempt == 1) {
// But it was upside down, so note that
// result.putMetadata(ResultMetadataType.ORIENTATION, new Integer(180));
// And remember to flip the result points horizontally.
ArrayRef< Ref<ResultPoint> > points(result->getResultPoints());
if (points) {
points[0] = Ref<ResultPoint>(new OneDResultPoint(width - points[0]->getX() - 1,
points[0]->getY()));
points[1] = Ref<ResultPoint>(new OneDResultPoint(width - points[1]->getX() - 1,
points[1]->getY()));
}
}
return result;
} catch (ReaderException const& re) {
(void)re;
continue;
}
}
}
throw NotFoundException();
}
float OneDReader::patternMatchVariance(vector<int>& counters,
vector<int> const& pattern,
float maxIndividualVariance) {
return patternMatchVariance(counters, &pattern[0], maxIndividualVariance);
}
float OneDReader::patternMatchVariance(vector<int>& counters,
int const pattern[],
float maxIndividualVariance) {
int numCounters = counters.size();
unsigned int total = 0;
unsigned int patternLength = 0;
for (int i = 0; i < numCounters; i++) {
total += counters[i];
patternLength += pattern[i];
}
if (total < patternLength) {
// If we don't even have one pixel per unit of bar width, assume this is too small
// to reliably match, so fail:
return FLT_MAX;
}
float unitBarWidth = (float) total / patternLength;
maxIndividualVariance *= unitBarWidth;
float totalVariance = 0.0f;
for (int x = 0; x < numCounters; x++) {
int counter = counters[x];
float scaledPattern = pattern[x] * unitBarWidth;
float variance = counter > scaledPattern ? counter - scaledPattern : scaledPattern - counter;
if (variance > maxIndividualVariance) {
return FLT_MAX;
}
totalVariance += variance;
}
return totalVariance / total;
}
void OneDReader::recordPattern(Ref<BitArray> row,
int start,
vector<int>& counters) {
int numCounters = counters.size();
for (int i = 0; i < numCounters; i++) {
counters[i] = 0;
}
int end = row->getSize();
if (start >= end) {
throw NotFoundException();
}
bool isWhite = !row->get(start);
int counterPosition = 0;
int i = start;
while (i < end) {
if (row->get(i) ^ isWhite) { // that is, exactly one is true
counters[counterPosition]++;
} else {
counterPosition++;
if (counterPosition == numCounters) {
break;
} else {
counters[counterPosition] = 1;
isWhite = !isWhite;
}
}
i++;
}
// If we read fully the last section of pixels and filled up our counters -- or filled
// the last counter but ran off the side of the image, OK. Otherwise, a problem.
if (!(counterPosition == numCounters || (counterPosition == numCounters - 1 && i == end))) {
throw NotFoundException();
}
}
OneDReader::~OneDReader() {}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/OneDReader.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 1,840
|
```c++
/*
* OneDResultPoint.cpp
* ZXing
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include "OneDResultPoint.h"
namespace zxing {
namespace oned {
OneDResultPoint::OneDResultPoint(float posX, float posY) : ResultPoint(posX,posY) {
}
}
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/OneDResultPoint.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 102
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
#ifndef __UPC_EAN_READER_H__
#define __UPC_EAN_READER_H__
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/oned/OneDReader.h>
#include <zxing/common/BitArray.h>
#include <zxing/Result.h>
namespace zxing {
namespace oned {
class UPCEANReader : public OneDReader {
private:
std::string decodeRowStringBuffer;
// UPCEANExtensionSupport extensionReader;
// EANManufacturerOrgSupport eanManSupport;
static const float MAX_AVG_VARIANCE;
static const float MAX_INDIVIDUAL_VARIANCE;
static Range findStartGuardPattern(Ref<BitArray> row);
virtual Range decodeEnd(Ref<BitArray> row, int endStart);
static bool checkStandardUPCEANChecksum(Ref<String> const& s);
static int getStandardUPCEANChecksum (const std::string &s);
static Range findGuardPattern(Ref<BitArray> row,
int rowOffset,
bool whiteFirst,
std::vector<int> const& pattern,
std::vector<int>& counters);
protected:
static const std::vector<int> START_END_PATTERN;
static const std::vector<int> MIDDLE_PATTERN;
static const std::vector<int const*> L_PATTERNS;
static const std::vector<int const*> L_AND_G_PATTERNS;
static Range findGuardPattern(Ref<BitArray> row,
int rowOffset,
bool whiteFirst,
std::vector<int> const& pattern);
public:
UPCEANReader();
virtual int decodeMiddle(Ref<BitArray> row,
Range const& startRange,
std::string& resultString) = 0;
virtual Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row);
virtual Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row, Range const& range);
static int decodeDigit(Ref<BitArray> row,
std::vector<int>& counters,
int rowOffset,
std::vector<int const*> const& patterns);
virtual bool checkChecksum(Ref<String> const& s);
virtual BarcodeFormat getBarcodeFormat() = 0;
virtual ~UPCEANReader();
friend class MultiFormatUPCEANReader;
};
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/UPCEANReader.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 554
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
#ifndef __CODE_39_READER_H__
#define __CODE_39_READER_H__
/*
* Code39Reader.h
* ZXing
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/oned/OneDReader.h>
#include <zxing/common/BitArray.h>
#include <zxing/Result.h>
namespace zxing {
namespace oned {
/**
* <p>Decodes Code 39 barcodes. This does not support "Full ASCII Code 39" yet.</p>
* Ported form Java (author Sean Owen)
* @author Lukasz Warchol
*/
class Code39Reader : public OneDReader {
private:
bool usingCheckDigit;
bool extendedMode;
std::string decodeRowResult;
std::vector<int> counters;
void init(bool usingCheckDigit = false, bool extendedMode = false);
static std::vector<int> findAsteriskPattern(Ref<BitArray> row,
std::vector<int>& counters);
static int toNarrowWidePattern(std::vector<int>& counters);
static char patternToChar(int pattern);
static Ref<String> decodeExtended(std::string encoded);
void append(char* s, char c);
public:
Code39Reader();
Code39Reader(bool usingCheckDigit_);
Code39Reader(bool usingCheckDigit_, bool extendedMode_);
Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row);
};
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/Code39Reader.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 361
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/ZXing.h>
#include <zxing/oned/Code128Reader.h>
#include <zxing/oned/OneDResultPoint.h>
#include <zxing/common/Array.h>
#include <zxing/ReaderException.h>
#include <zxing/NotFoundException.h>
#include <zxing/FormatException.h>
#include <zxing/ChecksumException.h>
#include <math.h>
#include <string.h>
#include <sstream>
#include <algorithm>
using std::vector;
using std::string;
using zxing::NotFoundException;
using zxing::FormatException;
using zxing::ChecksumException;
using zxing::Ref;
using zxing::Result;
using zxing::oned::Code128Reader;
// VC++
using zxing::BitArray;
const float Code128Reader::MAX_AVG_VARIANCE = 0.25f;
const float Code128Reader::MAX_INDIVIDUAL_VARIANCE = 0.7f;
namespace {
const int CODE_SHIFT = 98;
const int CODE_CODE_C = 99;
const int CODE_CODE_B = 100;
const int CODE_CODE_A = 101;
const int CODE_FNC_1 = 102;
const int CODE_FNC_2 = 97;
const int CODE_FNC_3 = 96;
const int CODE_FNC_4_A = 101;
const int CODE_FNC_4_B = 100;
const int CODE_START_A = 103;
const int CODE_START_B = 104;
const int CODE_START_C = 105;
const int CODE_STOP = 106;
const int CODE_PATTERNS_LENGTH = 107;
const int CODE_PATTERNS[CODE_PATTERNS_LENGTH][6] = {
{2, 1, 2, 2, 2, 2}, /* 0 */
{2, 2, 2, 1, 2, 2},
{2, 2, 2, 2, 2, 1},
{1, 2, 1, 2, 2, 3},
{1, 2, 1, 3, 2, 2},
{1, 3, 1, 2, 2, 2}, /* 5 */
{1, 2, 2, 2, 1, 3},
{1, 2, 2, 3, 1, 2},
{1, 3, 2, 2, 1, 2},
{2, 2, 1, 2, 1, 3},
{2, 2, 1, 3, 1, 2}, /* 10 */
{2, 3, 1, 2, 1, 2},
{1, 1, 2, 2, 3, 2},
{1, 2, 2, 1, 3, 2},
{1, 2, 2, 2, 3, 1},
{1, 1, 3, 2, 2, 2}, /* 15 */
{1, 2, 3, 1, 2, 2},
{1, 2, 3, 2, 2, 1},
{2, 2, 3, 2, 1, 1},
{2, 2, 1, 1, 3, 2},
{2, 2, 1, 2, 3, 1}, /* 20 */
{2, 1, 3, 2, 1, 2},
{2, 2, 3, 1, 1, 2},
{3, 1, 2, 1, 3, 1},
{3, 1, 1, 2, 2, 2},
{3, 2, 1, 1, 2, 2}, /* 25 */
{3, 2, 1, 2, 2, 1},
{3, 1, 2, 2, 1, 2},
{3, 2, 2, 1, 1, 2},
{3, 2, 2, 2, 1, 1},
{2, 1, 2, 1, 2, 3}, /* 30 */
{2, 1, 2, 3, 2, 1},
{2, 3, 2, 1, 2, 1},
{1, 1, 1, 3, 2, 3},
{1, 3, 1, 1, 2, 3},
{1, 3, 1, 3, 2, 1}, /* 35 */
{1, 1, 2, 3, 1, 3},
{1, 3, 2, 1, 1, 3},
{1, 3, 2, 3, 1, 1},
{2, 1, 1, 3, 1, 3},
{2, 3, 1, 1, 1, 3}, /* 40 */
{2, 3, 1, 3, 1, 1},
{1, 1, 2, 1, 3, 3},
{1, 1, 2, 3, 3, 1},
{1, 3, 2, 1, 3, 1},
{1, 1, 3, 1, 2, 3}, /* 45 */
{1, 1, 3, 3, 2, 1},
{1, 3, 3, 1, 2, 1},
{3, 1, 3, 1, 2, 1},
{2, 1, 1, 3, 3, 1},
{2, 3, 1, 1, 3, 1}, /* 50 */
{2, 1, 3, 1, 1, 3},
{2, 1, 3, 3, 1, 1},
{2, 1, 3, 1, 3, 1},
{3, 1, 1, 1, 2, 3},
{3, 1, 1, 3, 2, 1}, /* 55 */
{3, 3, 1, 1, 2, 1},
{3, 1, 2, 1, 1, 3},
{3, 1, 2, 3, 1, 1},
{3, 3, 2, 1, 1, 1},
{3, 1, 4, 1, 1, 1}, /* 60 */
{2, 2, 1, 4, 1, 1},
{4, 3, 1, 1, 1, 1},
{1, 1, 1, 2, 2, 4},
{1, 1, 1, 4, 2, 2},
{1, 2, 1, 1, 2, 4}, /* 65 */
{1, 2, 1, 4, 2, 1},
{1, 4, 1, 1, 2, 2},
{1, 4, 1, 2, 2, 1},
{1, 1, 2, 2, 1, 4},
{1, 1, 2, 4, 1, 2}, /* 70 */
{1, 2, 2, 1, 1, 4},
{1, 2, 2, 4, 1, 1},
{1, 4, 2, 1, 1, 2},
{1, 4, 2, 2, 1, 1},
{2, 4, 1, 2, 1, 1}, /* 75 */
{2, 2, 1, 1, 1, 4},
{4, 1, 3, 1, 1, 1},
{2, 4, 1, 1, 1, 2},
{1, 3, 4, 1, 1, 1},
{1, 1, 1, 2, 4, 2}, /* 80 */
{1, 2, 1, 1, 4, 2},
{1, 2, 1, 2, 4, 1},
{1, 1, 4, 2, 1, 2},
{1, 2, 4, 1, 1, 2},
{1, 2, 4, 2, 1, 1}, /* 85 */
{4, 1, 1, 2, 1, 2},
{4, 2, 1, 1, 1, 2},
{4, 2, 1, 2, 1, 1},
{2, 1, 2, 1, 4, 1},
{2, 1, 4, 1, 2, 1}, /* 90 */
{4, 1, 2, 1, 2, 1},
{1, 1, 1, 1, 4, 3},
{1, 1, 1, 3, 4, 1},
{1, 3, 1, 1, 4, 1},
{1, 1, 4, 1, 1, 3}, /* 95 */
{1, 1, 4, 3, 1, 1},
{4, 1, 1, 1, 1, 3},
{4, 1, 1, 3, 1, 1},
{1, 1, 3, 1, 4, 1},
{1, 1, 4, 1, 3, 1}, /* 100 */
{3, 1, 1, 1, 4, 1},
{4, 1, 1, 1, 3, 1},
{2, 1, 1, 4, 1, 2},
{2, 1, 1, 2, 1, 4},
{2, 1, 1, 2, 3, 2}, /* 105 */
{2, 3, 3, 1, 1, 1}
};
}
Code128Reader::Code128Reader(){}
vector<int> Code128Reader::findStartPattern(Ref<BitArray> row){
int width = row->getSize();
int rowOffset = row->getNextSet(0);
int counterPosition = 0;
vector<int> counters (6, 0);
int patternStart = rowOffset;
bool isWhite = false;
int patternLength = counters.size();
for (int i = rowOffset; i < width; i++) {
if (row->get(i) ^ isWhite) {
counters[counterPosition]++;
} else {
if (counterPosition == patternLength - 1) {
float bestVariance = MAX_AVG_VARIANCE;
int bestMatch = -1;
for (int startCode = CODE_START_A; startCode <= CODE_START_C; startCode++) {
float variance = patternMatchVariance(counters, CODE_PATTERNS[startCode], MAX_INDIVIDUAL_VARIANCE);
if (variance < bestVariance) {
bestVariance = variance;
bestMatch = startCode;
}
}
// Look for whitespace before start pattern, >= 50% of width of start pattern
if (bestMatch >= 0 &&
row->isRange(std::max(0, patternStart - (i - patternStart) / 2), patternStart, false)) {
vector<int> resultValue (3, 0);
resultValue[0] = patternStart;
resultValue[1] = i;
resultValue[2] = bestMatch;
return resultValue;
}
patternStart += counters[0] + counters[1];
for (int y = 2; y < patternLength; y++) {
counters[y - 2] = counters[y];
}
counters[patternLength - 2] = 0;
counters[patternLength - 1] = 0;
counterPosition--;
} else {
counterPosition++;
}
counters[counterPosition] = 1;
isWhite = !isWhite;
}
}
throw NotFoundException();
}
int Code128Reader::decodeCode(Ref<BitArray> row, vector<int>& counters, int rowOffset) {
recordPattern(row, rowOffset, counters);
float bestVariance = MAX_AVG_VARIANCE; // worst variance we'll accept
int bestMatch = -1;
for (int d = 0; d < CODE_PATTERNS_LENGTH; d++) {
int const* const pattern = CODE_PATTERNS[d]; // const pointer to const int
float variance = patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE);
if (variance < bestVariance) {
bestVariance = variance;
bestMatch = d;
}
}
// TODO We're overlooking the fact that the STOP pattern has 7 values, not 6.
if (bestMatch >= 0) {
return bestMatch;
} else {
throw NotFoundException();
}
}
Ref<Result> Code128Reader::decodeRow(int rowNumber, Ref<BitArray> row) {
// boolean convertFNC1 = hints != null && hints.containsKey(DecodeHintType.ASSUME_GS1);
boolean convertFNC1 = false;
vector<int> startPatternInfo (findStartPattern(row));
int startCode = startPatternInfo[2];
int codeSet;
switch (startCode) {
case CODE_START_A:
codeSet = CODE_CODE_A;
break;
case CODE_START_B:
codeSet = CODE_CODE_B;
break;
case CODE_START_C:
codeSet = CODE_CODE_C;
break;
default:
throw FormatException();
}
bool done = false;
bool isNextShifted = false;
string result;
vector<char> rawCodes(20, 0);
int lastStart = startPatternInfo[0];
int nextStart = startPatternInfo[1];
vector<int> counters (6, 0);
int lastCode = 0;
int code = 0;
int checksumTotal = startCode;
int multiplier = 0;
bool lastCharacterWasPrintable = true;
bool upperMode = false;
bool shiftUpperMode = false;
std::ostringstream oss;
while (!done) {
bool unshift = isNextShifted;
isNextShifted = false;
// Save off last code
lastCode = code;
code = decodeCode(row, counters, nextStart);
// Remember whether the last code was printable or not (excluding CODE_STOP)
if (code != CODE_STOP) {
lastCharacterWasPrintable = true;
}
// Add to checksum computation (if not CODE_STOP of course)
if (code != CODE_STOP) {
multiplier++;
checksumTotal += multiplier * code;
}
// Advance to where the next code will to start
lastStart = nextStart;
for (int i = 0, e = counters.size(); i < e; i++) {
nextStart += counters[i];
}
// Take care of illegal start codes
switch (code) {
case CODE_START_A:
case CODE_START_B:
case CODE_START_C:
throw FormatException();
}
switch (codeSet) {
case CODE_CODE_A:
if (code < 64) {
if (shiftUpperMode == upperMode) {
result.append(1, (char) (' ' + code));
} else {
result.append(1, (char) (' ' + code + 128));
}
shiftUpperMode = false;
} else if (code < 96) {
if (shiftUpperMode == upperMode) {
result.append(1, (char) (code - 64));
} else {
result.append(1, (char) (code + 64));
}
shiftUpperMode = false;
} else {
// Don't let CODE_STOP, which always appears, affect whether whether we think the
// last code was printable or not.
if (code != CODE_STOP) {
lastCharacterWasPrintable = false;
}
switch (code) {
case CODE_FNC_1:
if (convertFNC1) {
if (result.length() == 0){
// GS1 specification 5.4.3.7. and 5.4.6.4. If the first char after the start code
// is FNC1 then this is GS1-128. We add the symbology identifier.
result.append("]C1");
} else {
// GS1 specification 5.4.7.5. Every subsequent FNC1 is returned as ASCII 29 (GS)
result.append(1, (char) 29);
}
}
break;
case CODE_FNC_2:
case CODE_FNC_3:
case CODE_FNC_4_A:
{
if (!upperMode && shiftUpperMode)
{
upperMode = true;
shiftUpperMode = false;
} else if (upperMode && shiftUpperMode)
{
upperMode = false;
shiftUpperMode = false;
} else
{
shiftUpperMode = true;
}
}
break;
case CODE_SHIFT:
isNextShifted = true;
codeSet = CODE_CODE_B;
break;
case CODE_CODE_B:
codeSet = CODE_CODE_B;
break;
case CODE_CODE_C:
codeSet = CODE_CODE_C;
break;
case CODE_STOP:
done = true;
break;
}
}
break;
case CODE_CODE_B:
if (code < 96) {
if (shiftUpperMode == upperMode) {
result.append(1, (char) (' ' + code));
} else {
result.append(1, (char) (' ' + code + 128));
}
shiftUpperMode = false;
} else {
if (code != CODE_STOP) {
lastCharacterWasPrintable = false;
}
switch (code) {
case CODE_FNC_1:
case CODE_FNC_2:
case CODE_FNC_3:
case CODE_FNC_4_B:
{
if (!upperMode && shiftUpperMode)
{
upperMode = true;
shiftUpperMode = false;
} else if (upperMode && shiftUpperMode)
{
upperMode = false;
shiftUpperMode = false;
} else
{
shiftUpperMode = true;
}
}
break;
case CODE_SHIFT:
isNextShifted = true;
codeSet = CODE_CODE_A;
break;
case CODE_CODE_A:
codeSet = CODE_CODE_A;
break;
case CODE_CODE_C:
codeSet = CODE_CODE_C;
break;
case CODE_STOP:
done = true;
break;
}
}
break;
case CODE_CODE_C:
if (code < 100) {
if (code < 10) {
result.append(1, '0');
}
oss.clear();
oss.str("");
oss << code;
result.append(oss.str());
} else {
if (code != CODE_STOP) {
lastCharacterWasPrintable = false;
}
switch (code) {
case CODE_FNC_1:
// do nothing?
break;
case CODE_CODE_A:
codeSet = CODE_CODE_A;
break;
case CODE_CODE_B:
codeSet = CODE_CODE_B;
break;
case CODE_STOP:
done = true;
break;
}
}
break;
}
// Unshift back to another code set if we were shifted
if (unshift) {
codeSet = codeSet == CODE_CODE_A ? CODE_CODE_B : CODE_CODE_A;
}
}
int lastPatternSize = nextStart - lastStart;
// Check for ample whitespace following pattern, but, to do this we first need to remember that
// we fudged decoding CODE_STOP since it actually has 7 bars, not 6. There is a black bar left
// to read off. Would be slightly better to properly read. Here we just skip it:
nextStart = row->getNextUnset(nextStart);
if (!row->isRange(nextStart,
std::min(row->getSize(), nextStart + (nextStart - lastStart) / 2),
false)) {
throw NotFoundException();
}
// Pull out from sum the value of the penultimate check code
checksumTotal -= multiplier * lastCode;
// lastCode is the checksum then:
if (checksumTotal % 103 != lastCode) {
throw ChecksumException();
}
// Need to pull out the check digits from string
int resultLength = result.length();
if (resultLength == 0) {
// false positive
throw NotFoundException();
}
// Only bother if the result had at least one character, and if the checksum digit happened to
// be a printable character. If it was just interpreted as a control code, nothing to remove.
if (resultLength > 0 && lastCharacterWasPrintable) {
if (codeSet == CODE_CODE_C) {
result.erase(resultLength - 2, resultLength);
} else {
result.erase(resultLength - 1, resultLength);
}
}
float left = (float) (startPatternInfo[1] + startPatternInfo[0]) / 2.0f;
float right = lastStart + lastPatternSize / 2.0f;
int rawCodesSize = rawCodes.size();
ArrayRef<char> rawBytes (rawCodesSize);
for (int i = 0; i < rawCodesSize; i++) {
rawBytes[i] = rawCodes[i];
}
ArrayRef< Ref<ResultPoint> > resultPoints(2);
resultPoints[0] =
Ref<OneDResultPoint>(new OneDResultPoint(left, (float) rowNumber));
resultPoints[1] =
Ref<OneDResultPoint>(new OneDResultPoint(right, (float) rowNumber));
return Ref<Result>(new Result(Ref<String>(new String(result)), rawBytes, resultPoints,
BarcodeFormat::CODE_128));
}
Code128Reader::~Code128Reader(){}
zxing::BarcodeFormat Code128Reader::getBarcodeFormat(){
return BarcodeFormat::CODE_128;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/Code128Reader.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 5,249
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
* UPCEANReader.cpp
* ZXing
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/ZXing.h>
#include <zxing/oned/UPCEANReader.h>
#include <zxing/oned/OneDResultPoint.h>
#include <zxing/ReaderException.h>
#include <zxing/NotFoundException.h>
#include <zxing/FormatException.h>
#include <zxing/ChecksumException.h>
using std::vector;
using std::string;
using zxing::Ref;
using zxing::Result;
using zxing::NotFoundException;
using zxing::FormatException;
using zxing::ChecksumException;
using zxing::oned::UPCEANReader;
// VC++
using zxing::BitArray;
using zxing::String;
#define LEN(v) ((int)(sizeof(v)/sizeof(v[0])))
namespace {
/**
* Start/end guard pattern.
*/
const int START_END_PATTERN_[] = {1, 1, 1};
// const int START_END_PATTERN_LEN = LEN(START_END_PATTERN_);
/**
* Pattern marking the middle of a UPC/EAN pattern, separating the two halves.
*/
const int MIDDLE_PATTERN_[] = {1, 1, 1, 1, 1};
// const int MIDDLE_PATTERN_LEN = LEN(MIDDLE_PATTERN_);
/**
* "Odd", or "L" patterns used to encode UPC/EAN digits.
*/
const int L_PATTERNS_[][4] = {
{3, 2, 1, 1}, // 0
{2, 2, 2, 1}, // 1
{2, 1, 2, 2}, // 2
{1, 4, 1, 1}, // 3
{1, 1, 3, 2}, // 4
{1, 2, 3, 1}, // 5
{1, 1, 1, 4}, // 6
{1, 3, 1, 2}, // 7
{1, 2, 1, 3}, // 8
{3, 1, 1, 2} // 9
};
// const int L_PATTERNS_LEN = LEN(L_PATTERNS_);
/**
* As above but also including the "even", or "G" patterns used to encode UPC/EAN digits.
*/
const int L_AND_G_PATTERNS_[][4] = {
{3, 2, 1, 1}, // 0
{2, 2, 2, 1}, // 1
{2, 1, 2, 2}, // 2
{1, 4, 1, 1}, // 3
{1, 1, 3, 2}, // 4
{1, 2, 3, 1}, // 5
{1, 1, 1, 4}, // 6
{1, 3, 1, 2}, // 7
{1, 2, 1, 3}, // 8
{3, 1, 1, 2}, // 9
{1, 1, 2, 3}, // 10 reversed 0
{1, 2, 2, 2}, // 11 reversed 1
{2, 2, 1, 2}, // 12 reversed 2
{1, 1, 4, 1}, // 13 reversed 3
{2, 3, 1, 1}, // 14 reversed 4
{1, 3, 2, 1}, // 15 reversed 5
{4, 1, 1, 1}, // 16 reversed 6
{2, 1, 3, 1}, // 17 reversed 7
{3, 1, 2, 1}, // 18 reversed 8
{2, 1, 1, 3} // 19 reversed 9
};
// const int L_AND_G_PATTERNS_LEN = LEN(L_AND_G_PATTERNS_);
}
const float UPCEANReader::MAX_AVG_VARIANCE = 0.48f;
const float UPCEANReader::MAX_INDIVIDUAL_VARIANCE = 0.7f;
#define VECTOR_INIT(v) v, v + sizeof(v)/sizeof(v[0])
const vector<int>
UPCEANReader::START_END_PATTERN (VECTOR_INIT(START_END_PATTERN_));
const vector<int>
UPCEANReader::MIDDLE_PATTERN (VECTOR_INIT(MIDDLE_PATTERN_));
const vector<int const*>
UPCEANReader::L_PATTERNS (VECTOR_INIT(L_PATTERNS_));
const vector<int const*>
UPCEANReader::L_AND_G_PATTERNS (VECTOR_INIT(L_AND_G_PATTERNS_));
UPCEANReader::UPCEANReader() {}
Ref<Result> UPCEANReader::decodeRow(int rowNumber, Ref<BitArray> row) {
return decodeRow(rowNumber, row, findStartGuardPattern(row));
}
Ref<Result> UPCEANReader::decodeRow(int rowNumber,
Ref<BitArray> row,
Range const& startGuardRange) {
string& result = decodeRowStringBuffer;
result.clear();
int endStart = decodeMiddle(row, startGuardRange, result);
Range endRange = decodeEnd(row, endStart);
// Make sure there is a quiet zone at least as big as the end pattern after the barcode.
// The spec might want more whitespace, but in practice this is the maximum we can count on.
int end = endRange[1];
int quietEnd = end + (end - endRange[0]);
if (quietEnd >= row->getSize() || !row->isRange(end, quietEnd, false)) {
throw NotFoundException();
}
// UPC/EAN should never be less than 8 chars anyway
if (result.length() < 8) {
throw FormatException();
}
Ref<String> resultString (new String(result));
if (!checkChecksum(resultString)) {
throw ChecksumException();
}
float left = (float) (startGuardRange[1] + startGuardRange[0]) / 2.0f;
float right = (float) (endRange[1] + endRange[0]) / 2.0f;
BarcodeFormat format = getBarcodeFormat();
ArrayRef< Ref<ResultPoint> > resultPoints(2);
resultPoints[0] = Ref<ResultPoint>(new OneDResultPoint(left, (float) rowNumber));
resultPoints[1] = Ref<ResultPoint>(new OneDResultPoint(right, (float) rowNumber));
Ref<Result> decodeResult (new Result(resultString, ArrayRef<char>(), resultPoints, format));
// Java extension and man stuff
return decodeResult;
}
UPCEANReader::Range UPCEANReader::findStartGuardPattern(Ref<BitArray> row) {
bool foundStart = false;
Range startRange;
int nextStart = 0;
vector<int> counters(START_END_PATTERN.size(), 0);
// std::cerr << "fsgp " << *row << std::endl;
while (!foundStart) {
for(int i=0; i < (int)START_END_PATTERN.size(); ++i) {
counters[i] = 0;
}
startRange = findGuardPattern(row, nextStart, false, START_END_PATTERN, counters);
// std::cerr << "sr " << startRange[0] << " " << startRange[1] << std::endl;
int start = startRange[0];
nextStart = startRange[1];
// Make sure there is a quiet zone at least as big as the start pattern before the barcode.
// If this check would run off the left edge of the image, do not accept this barcode,
// as it is very likely to be a false positive.
int quietStart = start - (nextStart - start);
if (quietStart >= 0) {
foundStart = row->isRange(quietStart, start, false);
}
}
return startRange;
}
UPCEANReader::Range UPCEANReader::findGuardPattern(Ref<BitArray> row,
int rowOffset,
bool whiteFirst,
vector<int> const& pattern) {
vector<int> counters (pattern.size(), 0);
return findGuardPattern(row, rowOffset, whiteFirst, pattern, counters);
}
UPCEANReader::Range UPCEANReader::findGuardPattern(Ref<BitArray> row,
int rowOffset,
bool whiteFirst,
vector<int> const& pattern,
vector<int>& counters) {
// cerr << "fGP " << rowOffset << " " << whiteFirst << endl;
if (false) {
for(int i=0; i < (int)pattern.size(); ++i) {
std::cerr << pattern[i];
}
std::cerr << std::endl;
}
int patternLength = pattern.size();
int width = row->getSize();
bool isWhite = whiteFirst;
rowOffset = whiteFirst ? row->getNextUnset(rowOffset) : row->getNextSet(rowOffset);
int counterPosition = 0;
int patternStart = rowOffset;
for (int x = rowOffset; x < width; x++) {
// std::cerr << "rg " << x << " " << row->get(x) << std::endl;
if (row->get(x) ^ isWhite) {
counters[counterPosition]++;
} else {
if (counterPosition == patternLength - 1) {
if (patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE) < MAX_AVG_VARIANCE) {
return Range(patternStart, x);
}
patternStart += counters[0] + counters[1];
for (int y = 2; y < patternLength; y++) {
counters[y - 2] = counters[y];
}
counters[patternLength - 2] = 0;
counters[patternLength - 1] = 0;
counterPosition--;
} else {
counterPosition++;
}
counters[counterPosition] = 1;
isWhite = !isWhite;
}
}
throw NotFoundException();
}
UPCEANReader::Range UPCEANReader::decodeEnd(Ref<BitArray> row, int endStart) {
return findGuardPattern(row, endStart, false, START_END_PATTERN);
}
int UPCEANReader::decodeDigit(Ref<BitArray> row,
vector<int> & counters,
int rowOffset,
vector<int const*> const& patterns) {
recordPattern(row, rowOffset, counters);
float bestVariance = MAX_AVG_VARIANCE; // worst variance we'll accept
int bestMatch = -1;
int max = patterns.size();
for (int i = 0; i < max; i++) {
int const* pattern (patterns[i]);
float variance = patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE);
if (variance < bestVariance) {
bestVariance = variance;
bestMatch = i;
}
}
if (bestMatch >= 0) {
return bestMatch;
} else {
throw NotFoundException();
}
}
/**
* @return {@link #checkStandardUPCEANChecksum(String)}
*/
bool UPCEANReader::checkChecksum(Ref<String> const& s) {
return checkStandardUPCEANChecksum(s);
}
/**
* Computes the UPC/EAN checksum on a string of digits, and reports
* whether the checksum is correct or not.
*
* @param s string of digits to check
* @return true iff string of digits passes the UPC/EAN checksum algorithm
*/
bool UPCEANReader::checkStandardUPCEANChecksum(Ref<String> const& s_) {
std::string const& s (s_->getText());
int length = s.length();
if (length == 0) {
return false;
}
int check = (int)s[length - 1] - (int) '0';
return getStandardUPCEANChecksum(s.substr(0, length - 1)) == check;
}
int UPCEANReader::getStandardUPCEANChecksum(const std::string &s) {
int length = s.length();
int sum = 0;
for (int i = length - 1; i >= 0; i -= 2) {
int digit = (int) s[i] - (int) '0';
if (digit < 0 || digit > 9) {
return -1;
}
sum += digit;
}
sum *= 3;
for (int i = length - 2; i >= 0; i -= 2) {
int digit = (int) s[i] - (int) '0';
if (digit < 0 || digit > 9) {
return -1;
}
sum += digit;
}
return (1000 - sum) % 10;
}
UPCEANReader::~UPCEANReader() {
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/UPCEANReader.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 2,963
|
```objective-c
#ifndef __MULTI_FORMAT_ONED_READER_H__
#define __MULTI_FORMAT_ONED_READER_H__
/*
* MultiFormatOneDReader.h
* ZXing
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/oned/OneDReader.h>
namespace zxing {
namespace oned {
class MultiFormatOneDReader : public OneDReader {
private:
std::vector<Ref<OneDReader> > readers;
public:
MultiFormatOneDReader(DecodeHints hints);
Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row);
};
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/MultiFormatOneDReader.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 166
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
#ifndef __ITF_READER_H__
#define __ITF_READER_H__
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/oned/OneDReader.h>
#include <zxing/common/BitArray.h>
#include <zxing/Result.h>
namespace zxing {
namespace oned {
class ITFReader : public OneDReader {
private:
static const float MAX_AVG_VARIANCE;
static const float MAX_INDIVIDUAL_VARIANCE;
// Stores the actual narrow line width of the image being decoded.
int narrowLineWidth;
Range decodeStart(Ref<BitArray> row);
Range decodeEnd(Ref<BitArray> row);
static void decodeMiddle(Ref<BitArray> row, int payloadStart, int payloadEnd, std::string& resultString);
void validateQuietZone(Ref<BitArray> row, int startPattern);
static int skipWhiteSpace(Ref<BitArray> row);
static Range findGuardPattern(Ref<BitArray> row, int rowOffset, std::vector<int> const& pattern);
static int decodeDigit(std::vector<int>& counters);
void append(char* s, char c);
public:
Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row);
ITFReader();
~ITFReader();
};
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/ITFReader.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 339
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
#ifndef __UPCA_READER_H__
#define __UPCA_READER_H__
/*
* UPCAReader.h
* ZXing
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/oned/EAN13Reader.h>
#include <zxing/DecodeHints.h>
namespace zxing {
namespace oned {
class UPCAReader : public UPCEANReader {
private:
EAN13Reader ean13Reader;
static Ref<Result> maybeReturnResult(Ref<Result> result);
public:
UPCAReader();
int decodeMiddle(Ref<BitArray> row, Range const& startRange, std::string& resultString);
Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row);
Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row, Range const& startGuardRange);
Ref<Result> decode(Ref<BinaryBitmap> image, DecodeHints hints);
BarcodeFormat getBarcodeFormat();
};
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/UPCAReader.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 258
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include "EAN13Reader.h"
#include <zxing/NotFoundException.h>
using std::vector;
using zxing::Ref;
using zxing::BitArray;
using zxing::oned::EAN13Reader;
namespace {
const int FIRST_DIGIT_ENCODINGS[10] = {
0x00, 0x0B, 0x0D, 0xE, 0x13, 0x19, 0x1C, 0x15, 0x16, 0x1A
};
}
EAN13Reader::EAN13Reader() : decodeMiddleCounters(4, 0) { }
int EAN13Reader::decodeMiddle(Ref<BitArray> row,
Range const& startRange,
std::string& resultString) {
vector<int>& counters (decodeMiddleCounters);
counters.clear();
counters.resize(4);
int end = row->getSize();
int rowOffset = startRange[1];
int lgPatternFound = 0;
for (int x = 0; x < 6 && rowOffset < end; x++) {
int bestMatch = decodeDigit(row, counters, rowOffset, L_AND_G_PATTERNS);
resultString.append(1, (char) ('0' + bestMatch % 10));
for (int i = 0, end = counters.size(); i <end; i++) {
rowOffset += counters[i];
}
if (bestMatch >= 10) {
lgPatternFound |= 1 << (5 - x);
}
}
determineFirstDigit(resultString, lgPatternFound);
Range middleRange = findGuardPattern(row, rowOffset, true, MIDDLE_PATTERN) ;
rowOffset = middleRange[1];
for (int x = 0; x < 6 && rowOffset < end; x++) {
int bestMatch =
decodeDigit(row, counters, rowOffset, L_PATTERNS);
resultString.append(1, (char) ('0' + bestMatch));
for (int i = 0, end = counters.size(); i < end; i++) {
rowOffset += counters[i];
}
}
return rowOffset;
}
void EAN13Reader::determineFirstDigit(std::string& resultString, int lgPatternFound) {
// std::cerr << "K " << resultString << " " << lgPatternFound << " " <<FIRST_DIGIT_ENCODINGS << std::endl;
for (int d = 0; d < 10; d++) {
if (lgPatternFound == FIRST_DIGIT_ENCODINGS[d]) {
resultString.insert(0, 1, (char) ('0' + d));
return;
}
}
throw NotFoundException();
}
zxing::BarcodeFormat EAN13Reader::getBarcodeFormat(){
return BarcodeFormat::EAN_13;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/EAN13Reader.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 684
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
#ifndef __CODA_BAR_READER_H__
#define __CODA_BAR_READER_H__
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/oned/OneDReader.h>
#include <zxing/common/BitArray.h>
#include <zxing/Result.h>
namespace zxing {
namespace oned {
class CodaBarReader : public OneDReader {
private:
static const float MAX_ACCEPTABLE;
static const float PADDING;
// Keep some instance variables to avoid reallocations
std::string decodeRowResult;
std::vector<int> counters;
int counterLength;
public:
CodaBarReader();
Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row);
void validatePattern(int start);
private:
void setCounters(Ref<BitArray> row);
void counterAppend(int e);
int findStartPattern();
static bool arrayContains(char const array[], char key);
int toNarrowWidePattern(int position);
};
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/CodaBarReader.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 266
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include "Code39Reader.h"
#include <zxing/oned/OneDResultPoint.h>
#include <zxing/common/Array.h>
#include <zxing/ReaderException.h>
#include <zxing/NotFoundException.h>
#include <zxing/ChecksumException.h>
#include <math.h>
#include <limits.h>
#include <algorithm>
using std::vector;
using zxing::Ref;
using zxing::Result;
using zxing::String;
using zxing::NotFoundException;
using zxing::ChecksumException;
using zxing::oned::Code39Reader;
// VC++
using zxing::BitArray;
namespace {
// const char* ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. *$/+%";
// Note this lacks '*' compared to ALPHABET_STRING
const char* CHECK_DIGIT_STRING = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%";
/**
* These represent the encodings of characters, as patterns of wide and narrow
* bars.
* The 9 least-significant bits of each int correspond to the pattern of wide
* and narrow, with 1s representing "wide" and 0s representing narrow.
*/
const int CHARACTER_ENCODINGS_LEN = 44;
int CHARACTER_ENCODINGS[CHARACTER_ENCODINGS_LEN] = {
0x034, 0x121, 0x061, 0x160, 0x031, 0x130, 0x070, 0x025, 0x124, 0x064, // 0-9
0x109, 0x049, 0x148, 0x019, 0x118, 0x058, 0x00D, 0x10C, 0x04C, 0x01C, // A-J
0x103, 0x043, 0x142, 0x013, 0x112, 0x052, 0x007, 0x106, 0x046, 0x016, // K-T
0x181, 0x0C1, 0x1C0, 0x091, 0x190, 0x0D0, 0x085, 0x184, 0x0C4, 0x094, // U-*
0x0A8, 0x0A2, 0x08A, 0x02A // $-%
};
int ASTERISK_ENCODING = 0x094;
const char* ALPHABET_STRING =
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. *$/+%";
std::string alphabet_string (ALPHABET_STRING);
std::string checkdigit_string (CHECK_DIGIT_STRING);
}
void Code39Reader::init(bool usingCheckDigit_, bool extendedMode_) {
usingCheckDigit = usingCheckDigit_;
extendedMode = extendedMode_;
decodeRowResult.reserve(20);
counters.resize(9);
}
/**
* Creates a reader that assumes all encoded data is data, and does not treat
* the final character as a check digit. It will not decoded "extended
* Code 39" sequences.
*/
Code39Reader::Code39Reader() {
init();
}
/**
* Creates a reader that can be configured to check the last character as a
* check digit. It will not decoded "extended Code 39" sequences.
*
* @param usingCheckDigit if true, treat the last data character as a check
* digit, not data, and verify that the checksum passes.
*/
Code39Reader::Code39Reader(bool usingCheckDigit_) {
init(usingCheckDigit_);
}
Code39Reader::Code39Reader(bool usingCheckDigit_, bool extendedMode_) {
init(usingCheckDigit_, extendedMode_);
}
Ref<Result> Code39Reader::decodeRow(int rowNumber, Ref<BitArray> row) {
std::vector<int>& theCounters (counters);
{ // Arrays.fill(counters, 0);
int size = theCounters.size();
theCounters.resize(0);
theCounters.resize(size); }
std::string& result (decodeRowResult);
result.clear();
vector<int> start (findAsteriskPattern(row, theCounters));
// Read off white space
int nextStart = row->getNextSet(start[1]);
int end = row->getSize();
char decodedChar;
int lastStart;
do {
recordPattern(row, nextStart, theCounters);
int pattern = toNarrowWidePattern(theCounters);
if (pattern < 0) {
throw NotFoundException();;
}
decodedChar = patternToChar(pattern);
result.append(1, decodedChar);
lastStart = nextStart;
for (int i = 0, end=theCounters.size(); i < end; i++) {
nextStart += theCounters[i];
}
// Read off white space
nextStart = row->getNextSet(nextStart);
} while (decodedChar != '*');
result.resize(decodeRowResult.length()-1);// remove asterisk
// Look for whitespace after pattern:
int lastPatternSize = 0;
for (int i = 0, e = theCounters.size(); i < e; i++) {
lastPatternSize += theCounters[i];
}
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 * 2) < lastPatternSize) {
throw NotFoundException();
}
if (usingCheckDigit) {
int max = result.length() - 1;
int total = 0;
for (int i = 0; i < max; i++) {
total += checkdigit_string.find_first_of(decodeRowResult[i], 0);
}
if (result[max] != CHECK_DIGIT_STRING[total % 43]) {
throw ChecksumException();
}
result.resize(max);
}
if (result.length() == 0) {
// Almost false positive
throw NotFoundException();
}
Ref<String> resultString;
if (extendedMode) {
resultString = decodeExtended(result);
} else {
resultString = Ref<String>(new String(result));
}
float left = (float) (start[1] + start[0]) / 2.0f;
float right = lastStart + lastPatternSize / 2.0f;
ArrayRef< Ref<ResultPoint> > resultPoints (2);
resultPoints[0] =
Ref<OneDResultPoint>(new OneDResultPoint(left, (float) rowNumber));
resultPoints[1] =
Ref<OneDResultPoint>(new OneDResultPoint(right, (float) rowNumber));
return Ref<Result>(
new Result(resultString, ArrayRef<char>(), resultPoints, BarcodeFormat::CODE_39)
);
}
vector<int> Code39Reader::findAsteriskPattern(Ref<BitArray> row, vector<int>& counters){
int width = row->getSize();
int rowOffset = row->getNextSet(0);
int counterPosition = 0;
int patternStart = rowOffset;
bool isWhite = false;
int patternLength = counters.size();
for (int i = rowOffset; i < width; i++) {
if (row->get(i) ^ isWhite) {
counters[counterPosition]++;
} else {
if (counterPosition == patternLength - 1) {
// Look for whitespace before start pattern, >= 50% of width of
// start pattern.
if (toNarrowWidePattern(counters) == ASTERISK_ENCODING &&
row->isRange(std::max(0, patternStart - ((i - patternStart) / 2)), patternStart, false)) {
vector<int> resultValue (2, 0);
resultValue[0] = patternStart;
resultValue[1] = i;
return resultValue;
}
patternStart += counters[0] + counters[1];
for (int y = 2; y < patternLength; y++) {
counters[y - 2] = counters[y];
}
counters[patternLength - 2] = 0;
counters[patternLength - 1] = 0;
counterPosition--;
} else {
counterPosition++;
}
counters[counterPosition] = 1;
isWhite = !isWhite;
}
}
throw NotFoundException();
}
// For efficiency, returns -1 on failure. Not throwing here saved as many as
// 700 exceptions per image when using some of our blackbox images.
int Code39Reader::toNarrowWidePattern(vector<int>& counters){
int numCounters = counters.size();
int maxNarrowCounter = 0;
int wideCounters;
do {
int minCounter = INT_MAX;
for (int i = 0; i < numCounters; i++) {
int counter = counters[i];
if (counter < minCounter && counter > maxNarrowCounter) {
minCounter = counter;
}
}
maxNarrowCounter = minCounter;
wideCounters = 0;
int totalWideCountersWidth = 0;
int pattern = 0;
for (int i = 0; i < numCounters; i++) {
int counter = counters[i];
if (counters[i] > maxNarrowCounter) {
pattern |= 1 << (numCounters - 1 - i);
wideCounters++;
totalWideCountersWidth += counter;
}
}
if (wideCounters == 3) {
// Found 3 wide counters, but are they close enough in width?
// We can perform a cheap, conservative check to see if any individual
// counter is more than 1.5 times the average:
for (int i = 0; i < numCounters && wideCounters > 0; i++) {
int counter = counters[i];
if (counters[i] > maxNarrowCounter) {
wideCounters--;
// totalWideCountersWidth = 3 * average, so this checks if
// counter >= 3/2 * average.
if ((counter * 2) >= totalWideCountersWidth) {
return -1;
}
}
}
return pattern;
}
} while (wideCounters > 3);
return -1;
}
char Code39Reader::patternToChar(int pattern){
for (int i = 0; i < CHARACTER_ENCODINGS_LEN; i++) {
if (CHARACTER_ENCODINGS[i] == pattern) {
return ALPHABET_STRING[i];
}
}
throw ReaderException("");
}
Ref<String> Code39Reader::decodeExtended(std::string encoded){
int length = encoded.length();
std::string tmpDecoded;
for (int i = 0; i < length; i++) {
char c = encoded[i];
if (c == '+' || c == '$' || c == '%' || c == '/') {
char next = encoded[i + 1];
char decodedChar = '\0';
switch (c) {
case '+':
// +A to +Z map to a to z
if (next >= 'A' && next <= 'Z') {
decodedChar = (char) (next + 32);
} else {
throw ReaderException("");
}
break;
case '$':
// $A to $Z map to control codes SH to SB
if (next >= 'A' && next <= 'Z') {
decodedChar = (char) (next - 64);
} else {
throw ReaderException("");
}
break;
case '%':
// %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 ReaderException("");
}
break;
case '/':
// /A to /O map to ! to , and /Z maps to :
if (next >= 'A' && next <= 'O') {
decodedChar = (char) (next - 32);
} else if (next == 'Z') {
decodedChar = ':';
} else {
throw ReaderException("");
}
break;
}
tmpDecoded.append(1, decodedChar);
// bump up i again since we read two characters
i++;
} else {
tmpDecoded.append(1, c);
}
}
Ref<String> decoded(new String(tmpDecoded));
return decoded;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/Code39Reader.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 2,882
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
* MultiFormatUPCEANReader.cpp
* ZXing
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/ZXing.h>
#include <zxing/oned/MultiFormatUPCEANReader.h>
#include <zxing/oned/EAN13Reader.h>
#include <zxing/oned/EAN8Reader.h>
#include <zxing/oned/UPCEReader.h>
#include <zxing/oned/UPCAReader.h>
#include <zxing/oned/OneDResultPoint.h>
#include <zxing/common/Array.h>
#include <zxing/ReaderException.h>
#include <zxing/NotFoundException.h>
#include <math.h>
using zxing::NotFoundException;
using zxing::Ref;
using zxing::Result;
using zxing::oned::MultiFormatUPCEANReader;
// VC++
using zxing::DecodeHints;
using zxing::BitArray;
MultiFormatUPCEANReader::MultiFormatUPCEANReader(DecodeHints hints) : readers() {
if (hints.containsFormat(BarcodeFormat::EAN_13)) {
readers.push_back(Ref<UPCEANReader>(new EAN13Reader()));
} else if (hints.containsFormat(BarcodeFormat::UPC_A)) {
readers.push_back(Ref<UPCEANReader>(new UPCAReader()));
}
if (hints.containsFormat(BarcodeFormat::EAN_8)) {
readers.push_back(Ref<UPCEANReader>(new EAN8Reader()));
}
if (hints.containsFormat(BarcodeFormat::UPC_E)) {
readers.push_back(Ref<UPCEANReader>(new UPCEReader()));
}
if (readers.size() == 0) {
readers.push_back(Ref<UPCEANReader>(new EAN13Reader()));
// UPC-A is covered by EAN-13
readers.push_back(Ref<UPCEANReader>(new EAN8Reader()));
readers.push_back(Ref<UPCEANReader>(new UPCEReader()));
}
}
#include <typeinfo>
Ref<Result> MultiFormatUPCEANReader::decodeRow(int rowNumber, Ref<BitArray> row) {
// Compute this location once and reuse it on multiple implementations
UPCEANReader::Range startGuardPattern = UPCEANReader::findStartGuardPattern(row);
for (int i = 0, e = readers.size(); i < e; i++) {
Ref<UPCEANReader> reader = readers[i];
Ref<Result> result;
try {
result = reader->decodeRow(rowNumber, row, startGuardPattern);
} catch (ReaderException const& ignored) {
(void)ignored;
continue;
}
// Special case: a 12-digit code encoded in UPC-A is identical
// to a "0" followed by those 12 digits encoded as EAN-13. Each
// will recognize such a code, UPC-A as a 12-digit string and
// EAN-13 as a 13-digit string starting with "0". Individually
// these are correct and their readers will both read such a
// code and correctly call it EAN-13, or UPC-A, respectively.
//
// In this case, if we've been looking for both types, we'd like
// to call it a UPC-A code. But for efficiency we only run the
// EAN-13 decoder to also read UPC-A. So we special case it
// here, and convert an EAN-13 result to a UPC-A result if
// appropriate.
bool ean13MayBeUPCA =
result->getBarcodeFormat() == BarcodeFormat::EAN_13 &&
result->getText()->charAt(0) == '0';
// Note: doesn't match Java which uses hints
bool canReturnUPCA = true;
if (ean13MayBeUPCA && canReturnUPCA) {
// Transfer the metdata across
Ref<Result> resultUPCA (new Result(result->getText()->substring(1),
result->getRawBytes(),
result->getResultPoints(),
BarcodeFormat::UPC_A));
// needs java metadata stuff
return resultUPCA;
}
return result;
}
throw NotFoundException();
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/MultiFormatUPCEANReader.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 974
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/ZXing.h>
#include <zxing/oned/CodaBarReader.h>
#include <zxing/oned/OneDResultPoint.h>
#include <zxing/common/Array.h>
#include <zxing/ReaderException.h>
#include <zxing/NotFoundException.h>
#include <zxing/FormatException.h>
#include <zxing/ChecksumException.h>
#include <math.h>
#include <sstream>
using std::vector;
using std::string;
using zxing::NotFoundException;
using zxing::FormatException;
using zxing::ChecksumException;
using zxing::Ref;
using zxing::Result;
using zxing::oned::CodaBarReader;
// VC++
using zxing::BitArray;
namespace {
char const ALPHABET_STRING[] = "0123456789-$:/.+ABCD";
char const* const ALPHABET = ALPHABET_STRING;
/**
* These represent the encodings of characters, as patterns of wide and narrow bars. The 7 least-significant bits of
* each int correspond to the pattern of wide and narrow, with 1s representing "wide" and 0s representing narrow.
*/
const int CHARACTER_ENCODINGS[] = {
0x003, 0x006, 0x009, 0x060, 0x012, 0x042, 0x021, 0x024, 0x030, 0x048, // 0-9
0x00c, 0x018, 0x045, 0x051, 0x054, 0x015, 0x01A, 0x029, 0x00B, 0x00E, // -$:/.+ABCD
};
// minimal number of characters that should be present (inclusing start and stop characters)
// under normal circumstances this should be set to 3, but can be set higher
// as a last-ditch attempt to reduce false positives.
const int MIN_CHARACTER_LENGTH = 3;
// official start and end patterns
const char STARTEND_ENCODING[] = {'A', 'B', 'C', 'D', 0};
// some codabar generator allow the codabar string to be closed by every
// character. This will cause lots of false positives!
// some industries use a checksum standard but this is not part of the original codabar standard
// for more information see : path_to_url
}
// These values are critical for determining how permissive the decoding
// will be. All stripe sizes must be within the window these define, as
// compared to the average stripe size.
const float CodaBarReader::MAX_ACCEPTABLE = 2.0f;
const float CodaBarReader::PADDING = 1.5f;
CodaBarReader::CodaBarReader()
: counters(80, 0), counterLength(0) {}
Ref<Result> CodaBarReader::decodeRow(int rowNumber, Ref<BitArray> row) {
{ // Arrays.fill(counters, 0);
int size = counters.size();
counters.resize(0);
counters.resize(size); }
setCounters(row);
int startOffset = findStartPattern();
int nextStart = startOffset;
decodeRowResult.clear();
do {
int charOffset = toNarrowWidePattern(nextStart);
if (charOffset == -1) {
throw NotFoundException();
}
// Hack: We store the position in the alphabet table into a
// StringBuilder, so that we can access the decoded patterns in
// validatePattern. We'll translate to the actual characters later.
decodeRowResult.append(1, (char)charOffset);
nextStart += 8;
// Stop as soon as we see the end character.
if (decodeRowResult.length() > 1 &&
arrayContains(STARTEND_ENCODING, ALPHABET[charOffset])) {
break;
}
} while (nextStart < counterLength); // no fixed end pattern so keep on reading while data is available
// Look for whitespace after pattern:
int trailingWhitespace = counters[nextStart - 1];
int lastPatternSize = 0;
for (int i = -8; i < -1; i++) {
lastPatternSize += counters[nextStart + i];
}
// We need to see whitespace equal to 50% of the last pattern size,
// otherwise this is probably a false positive. The exception is if we are
// at the end of the row. (I.e. the barcode barely fits.)
if (nextStart < counterLength && trailingWhitespace < lastPatternSize / 2) {
throw NotFoundException();
}
validatePattern(startOffset);
// Translate character table offsets to actual characters.
for (int i = 0; i < (int)decodeRowResult.length(); i++) {
decodeRowResult[i] = ALPHABET[(int)decodeRowResult[i]];
}
// Ensure a valid start and end character
char startchar = decodeRowResult[0];
if (!arrayContains(STARTEND_ENCODING, startchar)) {
throw NotFoundException();
}
char endchar = decodeRowResult[decodeRowResult.length() - 1];
if (!arrayContains(STARTEND_ENCODING, endchar)) {
throw NotFoundException();
}
// remove stop/start characters character and check if a long enough string is contained
if ((int)decodeRowResult.length() <= MIN_CHARACTER_LENGTH) {
// Almost surely a false positive ( start + stop + at least 1 character)
throw NotFoundException();
}
decodeRowResult.erase(decodeRowResult.length() - 1, 1);
decodeRowResult.erase(0, 1);
int runningCount = 0;
for (int i = 0; i < startOffset; i++) {
runningCount += counters[i];
}
float left = (float) runningCount;
for (int i = startOffset; i < nextStart - 1; i++) {
runningCount += counters[i];
}
float right = (float) runningCount;
ArrayRef< Ref<ResultPoint> > resultPoints(2);
resultPoints[0] =
Ref<OneDResultPoint>(new OneDResultPoint(left, (float) rowNumber));
resultPoints[1] =
Ref<OneDResultPoint>(new OneDResultPoint(right, (float) rowNumber));
return Ref<Result>(new Result(Ref<String>(new String(decodeRowResult)),
ArrayRef<char>(),
resultPoints,
BarcodeFormat::CODABAR));
}
void CodaBarReader::validatePattern(int start) {
// First, sum up the total size of our four categories of stripe sizes;
vector<int> sizes (4, 0);
vector<int> counts (4, 0);
int end = decodeRowResult.length() - 1;
// We break out of this loop in the middle, in order to handle
// inter-character spaces properly.
int pos = start;
for (int i = 0; true; i++) {
int pattern = CHARACTER_ENCODINGS[(int)decodeRowResult[i]];
for (int j = 6; j >= 0; j--) {
// Even j = bars, while odd j = spaces. Categories 2 and 3 are for
// long stripes, while 0 and 1 are for short stripes.
int category = (j & 1) + (pattern & 1) * 2;
sizes[category] += counters[pos + j];
counts[category]++;
pattern >>= 1;
}
if (i >= end) {
break;
}
// We ignore the inter-character space - it could be of any size.
pos += 8;
}
// Calculate our allowable size thresholds using fixed-point math.
vector<float> maxes (4, 0.0f);
vector<float> mins (4, 0.0f);
// Define the threshold of acceptability to be the midpoint between the
// average small stripe and the average large stripe. No stripe lengths
// should be on the "wrong" side of that line.
for (int i = 0; i < 2; i++) {
mins[i] = 0.0f; // Accept arbitrarily small "short" stripes.
mins[i + 2] = ((float) sizes[i] / counts[i] + (float) sizes[i + 2] /
counts[i + 2]) / 2.0f;
maxes[i] = mins[i + 2];
maxes[i + 2] = (sizes[i + 2] * MAX_ACCEPTABLE + PADDING) / counts[i + 2];
}
// Now verify that all of the stripes are within the thresholds.
pos = start;
for (int i = 0; true; i++) {
int pattern = CHARACTER_ENCODINGS[(int)decodeRowResult[i]];
for (int j = 6; j >= 0; j--) {
// Even j = bars, while odd j = spaces. Categories 2 and 3 are for
// long stripes, while 0 and 1 are for short stripes.
int category = (j & 1) + (pattern & 1) * 2;
int size = counters[pos + j];
if (size < mins[category] || size > maxes[category]) {
throw NotFoundException();
}
pattern >>= 1;
}
if (i >= end) {
break;
}
pos += 8;
}
}
/**
* Records the size of all runs of white and black pixels, starting with white.
* This is just like recordPattern, except it records all the counters, and
* uses our builtin "counters" member for storage.
* @param row row to count from
*/
void CodaBarReader::setCounters(Ref<BitArray> row) {
counterLength = 0;
// Start from the first white bit.
int i = row->getNextUnset(0);
int end = row->getSize();
if (i >= end) {
throw NotFoundException();
}
bool isWhite = true;
int count = 0;
for (; i < end; i++) {
if (row->get(i) ^ isWhite) { // that is, exactly one is true
count++;
} else {
counterAppend(count);
count = 1;
isWhite = !isWhite;
}
}
counterAppend(count);
}
void CodaBarReader::counterAppend(int e) {
if (counterLength < (int)counters.size()) {
counters[counterLength] = e;
} else {
counters.push_back(e);
}
counterLength++;
}
int CodaBarReader::findStartPattern() {
for (int i = 1; i < counterLength; i += 2) {
int charOffset = toNarrowWidePattern(i);
if (charOffset != -1 && arrayContains(STARTEND_ENCODING, ALPHABET[charOffset])) {
// Look for whitespace before start pattern, >= 50% of width of start pattern
// We make an exception if the whitespace is the first element.
int patternSize = 0;
for (int j = i; j < i + 7; j++) {
patternSize += counters[j];
}
if (i == 1 || counters[i-1] >= patternSize / 2) {
return i;
}
}
}
throw NotFoundException();
}
bool CodaBarReader::arrayContains(char const array[], char key) {
return strchr(array, key) != 0;
}
int CodaBarReader::toNarrowWidePattern(int position) {
int end = position + 7;
if (end >= counterLength) {
return -1;
}
vector<int>& theCounters = counters;
int maxBar = 0;
int minBar = std::numeric_limits<int>::max();
for (int j = position; j < end; j += 2) {
int currentCounter = theCounters[j];
if (currentCounter < minBar) {
minBar = currentCounter;
}
if (currentCounter > maxBar) {
maxBar = currentCounter;
}
}
int thresholdBar = (minBar + maxBar) / 2;
int maxSpace = 0;
int minSpace = std::numeric_limits<int>::max();
for (int j = position + 1; j < end; j += 2) {
int currentCounter = theCounters[j];
if (currentCounter < minSpace) {
minSpace = currentCounter;
}
if (currentCounter > maxSpace) {
maxSpace = currentCounter;
}
}
int thresholdSpace = (minSpace + maxSpace) / 2;
int bitmask = 1 << 7;
int pattern = 0;
for (int i = 0; i < 7; i++) {
int threshold = (i & 1) == 0 ? thresholdBar : thresholdSpace;
bitmask >>= 1;
if (theCounters[position + i] > threshold) {
pattern |= bitmask;
}
}
for (int i = 0; i < ZXING_ARRAY_LEN(CHARACTER_ENCODINGS); i++) {
if (CHARACTER_ENCODINGS[i] == pattern) {
return i;
}
}
return -1;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/CodaBarReader.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 3,000
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
#ifndef __CODE_128_READER_H__
#define __CODE_128_READER_H__
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/oned/OneDReader.h>
#include <zxing/common/BitArray.h>
#include <zxing/Result.h>
namespace zxing {
namespace oned {
class Code128Reader : public OneDReader {
private:
static const float MAX_AVG_VARIANCE;
static const float MAX_INDIVIDUAL_VARIANCE;
static std::vector<int> findStartPattern(Ref<BitArray> row);
static int decodeCode(Ref<BitArray> row,
std::vector<int>& counters,
int rowOffset);
public:
Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row);
Code128Reader();
~Code128Reader();
BarcodeFormat getBarcodeFormat();
};
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/Code128Reader.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 240
|
```objective-c
#ifndef __ONED_RESULT_POINT_H__
#define __ONED_RESULT_POINT_H__
/*
* OneDResultPoint.h
* ZXing
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/ResultPoint.h>
#include <cmath>
namespace zxing {
namespace oned {
class OneDResultPoint : public ResultPoint {
public:
OneDResultPoint(float posX, float posY);
};
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/OneDResultPoint.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 127
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/ZXing.h>
#include <zxing/oned/ITFReader.h>
#include <zxing/oned/OneDResultPoint.h>
#include <zxing/common/Array.h>
#include <zxing/ReaderException.h>
#include <zxing/FormatException.h>
#include <zxing/NotFoundException.h>
#include <math.h>
using std::vector;
using zxing::Ref;
using zxing::ArrayRef;
using zxing::Array;
using zxing::Result;
using zxing::FormatException;
using zxing::NotFoundException;
using zxing::oned::ITFReader;
// VC++
using zxing::BitArray;
const float ITFReader::MAX_AVG_VARIANCE = 0.38f;
const float ITFReader::MAX_INDIVIDUAL_VARIANCE = 0.78f;
#define VECTOR_INIT(v) v, v + sizeof(v)/sizeof(v[0])
namespace {
const int W = 3; // Pixel width of a wide line
const int N = 1; // Pixed width of a narrow line
const int DEFAULT_ALLOWED_LENGTHS_[] =
{ 48, 44, 24, 20, 18, 16, 14, 12, 10, 8, 6 };
const ArrayRef<int> DEFAULT_ALLOWED_LENGTHS (new Array<int>(VECTOR_INIT(DEFAULT_ALLOWED_LENGTHS_)));
/**
* Start/end guard pattern.
*
* Note: The end pattern is reversed because the row is reversed before
* searching for the END_PATTERN
*/
const int START_PATTERN_[] = {N, N, N, N};
const vector<int> START_PATTERN (VECTOR_INIT(START_PATTERN_));
const int END_PATTERN_REVERSED_[] = {N, N, W};
const vector<int> END_PATTERN_REVERSED (VECTOR_INIT(END_PATTERN_REVERSED_));
/**
* Patterns of Wide / Narrow lines to indicate each digit
*/
const int PATTERNS[][5] = {
{N, N, W, W, N}, // 0
{W, N, N, N, W}, // 1
{N, W, N, N, W}, // 2
{W, W, N, N, N}, // 3
{N, N, W, N, W}, // 4
{W, N, W, N, N}, // 5
{N, W, W, N, N}, // 6
{N, N, N, W, W}, // 7
{W, N, N, W, N}, // 8
{N, W, N, W, N} // 9
};
}
ITFReader::ITFReader() : narrowLineWidth(-1) {
}
Ref<Result> ITFReader::decodeRow(int rowNumber, Ref<BitArray> row) {
// Find out where the Middle section (payload) starts & ends
Range startRange = decodeStart(row);
Range endRange = decodeEnd(row);
std::string result;
decodeMiddle(row, startRange[1], endRange[0], result);
Ref<String> resultString(new String(result));
ArrayRef<int> allowedLengths;
// Java hints stuff missing
if (!allowedLengths) {
allowedLengths = DEFAULT_ALLOWED_LENGTHS;
}
// To avoid false positives with 2D barcodes (and other patterns), make
// an assumption that the decoded string must be 6, 10 or 14 digits.
int length = resultString->size();
bool lengthOK = false;
for (int i = 0, e = allowedLengths->size(); i < e; i++) {
if (length == allowedLengths[i]) {
lengthOK = true;
break;
}
}
if (!lengthOK) {
throw FormatException();
}
ArrayRef< Ref<ResultPoint> > resultPoints(2);
resultPoints[0] =
Ref<OneDResultPoint>(new OneDResultPoint(float(startRange[1]), float(rowNumber)));
resultPoints[1] =
Ref<OneDResultPoint>(new OneDResultPoint(float(endRange[0]), float(rowNumber)));
return Ref<Result>(new Result(resultString, ArrayRef<char>(), resultPoints, BarcodeFormat::ITF));
}
/**
* @param row row of black/white values to search
* @param payloadStart offset of start pattern
* @param resultString {@link StringBuffer} to append decoded chars to
* @throws ReaderException if decoding could not complete successfully
*/
void ITFReader::decodeMiddle(Ref<BitArray> row,
int payloadStart,
int payloadEnd,
std::string& resultString) {
// Digits are interleaved in pairs - 5 black lines for one digit, and the
// 5
// interleaved white lines for the second digit.
// Therefore, need to scan 10 lines and then
// split these into two arrays
vector<int> counterDigitPair(10, 0);
vector<int> counterBlack(5, 0);
vector<int> counterWhite(5, 0);
while (payloadStart < payloadEnd) {
// Get 10 runs of black/white.
recordPattern(row, payloadStart, counterDigitPair);
// Split them into each array
for (int k = 0; k < 5; k++) {
int twoK = 2 * k;
counterBlack[k] = counterDigitPair[twoK];
counterWhite[k] = counterDigitPair[twoK + 1];
}
int bestMatch = decodeDigit(counterBlack);
resultString.append(1, (char) ('0' + bestMatch));
bestMatch = decodeDigit(counterWhite);
resultString.append(1, (char) ('0' + bestMatch));
for (int i = 0, e = counterDigitPair.size(); i < e; i++) {
payloadStart += counterDigitPair[i];
}
}
}
/**
* Identify where the start of the middle / payload section starts.
*
* @param row row of black/white values to search
* @return Array, containing index of start of 'start block' and end of
* 'start block'
* @throws ReaderException
*/
ITFReader::Range ITFReader::decodeStart(Ref<BitArray> row) {
int endStart = skipWhiteSpace(row);
Range startPattern = findGuardPattern(row, endStart, START_PATTERN);
// Determine the width of a narrow line in pixels. We can do this by
// getting the width of the start pattern and dividing by 4 because its
// made up of 4 narrow lines.
narrowLineWidth = (startPattern[1] - startPattern[0]) / 4;
validateQuietZone(row, startPattern[0]);
return startPattern;
}
/**
* Identify where the end of the middle / payload section ends.
*
* @param row row of black/white values to search
* @return Array, containing index of start of 'end block' and end of 'end
* block'
* @throws ReaderException
*/
ITFReader::Range ITFReader::decodeEnd(Ref<BitArray> row) {
// For convenience, reverse the row and then
// search from 'the start' for the end block
BitArray::Reverse r (row);
int endStart = skipWhiteSpace(row);
Range endPattern = findGuardPattern(row, endStart, END_PATTERN_REVERSED);
// The start & end patterns must be pre/post fixed by a quiet zone. This
// zone must be at least 10 times the width of a narrow line.
// ref: path_to_url
validateQuietZone(row, endPattern[0]);
// Now recalculate the indices of where the 'endblock' starts & stops to
// accommodate
// the reversed nature of the search
int temp = endPattern[0];
endPattern[0] = row->getSize() - endPattern[1];
endPattern[1] = row->getSize() - temp;
return endPattern;
}
/**
* The start & end patterns must be pre/post fixed by a quiet zone. This
* zone must be at least 10 times the width of a narrow line. Scan back until
* we either get to the start of the barcode or match the necessary number of
* quiet zone pixels.
*
* Note: Its assumed the row is reversed when using this method to find
* quiet zone after the end pattern.
*
* ref: path_to_url
*
* @param row bit array representing the scanned barcode.
* @param startPattern index into row of the start or end pattern.
* @throws ReaderException if the quiet zone cannot be found, a ReaderException is thrown.
*/
void ITFReader::validateQuietZone(Ref<BitArray> row, int startPattern) {
int quietCount = this->narrowLineWidth * 10; // expect to find this many pixels of quiet zone
for (int i = startPattern - 1; quietCount > 0 && i >= 0; i--) {
if (row->get(i)) {
break;
}
quietCount--;
}
if (quietCount != 0) {
// Unable to find the necessary number of quiet zone pixels.
throw NotFoundException();
}
}
/**
* Skip all whitespace until we get to the first black line.
*
* @param row row of black/white values to search
* @return index of the first black line.
* @throws ReaderException Throws exception if no black lines are found in the row
*/
int ITFReader::skipWhiteSpace(Ref<BitArray> row) {
int width = row->getSize();
int endStart = row->getNextSet(0);
if (endStart == width) {
throw NotFoundException();
}
return endStart;
}
/**
* @param row row of black/white values to search
* @param rowOffset position to start search
* @param pattern pattern of counts of number of black and white pixels that are
* being searched for as a pattern
* @return start/end horizontal offset of guard pattern, as an array of two
* ints
* @throws ReaderException if pattern is not found
*/
ITFReader::Range ITFReader::findGuardPattern(Ref<BitArray> row,
int rowOffset,
vector<int> const& pattern) {
// TODO: This is very similar to implementation in UPCEANReader. Consider if they can be
// merged to a single method.
int patternLength = pattern.size();
vector<int> counters(patternLength);
int width = row->getSize();
bool isWhite = false;
int counterPosition = 0;
int patternStart = rowOffset;
for (int x = rowOffset; x < width; x++) {
if (row->get(x) ^ isWhite) {
counters[counterPosition]++;
} else {
if (counterPosition == patternLength - 1) {
if (patternMatchVariance(counters, &pattern[0], MAX_INDIVIDUAL_VARIANCE) < MAX_AVG_VARIANCE) {
return Range(patternStart, x);
}
patternStart += counters[0] + counters[1];
for (int y = 2; y < patternLength; y++) {
counters[y - 2] = counters[y];
}
counters[patternLength - 2] = 0;
counters[patternLength - 1] = 0;
counterPosition--;
} else {
counterPosition++;
}
counters[counterPosition] = 1;
isWhite = !isWhite;
}
}
throw NotFoundException();
}
/**
* Attempts to decode a sequence of ITF black/white lines into single
* digit.
*
* @param counters the counts of runs of observed black/white/black/... values
* @return The decoded digit
* @throws ReaderException if digit cannot be decoded
*/
int ITFReader::decodeDigit(vector<int>& counters){
float bestVariance = MAX_AVG_VARIANCE; // worst variance we'll accept
int bestMatch = -1;
int max = sizeof(PATTERNS)/sizeof(PATTERNS[0]);
for (int i = 0; i < max; i++) {
int const* pattern = PATTERNS[i];
float variance = patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE);
if (variance < bestVariance) {
bestVariance = variance;
bestMatch = i;
}
}
if (bestMatch >= 0) {
return bestMatch;
} else {
throw NotFoundException();
}
}
ITFReader::~ITFReader(){}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/ITFReader.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 2,822
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include "EAN8Reader.h"
#include <zxing/ReaderException.h>
using std::vector;
using zxing::oned::EAN8Reader;
// VC++
using zxing::Ref;
using zxing::BitArray;
EAN8Reader::EAN8Reader() : decodeMiddleCounters(4, 0) {}
int EAN8Reader::decodeMiddle(Ref<BitArray> row,
Range const& startRange,
std::string& result){
vector<int>& counters (decodeMiddleCounters);
counters[0] = 0;
counters[1] = 0;
counters[2] = 0;
counters[3] = 0;
int end = row->getSize();
int rowOffset = startRange[1];
for (int x = 0; x < 4 && rowOffset < end; x++) {
int bestMatch = decodeDigit(row, counters, rowOffset, L_PATTERNS);
result.append(1, (char) ('0' + bestMatch));
for (int i = 0, end = counters.size(); i < end; i++) {
rowOffset += counters[i];
}
}
Range middleRange =
findGuardPattern(row, rowOffset, true, MIDDLE_PATTERN);
rowOffset = middleRange[1];
for (int x = 0; x < 4 && rowOffset < end; x++) {
int bestMatch = decodeDigit(row, counters, rowOffset, L_PATTERNS);
result.append(1, (char) ('0' + bestMatch));
for (int i = 0, end = counters.size(); i < end; i++) {
rowOffset += counters[i];
}
}
return rowOffset;
}
zxing::BarcodeFormat EAN8Reader::getBarcodeFormat(){
return BarcodeFormat::EAN_8;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/EAN8Reader.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 465
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
#ifndef __UPC_E_READER_H__
#define __UPC_E_READER_H__
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/oned/UPCEANReader.h>
#include <zxing/Result.h>
namespace zxing {
namespace oned {
class UPCEReader : public UPCEANReader {
private:
std::vector<int> decodeMiddleCounters;
static bool determineNumSysAndCheckDigit(std::string& resultString, int lgPatternFound);
protected:
Range decodeEnd(Ref<BitArray> row, int endStart);
bool checkChecksum(Ref<String> const& s);
public:
UPCEReader();
int decodeMiddle(Ref<BitArray> row, Range const& startRange, std::string& resultString);
static Ref<String> convertUPCEtoUPCA(Ref<String> const& upce);
BarcodeFormat getBarcodeFormat();
};
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/UPCEReader.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 249
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
#ifndef __EAN_13_READER_H__
#define __EAN_13_READER_H__
/*
* EAN13Reader.h
* ZXing
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/oned/UPCEANReader.h>
#include <zxing/Result.h>
namespace zxing {
namespace oned {
class EAN13Reader : public UPCEANReader {
private:
std::vector<int> decodeMiddleCounters;
static void determineFirstDigit(std::string& resultString,
int lgPatternFound);
public:
EAN13Reader();
int decodeMiddle(Ref<BitArray> row,
Range const& startRange,
std::string& resultString);
BarcodeFormat getBarcodeFormat();
};
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/EAN13Reader.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 215
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
* UPCAReader.cpp
* ZXing
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include "UPCAReader.h"
#include <zxing/FormatException.h>
using zxing::oned::UPCAReader;
using zxing::Ref;
using zxing::Result;
// VC++
using zxing::BitArray;
using zxing::BinaryBitmap;
using zxing::DecodeHints;
using zxing::FormatException;
UPCAReader::UPCAReader() : ean13Reader() {}
Ref<Result> UPCAReader::decodeRow(int rowNumber, Ref<BitArray> row) {
return maybeReturnResult(ean13Reader.decodeRow(rowNumber, row));
}
Ref<Result> UPCAReader::decodeRow(int rowNumber,
Ref<BitArray> row,
Range const& startGuardRange) {
return maybeReturnResult(ean13Reader.decodeRow(rowNumber, row, startGuardRange));
}
Ref<Result> UPCAReader::decode(Ref<BinaryBitmap> image, DecodeHints hints) {
return maybeReturnResult(ean13Reader.decode(image, hints));
}
int UPCAReader::decodeMiddle(Ref<BitArray> row,
Range const& startRange,
std::string& resultString) {
return ean13Reader.decodeMiddle(row, startRange, resultString);
}
Ref<Result> UPCAReader::maybeReturnResult(Ref<Result> 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();
}
}
zxing::BarcodeFormat UPCAReader::getBarcodeFormat(){
return BarcodeFormat::UPC_A;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/UPCAReader.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 454
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
#ifndef __CODE_93_READER_H__
#define __CODE_93_READER_H__
/*
* Code93Reader.h
* ZXing
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/oned/OneDReader.h>
#include <zxing/common/BitArray.h>
#include <zxing/Result.h>
namespace zxing {
namespace oned {
/**
* <p>Decodes Code 93 barcodes. This does not support "Full ASCII Code 93" yet.</p>
* Ported form Java (author Sean Owen)
* @author Lukasz Warchol
*/
class Code93Reader : public OneDReader {
public:
Code93Reader();
Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row);
private:
std::string decodeRowResult;
std::vector<int> counters;
Range findAsteriskPattern(Ref<BitArray> row);
static int toPattern(std::vector<int>& counters);
static char patternToChar(int pattern);
static Ref<String> decodeExtended(std::string const& encoded);
static void checkChecksums(std::string const& result);
static void checkOneChecksum(std::string const& result,
int checkPosition,
int weightMax);
};
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/Code93Reader.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 321
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
#ifndef __EAN_8_READER_H__
#define __EAN_8_READER_H__
/*
* EAN8Reader.h
* ZXing
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/oned/UPCEANReader.h>
#include <zxing/Result.h>
namespace zxing {
namespace oned {
class EAN8Reader : public UPCEANReader {
private:
std::vector<int> decodeMiddleCounters;
public:
EAN8Reader();
int decodeMiddle(Ref<BitArray> row,
Range const& startRange,
std::string& resultString);
BarcodeFormat getBarcodeFormat();
};
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/EAN8Reader.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 196
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/ZXing.h>
#include <zxing/oned/UPCEReader.h>
#include <zxing/ReaderException.h>
using std::string;
using std::vector;
using zxing::Ref;
using zxing::String;
using zxing::oned::UPCEReader;
// VC++
using zxing::BitArray;
#define VECTOR_INIT(v) v, v + sizeof(v)/sizeof(v[0])
namespace {
/**
* The pattern that marks the middle, and end, of a UPC-E pattern.
* There is no "second half" to a UPC-E barcode.
*/
const int MIDDLE_END_PATTERN_[6] = {1, 1, 1, 1, 1, 1};
const vector<int> MIDDLE_END_PATTERN (VECTOR_INIT(MIDDLE_END_PATTERN_));
/**
* See {@link #L_AND_G_PATTERNS}; these values similarly represent patterns of
* even-odd parity encodings of digits that imply both the number system (0 or 1)
* used, and the check digit.
*/
const int NUMSYS_AND_CHECK_DIGIT_PATTERNS[2][10] = {
{0x38, 0x34, 0x32, 0x31, 0x2C, 0x26, 0x23, 0x2A, 0x29, 0x25},
{0x07, 0x0B, 0x0D, 0x0E, 0x13, 0x19, 0x1C, 0x15, 0x16, 0x1A}
};
}
UPCEReader::UPCEReader() {
}
int UPCEReader::decodeMiddle(Ref<BitArray> row, Range const& startRange, string& result) {
vector<int>& counters (decodeMiddleCounters);
counters.clear();
counters.resize(4);
int end = row->getSize();
int rowOffset = startRange[1];
int lgPatternFound = 0;
for (int x = 0; x < 6 && rowOffset < end; x++) {
int bestMatch = decodeDigit(row, counters, rowOffset, L_AND_G_PATTERNS);
result.append(1, (char) ('0' + bestMatch % 10));
for (int i = 0, e = counters.size(); i < e; i++) {
rowOffset += counters[i];
}
if (bestMatch >= 10) {
lgPatternFound |= 1 << (5 - x);
}
}
determineNumSysAndCheckDigit(result, lgPatternFound);
return rowOffset;
}
UPCEReader::Range UPCEReader::decodeEnd(Ref<BitArray> row, int endStart) {
return findGuardPattern(row, endStart, true, MIDDLE_END_PATTERN);
}
bool UPCEReader::checkChecksum(Ref<String> const& s){
return UPCEANReader::checkChecksum(convertUPCEtoUPCA(s));
}
bool UPCEReader::determineNumSysAndCheckDigit(std::string& resultString, int lgPatternFound) {
for (int numSys = 0; numSys <= 1; numSys++) {
for (int d = 0; d < 10; d++) {
if (lgPatternFound == NUMSYS_AND_CHECK_DIGIT_PATTERNS[numSys][d]) {
resultString.insert(0, 1, (char) ('0' + numSys));
resultString.append(1, (char) ('0' + d));
return true;
}
}
}
return false;
}
/**
* Expands a UPC-E value back into its full, equivalent UPC-A code value.
*
* @param upce UPC-E code as string of digits
* @return equivalent UPC-A code as string of digits
*/
Ref<String> UPCEReader::convertUPCEtoUPCA(Ref<String> const& upce_)
{
string const& upce(upce_->getText());
if (upce.size() >= 7) {
string result;
result.append(1, upce[0]);
char lastChar = upce[6];
switch (lastChar) {
case '0':
case '1':
case '2':
result.append(upce.substr(1,2));
result.append(1, lastChar);
result.append("0000");
result.append(upce.substr(3,3));
break;
case '3':
result.append(upce.substr(1,3));
result.append("00000");
result.append(upce.substr(4,2));
break;
case '4':
result.append(upce.substr(1,4));
result.append("00000");
result.append(1, upce[5]);
break;
default:
result.append(upce.substr(1,5));
result.append("0000");
result.append(1, lastChar);
break;
}
// Only append check digit in conversion if supplied
if (upce.size() >= 8)
result.append(1, upce[7]);
return Ref<String>(new String(result));
}
return upce_;
}
zxing::BarcodeFormat UPCEReader::getBarcodeFormat() {
return BarcodeFormat::UPC_E;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/UPCEReader.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 1,236
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
#ifndef __MULTI_FORMAT_UPC_EAN_READER_H__
#define __MULTI_FORMAT_UPC_EAN_READER_H__
/*
* MultiFormatUPCEANReader.h
* ZXing
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/oned/OneDReader.h>
namespace zxing {
namespace oned {
class UPCEANReader;
class MultiFormatUPCEANReader : public OneDReader {
private:
std::vector< Ref<UPCEANReader> > readers;
public:
MultiFormatUPCEANReader(DecodeHints hints);
Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row);
};
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/MultiFormatUPCEANReader.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 195
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/ZXing.h>
#include <zxing/oned/MultiFormatOneDReader.h>
#include <zxing/oned/MultiFormatUPCEANReader.h>
#include <zxing/oned/Code39Reader.h>
#include <zxing/oned/Code128Reader.h>
#include <zxing/oned/Code93Reader.h>
#include <zxing/oned/CodaBarReader.h>
#include <zxing/oned/ITFReader.h>
#include <zxing/ReaderException.h>
#include <zxing/NotFoundException.h>
using zxing::Ref;
using zxing::Result;
using zxing::oned::MultiFormatOneDReader;
// VC++
using zxing::DecodeHints;
using zxing::BitArray;
MultiFormatOneDReader::MultiFormatOneDReader(DecodeHints hints) : readers() {
if (hints.containsFormat(BarcodeFormat::EAN_13) ||
hints.containsFormat(BarcodeFormat::EAN_8) ||
hints.containsFormat(BarcodeFormat::UPC_A) ||
hints.containsFormat(BarcodeFormat::UPC_E)) {
readers.push_back(Ref<OneDReader>(new MultiFormatUPCEANReader(hints)));
}
if (hints.containsFormat(BarcodeFormat::CODE_39)) {
readers.push_back(Ref<OneDReader>(new Code39Reader()));
}
if (hints.containsFormat(BarcodeFormat::CODE_93)) {
readers.push_back(Ref<OneDReader>(new Code93Reader()));
}
if (hints.containsFormat(BarcodeFormat::CODE_128)) {
readers.push_back(Ref<OneDReader>(new Code128Reader()));
}
if (hints.containsFormat(BarcodeFormat::ITF)) {
readers.push_back(Ref<OneDReader>(new ITFReader()));
}
if (hints.containsFormat(BarcodeFormat::CODABAR)) {
readers.push_back(Ref<OneDReader>(new CodaBarReader()));
}
/*
if (hints.containsFormat(BarcodeFormat::RSS_14)) {
readers.push_back(Ref<OneDReader>(new RSS14Reader()));
}
*/
/*
if (hints.containsFormat(BarcodeFormat::RSS_EXPANDED)) {
readers.push_back(Ref<OneDReader>(new RSS14ExpandedReader()));
}
*/
if (readers.size() == 0) {
readers.push_back(Ref<OneDReader>(new MultiFormatUPCEANReader(hints)));
readers.push_back(Ref<OneDReader>(new Code39Reader()));
readers.push_back(Ref<OneDReader>(new CodaBarReader()));
readers.push_back(Ref<OneDReader>(new Code93Reader()));
readers.push_back(Ref<OneDReader>(new Code128Reader()));
readers.push_back(Ref<OneDReader>(new ITFReader()));
// readers.push_back(Ref<OneDReader>(new RSS14Reader()));
// readers.push_back(Ref<OneDReader>(new RSS14ExpandedReader()));
}
}
#include <typeinfo>
Ref<Result> MultiFormatOneDReader::decodeRow(int rowNumber, Ref<BitArray> row) {
int size = readers.size();
for (int i = 0; i < size; i++) {
OneDReader* reader = readers[i];
try {
Ref<Result> result = reader->decodeRow(rowNumber, row);
return result;
} catch (ReaderException const& re) {
(void)re;
// continue
}
}
throw NotFoundException();
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/MultiFormatOneDReader.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 818
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/pdf417/PDF417Reader.h>
#include <zxing/pdf417/detector/Detector.h>
using zxing::Ref;
using zxing::Result;
using zxing::BitMatrix;
using zxing::pdf417::PDF417Reader;
using zxing::pdf417::detector::Detector;
// VC++
using zxing::ArrayRef;
using zxing::BinaryBitmap;
using zxing::DecodeHints;
Ref<Result> PDF417Reader::decode(Ref<BinaryBitmap> image, DecodeHints hints) {
Ref<DecoderResult> decoderResult;
/* 2012-05-30 hfn C++ DecodeHintType does not yet know a type "PURE_BARCODE", */
/* therefore skip this for now, todo: may be add this type later */
/*
if (!hints.isEmpty() && hints.containsKey(DecodeHintType.PURE_BARCODE)) {
BitMatrix bits = extractPureBits(image.getBlackMatrix());
decoderResult = decoder.decode(bits);
points = NO_POINTS;
} else {
*/
Detector detector(image);
Ref<DetectorResult> detectorResult = detector.detect(hints); /* 2012-09-17 hints ("try_harder") */
ArrayRef< Ref<ResultPoint> > points(detectorResult->getPoints());
if (!hints.isEmpty()) {
Ref<ResultPointCallback> rpcb = hints.getResultPointCallback();
/* .get(DecodeHintType.NEED_RESULT_POINT_CALLBACK); */
if (rpcb != NULL) {
for (int i = 0; i < points->size(); i++) {
rpcb->foundPossibleResultPoint(*points[i]);
}
}
}
decoderResult = decoder.decode(detectorResult->getBits(),hints);
/*
}
*/
Ref<Result> r(new Result(decoderResult->getText(), decoderResult->getRawBytes(), points,
BarcodeFormat::PDF_417));
return r;
}
void PDF417Reader::reset() {
// do nothing
}
Ref<BitMatrix> PDF417Reader::extractPureBits(Ref<BitMatrix> image) {
ArrayRef<int> leftTopBlack = image->getTopLeftOnBit();
ArrayRef<int> rightBottomBlack = image->getBottomRightOnBit();
/* see BitMatrix::getTopLeftOnBit etc.:
if (leftTopBlack == null || rightBottomBlack == null) {
throw NotFoundException.getNotFoundInstance();
} */
int nModuleSize = moduleSize(leftTopBlack, image);
int top = leftTopBlack[1];
int bottom = rightBottomBlack[1];
int left = findPatternStart(leftTopBlack[0], top, image);
int right = findPatternEnd(leftTopBlack[0], top, image);
int matrixWidth = (right - left + 1) / nModuleSize;
int matrixHeight = (bottom - top + 1) / nModuleSize;
if (matrixWidth <= 0 || matrixHeight <= 0) {
throw NotFoundException("PDF417Reader::extractPureBits: no matrix found!");
}
// Push in the "border" by half the module width so that we start
// sampling in the middle of the module. Just in case the image is a
// little off, this will help recover.
int nudge = nModuleSize >> 1;
top += nudge;
left += nudge;
// Now just read off the bits
Ref<BitMatrix> bits(new BitMatrix(matrixWidth, matrixHeight));
for (int y = 0; y < matrixHeight; y++) {
int iOffset = top + y * nModuleSize;
for (int x = 0; x < matrixWidth; x++) {
if (image->get(left + x * nModuleSize, iOffset)) {
bits->set(x, y);
}
}
}
return bits;
}
int PDF417Reader::moduleSize(ArrayRef<int> leftTopBlack, Ref<BitMatrix> image) {
int x = leftTopBlack[0];
int y = leftTopBlack[1];
int width = image->getWidth();
while (x < width && image->get(x, y)) {
x++;
}
if (x == width) {
throw NotFoundException("PDF417Reader::moduleSize: not found!");
}
int moduleSize = (int)(((unsigned)(x - leftTopBlack[0])) >> 3); // We've crossed left first bar, which is 8x
if (moduleSize == 0) {
throw NotFoundException("PDF417Reader::moduleSize: is zero!");
}
return moduleSize;
}
int PDF417Reader::findPatternStart(int x, int y, Ref<BitMatrix> image) {
int width = image->getWidth();
int start = x;
// start should be on black
int transitions = 0;
bool black = true;
while (start < width - 1 && transitions < 8) {
start++;
bool newBlack = image->get(start, y);
if (black != newBlack) {
transitions++;
}
black = newBlack;
}
if (start == width - 1) {
throw NotFoundException("PDF417Reader::findPatternStart: no pattern start found!");
}
return start;
}
int PDF417Reader::findPatternEnd(int x, int y, Ref<BitMatrix> image) {
int width = image->getWidth();
int end = width - 1;
// end should be on black
while (end > x && !image->get(end, y)) {
end--;
}
int transitions = 0;
bool black = true;
while (end > x && transitions < 9) {
end--;
bool newBlack = image->get(end, y);
if (black != newBlack) {
transitions++;
}
black = newBlack;
}
if (end == x) {
throw NotFoundException("PDF417Reader::findPatternEnd: no pattern end found!");
}
return end;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/pdf417/PDF417Reader.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 1,375
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
#ifndef __PDF417_READER_H__
#define __PDF417_READER_H__
/*
* PDF417Reader.h
* zxing
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/Reader.h>
#include <zxing/pdf417/decoder/Decoder.h>
#include <zxing/DecodeHints.h>
namespace zxing {
namespace pdf417 {
class PDF417Reader : public Reader {
private:
decoder::Decoder decoder;
static Ref<BitMatrix> extractPureBits(Ref<BitMatrix> image);
static int moduleSize(ArrayRef<int> leftTopBlack, Ref<BitMatrix> image);
static int findPatternStart(int x, int y, Ref<BitMatrix> image);
static int findPatternEnd(int x, int y, Ref<BitMatrix> image);
public:
Ref<Result> decode(Ref<BinaryBitmap> image, DecodeHints hints);
void reset();
};
}
}
#endif // __PDF417_READER_H__
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/pdf417/PDF417Reader.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 255
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include "Code93Reader.h"
#include <zxing/oned/OneDResultPoint.h>
#include <zxing/common/Array.h>
#include <zxing/ReaderException.h>
#include <zxing/FormatException.h>
#include <zxing/NotFoundException.h>
#include <zxing/ChecksumException.h>
#include <math.h>
#include <limits.h>
using std::vector;
using std::string;
using zxing::Ref;
using zxing::Result;
using zxing::String;
using zxing::NotFoundException;
using zxing::ChecksumException;
using zxing::oned::Code93Reader;
// VC++
using zxing::BitArray;
namespace {
char const ALPHABET[] =
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%abcd*";
string ALPHABET_STRING (ALPHABET);
/**
* These represent the encodings of characters, as patterns of wide and narrow bars.
* The 9 least-significant bits of each int correspond to the pattern of wide and narrow.
*/
int const CHARACTER_ENCODINGS[] = {
0x114, 0x148, 0x144, 0x142, 0x128, 0x124, 0x122, 0x150, 0x112, 0x10A, // 0-9
0x1A8, 0x1A4, 0x1A2, 0x194, 0x192, 0x18A, 0x168, 0x164, 0x162, 0x134, // A-J
0x11A, 0x158, 0x14C, 0x146, 0x12C, 0x116, 0x1B4, 0x1B2, 0x1AC, 0x1A6, // K-T
0x196, 0x19A, 0x16C, 0x166, 0x136, 0x13A, // U-Z
0x12E, 0x1D4, 0x1D2, 0x1CA, 0x16E, 0x176, 0x1AE, // - - %
0x126, 0x1DA, 0x1D6, 0x132, 0x15E, // Control chars? $-*
};
int const CHARACTER_ENCODINGS_LENGTH =
(int)sizeof(CHARACTER_ENCODINGS)/sizeof(CHARACTER_ENCODINGS[0]);
const int ASTERISK_ENCODING = CHARACTER_ENCODINGS[47];
}
Code93Reader::Code93Reader() {
decodeRowResult.reserve(20);
counters.resize(6);
}
Ref<Result> Code93Reader::decodeRow(int rowNumber, Ref<BitArray> row) {
Range start (findAsteriskPattern(row));
// Read off white space
int nextStart = row->getNextSet(start[1]);
int end = row->getSize();
vector<int>& theCounters (counters);
{ // Arrays.fill(counters, 0);
int size = theCounters.size();
theCounters.resize(0);
theCounters.resize(size); }
string& result (decodeRowResult);
result.clear();
char decodedChar;
int lastStart;
do {
recordPattern(row, nextStart, theCounters);
int pattern = toPattern(theCounters);
if (pattern < 0) {
throw NotFoundException();
}
decodedChar = patternToChar(pattern);
result.append(1, decodedChar);
lastStart = nextStart;
for(int i=0, e=theCounters.size(); i < e; ++i) {
nextStart += theCounters[i];
}
// Read off white space
nextStart = row->getNextSet(nextStart);
} while (decodedChar != '*');
result.resize(result.length() - 1); // remove asterisk
// Look for whitespace after pattern:
int lastPatternSize = 0;
for (int i = 0, e = theCounters.size(); i < e; i++) {
lastPatternSize += theCounters[i];
}
// Should be at least one more black module
if (nextStart == end || !row->get(nextStart)) {
throw NotFoundException();
}
if (result.length() < 2) {
// false positive -- need at least 2 checksum digits
throw NotFoundException();
}
checkChecksums(result);
// Remove checksum digits
result.resize(result.length() - 2);
Ref<String> resultString = decodeExtended(result);
float left = (float) (start[1] + start[0]) / 2.0f;
float right = lastStart + lastPatternSize / 2.0f;
ArrayRef< Ref<ResultPoint> > resultPoints (2);
resultPoints[0] =
Ref<OneDResultPoint>(new OneDResultPoint(left, (float) rowNumber));
resultPoints[1] =
Ref<OneDResultPoint>(new OneDResultPoint(right, (float) rowNumber));
return Ref<Result>(new Result(
resultString,
ArrayRef<char>(),
resultPoints,
BarcodeFormat::CODE_93));
}
Code93Reader::Range Code93Reader::findAsteriskPattern(Ref<BitArray> row) {
int width = row->getSize();
int rowOffset = row->getNextSet(0);
{ // Arrays.fill(counters, 0);
int size = counters.size();
counters.resize(0);
counters.resize(size); }
vector<int>& theCounters (counters);
int patternStart = rowOffset;
bool isWhite = false;
int patternLength = theCounters.size();
int counterPosition = 0;
for (int i = rowOffset; i < width; i++) {
if (row->get(i) ^ isWhite) {
theCounters[counterPosition]++;
} else {
if (counterPosition == patternLength - 1) {
if (toPattern(theCounters) == ASTERISK_ENCODING) {
return Range(patternStart, i);
}
patternStart += theCounters[0] + theCounters[1];
for (int y = 2; y < patternLength; y++) {
theCounters[y - 2] = theCounters[y];
}
theCounters[patternLength - 2] = 0;
theCounters[patternLength - 1] = 0;
counterPosition--;
} else {
counterPosition++;
}
theCounters[counterPosition] = 1;
isWhite = !isWhite;
}
}
throw NotFoundException();
}
int Code93Reader::toPattern(vector<int>& counters) {
int max = counters.size();
int sum = 0;
for(int i=0, e=counters.size(); i<e; ++i) {
sum += counters[i];
}
int pattern = 0;
for (int i = 0; i < max; i++) {
int scaled = int(counters[i] * 9.0f / sum);
if (scaled < 1 || scaled > 4) {
return -1;
}
if ((i & 0x01) == 0) {
for (int j = 0; j < scaled; j++) {
pattern = (pattern << 1) | 0x01;
}
} else {
pattern <<= scaled;
}
}
return pattern;
}
char Code93Reader::patternToChar(int pattern) {
for (int i = 0; i < CHARACTER_ENCODINGS_LENGTH; i++) {
if (CHARACTER_ENCODINGS[i] == pattern) {
return ALPHABET[i];
}
}
throw NotFoundException();
}
Ref<String> Code93Reader::decodeExtended(string const& encoded) {
int length = encoded.length();
string decoded;
for (int i = 0; i < length; i++) {
char c = encoded[i];
if (c >= 'a' && c <= 'd') {
if (i >= length - 1) {
throw FormatException::getFormatInstance();
}
char next = encoded[i + 1];
char decodedChar = '\0';
switch (c) {
case 'd':
// +A to +Z map to a to z
if (next >= 'A' && next <= 'Z') {
decodedChar = (char) (next + 32);
} else {
throw FormatException::getFormatInstance();
}
break;
case 'a':
// $A to $Z map to control codes SH to SB
if (next >= 'A' && next <= 'Z') {
decodedChar = (char) (next - 64);
} else {
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 <= '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') {
decodedChar = (char) (next - 32);
} else if (next == 'Z') {
decodedChar = ':';
} else {
throw FormatException::getFormatInstance();
}
break;
}
decoded.append(1, decodedChar);
// bump up i again since we read two characters
i++;
} else {
decoded.append(1, c);
}
}
return Ref<String>(new String(decoded));
}
void Code93Reader::checkChecksums(string const& result) {
int length = result.length();
checkOneChecksum(result, length - 2, 20);
checkOneChecksum(result, length - 1, 15);
}
void Code93Reader::checkOneChecksum(string const& result,
int checkPosition,
int weightMax) {
int weight = 1;
int total = 0;
for (int i = checkPosition - 1; i >= 0; i--) {
total += weight * ALPHABET_STRING.find_first_of(result[i]);
if (++weight > weightMax) {
weight = 1;
}
}
if (result[checkPosition] != ALPHABET[total % 47]) {
throw ChecksumException();
}
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/oned/Code93Reader.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 2,577
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <stdint.h>
#include <bigint/BigIntegerUtils.hh>
#include <zxing/FormatException.h>
#include <zxing/pdf417/decoder/DecodedBitStreamParser.h>
#include <zxing/common/DecoderResult.h>
using std::string;
using zxing::pdf417::DecodedBitStreamParser;
using zxing::ArrayRef;
using zxing::Ref;
using zxing::DecoderResult;
using zxing::String;
const int DecodedBitStreamParser::TEXT_COMPACTION_MODE_LATCH = 900;
const int DecodedBitStreamParser::BYTE_COMPACTION_MODE_LATCH = 901;
const int DecodedBitStreamParser::NUMERIC_COMPACTION_MODE_LATCH = 902;
const int DecodedBitStreamParser::BYTE_COMPACTION_MODE_LATCH_6 = 924;
const int DecodedBitStreamParser::BEGIN_MACRO_PDF417_CONTROL_BLOCK = 928;
const int DecodedBitStreamParser::BEGIN_MACRO_PDF417_OPTIONAL_FIELD = 923;
const int DecodedBitStreamParser::MACRO_PDF417_TERMINATOR = 922;
const int DecodedBitStreamParser::MODE_SHIFT_TO_BYTE_COMPACTION_MODE = 913;
const int DecodedBitStreamParser::MAX_NUMERIC_CODEWORDS = 15;
const int DecodedBitStreamParser::PL = 25;
const int DecodedBitStreamParser::LL = 27;
const int DecodedBitStreamParser::AS = 27;
const int DecodedBitStreamParser::ML = 28;
const int DecodedBitStreamParser::AL = 28;
const int DecodedBitStreamParser::PS = 29;
const int DecodedBitStreamParser::PAL = 29;
const int DecodedBitStreamParser::EXP900_SIZE = 16;
const char DecodedBitStreamParser::PUNCT_CHARS[] = {
';', '<', '>', '@', '[', '\\', '}', '_', '`', '~', '!',
'\r', '\t', ',', ':', '\n', '-', '.', '$', '/', '"', '|', '*',
'(', ')', '?', '{', '}', '\''};
const char DecodedBitStreamParser::MIXED_CHARS[] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '&',
'\r', '\t', ',', ':', '#', '-', '.', '$', '/', '+', '%', '*',
'=', '^'};
ArrayRef<BigInteger> DecodedBitStreamParser::initEXP900() {
ArrayRef<BigInteger> EXP900 (16);
EXP900[0] = BigInteger(1);
BigInteger nineHundred (900);
EXP900[1] = nineHundred;
for (int i = 2; i < EXP900->size(); i++) {
EXP900[i] = EXP900[i - 1] * nineHundred;
}
return EXP900;
}
ArrayRef<BigInteger> DecodedBitStreamParser::EXP900 = initEXP900();
DecodedBitStreamParser::DecodedBitStreamParser(){}
/**
* PDF417 main decoder.
**/
Ref<DecoderResult> DecodedBitStreamParser::decode(ArrayRef<int> codewords)
{
Ref<String> result (new String(100));
// Get compaction mode
int codeIndex = 1;
int code = codewords[codeIndex++];
while (codeIndex < codewords[0]) {
switch (code) {
case TEXT_COMPACTION_MODE_LATCH:
codeIndex = textCompaction(codewords, codeIndex, result);
break;
case BYTE_COMPACTION_MODE_LATCH:
codeIndex = byteCompaction(code, codewords, codeIndex, result);
break;
case NUMERIC_COMPACTION_MODE_LATCH:
codeIndex = numericCompaction(codewords, codeIndex, result);
break;
case MODE_SHIFT_TO_BYTE_COMPACTION_MODE:
codeIndex = byteCompaction(code, codewords, codeIndex, result);
break;
case BYTE_COMPACTION_MODE_LATCH_6:
codeIndex = byteCompaction(code, codewords, codeIndex, result);
break;
default:
// Default to text compaction. During testing numerous barcodes
// appeared to be missing the starting mode. In these cases defaulting
// to text compaction seems to work.
codeIndex--;
codeIndex = textCompaction(codewords, codeIndex, result);
break;
}
if (codeIndex < codewords->size()) {
code = codewords[codeIndex++];
} else {
throw FormatException();
}
}
return Ref<DecoderResult>(new DecoderResult(ArrayRef<char>(), result));
}
/**
* Text Compaction mode (see 5.4.1.5) permits all printable ASCII characters to be
* encoded, i.e. values 32 - 126 inclusive in accordance with ISO/IEC 646 (IRV), as
* well as selected control characters.
*
* @param codewords The array of codewords (data + error)
* @param codeIndex The current index into the codeword array.
* @param result The decoded data is appended to the result.
* @return The next index into the codeword array.
*/
int DecodedBitStreamParser::textCompaction(ArrayRef<int> codewords,
int codeIndex,
Ref<String> result) {
// 2 character per codeword
ArrayRef<int> textCompactionData (codewords[0] << 1);
// Used to hold the byte compaction value if there is a mode shift
ArrayRef<int> byteCompactionData (codewords[0] << 1);
int index = 0;
bool end = false;
while ((codeIndex < codewords[0]) && !end) {
int code = codewords[codeIndex++];
if (code < TEXT_COMPACTION_MODE_LATCH) {
textCompactionData[index] = code / 30;
textCompactionData[index + 1] = code % 30;
index += 2;
} else {
switch (code) {
case TEXT_COMPACTION_MODE_LATCH:
textCompactionData[index++] = TEXT_COMPACTION_MODE_LATCH;
break;
case BYTE_COMPACTION_MODE_LATCH:
codeIndex--;
end = true;
break;
case NUMERIC_COMPACTION_MODE_LATCH:
codeIndex--;
end = true;
break;
case MODE_SHIFT_TO_BYTE_COMPACTION_MODE:
// The Mode Shift codeword 913 shall cause a temporary
// switch from Text Compaction mode to Byte Compaction mode.
// This switch shall be in effect for only the next codeword,
// after which the mode shall revert to the prevailing sub-mode
// of the Text Compaction mode. Codeword 913 is only available
// in Text Compaction mode; its use is described in 5.4.2.4.
textCompactionData[index] = MODE_SHIFT_TO_BYTE_COMPACTION_MODE;
code = codewords[codeIndex++];
byteCompactionData[index] = code; //Integer.toHexString(code);
index++;
break;
case BYTE_COMPACTION_MODE_LATCH_6:
codeIndex--;
end = true;
break;
}
}
}
decodeTextCompaction(textCompactionData, byteCompactionData, index, result);
return codeIndex;
}
/**
* The Text Compaction mode includes all the printable ASCII characters
* (i.e. values from 32 to 126) and three ASCII control characters: HT or tab
* (ASCII value 9), LF or line feed (ASCII value 10), and CR or carriage
* return (ASCII value 13). The Text Compaction mode also includes various latch
* and shift characters which are used exclusively within the mode. The Text
* Compaction mode encodes up to 2 characters per codeword. The compaction rules
* for converting data into PDF417 codewords are defined in 5.4.2.2. The sub-mode
* switches are defined in 5.4.2.3.
*
* @param textCompactionData The text compaction data.
* @param byteCompactionData The byte compaction data if there
* was a mode shift.
* @param length The size of the text compaction and byte compaction data.
* @param result The decoded data is appended to the result.
*/
void DecodedBitStreamParser::decodeTextCompaction(ArrayRef<int> textCompactionData,
ArrayRef<int> byteCompactionData,
int length,
Ref<String> result)
{
// Beginning from an initial state of the Alpha sub-mode
// The default compaction mode for PDF417 in effect at the start of each symbol shall always be Text
// Compaction mode Alpha sub-mode (uppercase alphabetic). A latch codeword from another mode to the Text
// Compaction mode shall always switch to the Text Compaction Alpha sub-mode.
Mode subMode = ALPHA;
Mode priorToShiftMode = ALPHA;
int i = 0;
while (i < length) {
int subModeCh = textCompactionData[i];
char ch = 0;
switch (subMode) {
case ALPHA:
// Alpha (uppercase alphabetic)
if (subModeCh < 26) {
// Upper case Alpha Character
ch = (char) ('A' + subModeCh);
} else {
if (subModeCh == 26) {
ch = ' ';
} else if (subModeCh == LL) {
subMode = LOWER;
} else if (subModeCh == ML) {
subMode = MIXED;
} else if (subModeCh == PS) {
// Shift to punctuation
priorToShiftMode = subMode;
subMode = PUNCT_SHIFT;
} else if (subModeCh == MODE_SHIFT_TO_BYTE_COMPACTION_MODE) {
result->append((char) byteCompactionData[i]);
} else if (subModeCh == TEXT_COMPACTION_MODE_LATCH) {
subMode = ALPHA;
}
}
break;
case LOWER:
// Lower (lowercase alphabetic)
if (subModeCh < 26) {
ch = (char) ('a' + subModeCh);
} else {
if (subModeCh == 26) {
ch = ' ';
} else if (subModeCh == AS) {
// Shift to alpha
priorToShiftMode = subMode;
subMode = ALPHA_SHIFT;
} else if (subModeCh == ML) {
subMode = MIXED;
} else if (subModeCh == PS) {
// Shift to punctuation
priorToShiftMode = subMode;
subMode = PUNCT_SHIFT;
} else if (subModeCh == MODE_SHIFT_TO_BYTE_COMPACTION_MODE) {
result->append((char) byteCompactionData[i]);
} else if (subModeCh == TEXT_COMPACTION_MODE_LATCH) {
subMode = ALPHA;
}
}
break;
case MIXED:
// Mixed (numeric and some punctuation)
if (subModeCh < PL) {
ch = MIXED_CHARS[subModeCh];
} else {
if (subModeCh == PL) {
subMode = PUNCT;
} else if (subModeCh == 26) {
ch = ' ';
} else if (subModeCh == LL) {
subMode = LOWER;
} else if (subModeCh == AL) {
subMode = ALPHA;
} else if (subModeCh == PS) {
// Shift to punctuation
priorToShiftMode = subMode;
subMode = PUNCT_SHIFT;
} else if (subModeCh == MODE_SHIFT_TO_BYTE_COMPACTION_MODE) {
result->append((char) byteCompactionData[i]);
} else if (subModeCh == TEXT_COMPACTION_MODE_LATCH) {
subMode = ALPHA;
}
}
break;
case PUNCT:
// Punctuation
if (subModeCh < PAL) {
ch = PUNCT_CHARS[subModeCh];
} else {
if (subModeCh == PAL) {
subMode = ALPHA;
} else if (subModeCh == MODE_SHIFT_TO_BYTE_COMPACTION_MODE) {
result->append((char) byteCompactionData[i]);
} else if (subModeCh == TEXT_COMPACTION_MODE_LATCH) {
subMode = ALPHA;
}
}
break;
case ALPHA_SHIFT:
// Restore sub-mode
subMode = priorToShiftMode;
if (subModeCh < 26) {
ch = (char) ('A' + subModeCh);
} else {
if (subModeCh == 26) {
ch = ' ';
} else {
if (subModeCh == 26) {
ch = ' ';
} else if (subModeCh == TEXT_COMPACTION_MODE_LATCH) {
subMode = ALPHA;
}
}
}
break;
case PUNCT_SHIFT:
// Restore sub-mode
subMode = priorToShiftMode;
if (subModeCh < PAL) {
ch = PUNCT_CHARS[subModeCh];
} else {
if (subModeCh == PAL) {
subMode = ALPHA;
// 2012-11-27 added from recent java code:
} else if (subModeCh == MODE_SHIFT_TO_BYTE_COMPACTION_MODE) {
// PS before Shift-to-Byte is used as a padding character,
// see 5.4.2.4 of the specification
result->append((char) byteCompactionData[i]);
} else if (subModeCh == TEXT_COMPACTION_MODE_LATCH) {
subMode = ALPHA;
}
}
break;
}
if (ch != 0) {
// Append decoded character to result
result->append(ch);
}
i++;
}
}
/**
* Byte Compaction mode (see 5.4.3) permits all 256 possible 8-bit byte values to be encoded.
* This includes all ASCII characters value 0 to 127 inclusive and provides for international
* character set support.
*
* @param mode The byte compaction mode i.e. 901 or 924
* @param codewords The array of codewords (data + error)
* @param codeIndex The current index into the codeword array.
* @param result The decoded data is appended to the result.
* @return The next index into the codeword array.
*/
int DecodedBitStreamParser::byteCompaction(int mode,
ArrayRef<int> codewords,
int codeIndex, Ref<String> result) {
if (mode == BYTE_COMPACTION_MODE_LATCH) {
// Total number of Byte Compaction characters to be encoded
// is not a multiple of 6
int count = 0;
int64_t value = 0;
ArrayRef<char> decodedData = new Array<char>(6);
ArrayRef<int> byteCompactedCodewords = new Array<int>(6);
bool end = false;
int nextCode = codewords[codeIndex++];
while ((codeIndex < codewords[0]) && !end) {
byteCompactedCodewords[count++] = nextCode;
// Base 900
value = 900 * value + nextCode;
nextCode = codewords[codeIndex++];
// perhaps it should be ok to check only nextCode >= TEXT_COMPACTION_MODE_LATCH
if (nextCode == TEXT_COMPACTION_MODE_LATCH ||
nextCode == BYTE_COMPACTION_MODE_LATCH ||
nextCode == NUMERIC_COMPACTION_MODE_LATCH ||
nextCode == BYTE_COMPACTION_MODE_LATCH_6 ||
nextCode == BEGIN_MACRO_PDF417_CONTROL_BLOCK ||
nextCode == BEGIN_MACRO_PDF417_OPTIONAL_FIELD ||
nextCode == MACRO_PDF417_TERMINATOR)
{
end = true;
}
else
{
if ((count%5 == 0) && (count > 0))
{
// Decode every 5 codewords
// Convert to Base 256
for (int j = 0; j < 6; ++j)
{
decodedData[5 - j] = (char) (value%256);
value >>= 8;
}
result->append(string(&(decodedData->values()[0]), decodedData->values().size()));
count = 0;
}
}
}
// if the end of all codewords is reached the last codeword needs to be added
if (codeIndex == codewords[0] && nextCode < TEXT_COMPACTION_MODE_LATCH)
byteCompactedCodewords[count++] = nextCode;
// If Byte Compaction mode is invoked with codeword 901,
// the last group of codewords is interpreted directly
// as one byte per codeword, without compaction.
for (int i = 0; i < count; i++)
{
result->append((char)byteCompactedCodewords[i]);
}
} else if (mode == BYTE_COMPACTION_MODE_LATCH_6) {
// Total number of Byte Compaction characters to be encoded
// is an integer multiple of 6
int count = 0;
int64_t value = 0;
bool end = false;
while (codeIndex < codewords[0] && !end) {
int code = codewords[codeIndex++];
if (code < TEXT_COMPACTION_MODE_LATCH) {
count++;
// Base 900
value = 900 * value + code;
} else {
if (code == TEXT_COMPACTION_MODE_LATCH ||
code == BYTE_COMPACTION_MODE_LATCH ||
code == NUMERIC_COMPACTION_MODE_LATCH ||
code == BYTE_COMPACTION_MODE_LATCH_6 ||
code == BEGIN_MACRO_PDF417_CONTROL_BLOCK ||
code == BEGIN_MACRO_PDF417_OPTIONAL_FIELD ||
code == MACRO_PDF417_TERMINATOR) {
codeIndex--;
end = true;
}
}
if ((count % 5 == 0) && (count > 0)) {
// Decode every 5 codewords
// Convert to Base 256
ArrayRef<char> decodedData = new Array<char>(6);
for (int j = 0; j < 6; ++j) {
decodedData[5 - j] = (char) (value & 0xFF);
value >>= 8;
}
result->append(string(&decodedData[0],6));
// 2012-11-27 hfn after recent java code/fix by srowen
count = 0;
}
}
}
return codeIndex;
}
/**
* Numeric Compaction mode (see 5.4.4) permits efficient encoding of numeric data strings.
*
* @param codewords The array of codewords (data + error)
* @param codeIndex The current index into the codeword array.
* @param result The decoded data is appended to the result.
* @return The next index into the codeword array.
*/
int DecodedBitStreamParser::numericCompaction(ArrayRef<int> codewords,
int codeIndex,
Ref<String> result) {
int count = 0;
bool end = false;
ArrayRef<int> numericCodewords = new Array<int>(MAX_NUMERIC_CODEWORDS);
while (codeIndex < codewords[0] && !end) {
int code = codewords[codeIndex++];
if (codeIndex == codewords[0]) {
end = true;
}
if (code < TEXT_COMPACTION_MODE_LATCH) {
numericCodewords[count] = code;
count++;
} else {
if (code == TEXT_COMPACTION_MODE_LATCH ||
code == BYTE_COMPACTION_MODE_LATCH ||
code == BYTE_COMPACTION_MODE_LATCH_6 ||
code == BEGIN_MACRO_PDF417_CONTROL_BLOCK ||
code == BEGIN_MACRO_PDF417_OPTIONAL_FIELD ||
code == MACRO_PDF417_TERMINATOR) {
codeIndex--;
end = true;
}
}
if (count % MAX_NUMERIC_CODEWORDS == 0 ||
code == NUMERIC_COMPACTION_MODE_LATCH ||
end) {
// Re-invoking Numeric Compaction mode (by using codeword 902
// while in Numeric Compaction mode) serves to terminate the
// current Numeric Compaction mode grouping as described in 5.4.4.2,
// and then to start a new one grouping.
Ref<String> s = decodeBase900toBase10(numericCodewords, count);
result->append(s->getText());
count = 0;
}
}
return codeIndex;
}
/**
* Convert a list of Numeric Compacted codewords from Base 900 to Base 10.
*
* @param codewords The array of codewords
* @param count The number of codewords
* @return The decoded string representing the Numeric data.
*/
/*
EXAMPLE
Encode the fifteen digit numeric string 000213298174000
Prefix the numeric string with a 1 and set the initial value of
t = 1 000 213 298 174 000
Calculate codeword 0
d0 = 1 000 213 298 174 000 mod 900 = 200
t = 1 000 213 298 174 000 div 900 = 1 111 348 109 082
Calculate codeword 1
d1 = 1 111 348 109 082 mod 900 = 282
t = 1 111 348 109 082 div 900 = 1 234 831 232
Calculate codeword 2
d2 = 1 234 831 232 mod 900 = 632
t = 1 234 831 232 div 900 = 1 372 034
Calculate codeword 3
d3 = 1 372 034 mod 900 = 434
t = 1 372 034 div 900 = 1 524
Calculate codeword 4
d4 = 1 524 mod 900 = 624
t = 1 524 div 900 = 1
Calculate codeword 5
d5 = 1 mod 900 = 1
t = 1 div 900 = 0
Codeword sequence is: 1, 624, 434, 632, 282, 200
Decode the above codewords involves
1 x 900 power of 5 + 624 x 900 power of 4 + 434 x 900 power of 3 +
632 x 900 power of 2 + 282 x 900 power of 1 + 200 x 900 power of 0 = 1000213298174000
Remove leading 1 => Result is 000213298174000
*/
Ref<String> DecodedBitStreamParser::decodeBase900toBase10(ArrayRef<int> codewords, int count)
{
BigInteger result = BigInteger(0);
for (int i = 0; i < count; i++) {
result = result + (EXP900[count - i - 1] * BigInteger(codewords[i]));
}
string resultString = bigIntegerToString(result);
if (resultString[0] != '1') {
throw FormatException("DecodedBitStreamParser::decodeBase900toBase10: String does not begin with 1");
}
string resultString2;
resultString2.assign(resultString.begin()+1,resultString.end());
Ref<String> res (new String(resultString2));
return res;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/pdf417/decoder/DecodedBitStreamParser2.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 5,320
|
```objective-c
#ifndef __BIT_MATRIX_PARSER__PDF_H__
#define __BIT_MATRIX_PARSER__PDF_H__
/*
* BitMatrixParser.h / PDF417
* zxing
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/ReaderException.h>
#include <zxing/FormatException.h>
#include <zxing/common/BitMatrix.h>
#include <zxing/common/Counted.h>
#include <zxing/common/Array.h>
#include <stdint.h>
namespace zxing {
namespace pdf417 {
namespace decoder {
class BitMatrixParser : public Counted {
private:
static const int MAX_ROWS;
// Maximum Codewords (Data + Error)
static const int MAX_CW_CAPACITY;
static const int MODULES_IN_SYMBOL;
Ref<BitMatrix> bitMatrix_;
int rows_; /* = 0 */
int leftColumnECData_; /* = 0 */
int rightColumnECData_; /* = 0 */
/* added 2012-06-22 HFN */
int aLeftColumnTriple_[3];
int aRightColumnTriple_[3];
int eraseCount_; /* = 0 */
ArrayRef<int> erasures_;
int ecLevel_; /* = -1 */
public:
static const int SYMBOL_TABLE[];
static const int SYMBOL_TABLE_LENGTH;
static const int CODEWORD_TABLE[];
public:
BitMatrixParser(Ref<BitMatrix> bitMatrix);
ArrayRef<int> getErasures() const {return erasures_;}
int getECLevel() const {return ecLevel_;}
int getEraseCount() const {return eraseCount_;}
ArrayRef<int> readCodewords(); /* throw(FormatException) */
static int getCodeword(int64_t symbol, int *pi = NULL);
private:
bool VerifyOuterColumns(int rownumber);
static ArrayRef<int> trimArray(ArrayRef<int> array, int size);
static int findCodewordIndex(int64_t symbol);
int processRow(int rowNumber,
ArrayRef<int> codewords, int next);
int processRow(ArrayRef<int> rowCounters, int rowNumber, int rowHeight,
ArrayRef<int> codewords, int next); /* throw(FormatException) */
protected:
bool IsEqual(int &a, int &b, int rownumber);
};
}
}
}
#endif // __BIT_MATRIX_PARSER__PDF_H__
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/pdf417/decoder/BitMatrixParser.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 538
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
#ifndef __DECODED_BIT_STREAM_PARSER_PD_H__
#define __DECODED_BIT_STREAM_PARSER_PD_H__
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <bigint/BigInteger.hh>
#include <zxing/common/Array.h>
#include <zxing/common/Str.h>
#include <zxing/common/DecoderResult.h>
namespace zxing {
namespace pdf417 {
class DecodedBitStreamParser {
protected:
enum Mode {
ALPHA,
LOWER,
MIXED,
PUNCT,
ALPHA_SHIFT,
PUNCT_SHIFT
};
private:
static const int TEXT_COMPACTION_MODE_LATCH;
static const int BYTE_COMPACTION_MODE_LATCH;
static const int NUMERIC_COMPACTION_MODE_LATCH;
static const int BYTE_COMPACTION_MODE_LATCH_6;
static const int BEGIN_MACRO_PDF417_CONTROL_BLOCK;
static const int BEGIN_MACRO_PDF417_OPTIONAL_FIELD;
static const int MACRO_PDF417_TERMINATOR;
static const int MODE_SHIFT_TO_BYTE_COMPACTION_MODE;
static const int MAX_NUMERIC_CODEWORDS;
static const int PL;
static const int LL;
static const int AS;
static const int ML;
static const int AL;
static const int PS;
static const int PAL;
static const int EXP900_SIZE;
static const char PUNCT_CHARS[];
static const char MIXED_CHARS[];
static ArrayRef<BigInteger> EXP900;
static ArrayRef<BigInteger> initEXP900();
static int textCompaction(ArrayRef<int> codewords, int codeIndex, Ref<String> result);
static void decodeTextCompaction(ArrayRef<int> textCompactionData,
ArrayRef<int> byteCompactionData,
int length,
Ref<String> result);
static int byteCompaction(int mode, ArrayRef<int> codewords, int codeIndex, Ref<String> result);
static int numericCompaction(ArrayRef<int> codewords, int codeIndex, Ref<String> result);
static Ref<String> decodeBase900toBase10(ArrayRef<int> codewords, int count);
public:
DecodedBitStreamParser();
static Ref<DecoderResult> decode(ArrayRef<int> codewords);
};
} /* namespace pdf417 */
} /* namespace zxing */
#endif // __DECODED_BIT_STREAM_PARSER_PD_H__
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/pdf417/decoder/DecodedBitStreamParser.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 546
|
```objective-c
#ifndef __DECOCER_PDF_H__
#define __DECOCER_PDF_H__
/*
* Decoder.h
* zxing
*
* Created by Hartmut Neubauer, 2012-05-25
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/pdf417/decoder/ec/ErrorCorrection.h>
#include <zxing/pdf417/decoder/ec/ModulusGF.h>
#include <zxing/common/Counted.h>
#include <zxing/common/Array.h>
#include <zxing/common/DecoderResult.h>
#include <zxing/common/BitMatrix.h>
namespace zxing {
namespace pdf417 {
namespace decoder {
/**
* <p>The main class which implements PDF417 Code decoding -- as
* opposed to locating and extracting the PDF417 Code from an image.</p>
*
* <p> 2012-06-27 HFN Reed-Solomon error correction activated, see class PDF417RSDecoder. </p>
* <p> 2012-09-19 HFN Reed-Solomon error correction via ErrorCorrection/ModulusGF/ModulusPoly. </p>
*/
class Decoder {
private:
static const int MAX_ERRORS;
static const int MAX_EC_CODEWORDS;
void correctErrors(ArrayRef<int> codewords,
ArrayRef<int> erasures, int numECCodewords);
static void verifyCodewordCount(ArrayRef<int> codewords, int numECCodewords);
public:
Ref<DecoderResult> decode(Ref<BitMatrix> bits, DecodeHints const &hints);
};
}
}
}
#endif // __DECOCER_PDF_H__
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/pdf417/decoder/Decoder.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 374
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
* 2012-06-27 hfn: PDF417 Reed-Solomon error correction, using following Java
* source code:
* path_to_url
*/
#include <zxing/pdf417/PDF417Reader.h>
#include <zxing/pdf417/decoder/Decoder.h>
#include <zxing/pdf417/decoder/BitMatrixParser.h>
#include <zxing/pdf417/decoder/DecodedBitStreamParser.h>
#include <zxing/ReaderException.h>
#include <zxing/common/reedsolomon/ReedSolomonException.h>
using zxing::pdf417::decoder::Decoder;
using zxing::pdf417::decoder::ec::ErrorCorrection;
using zxing::Ref;
using zxing::DecoderResult;
// VC++
using zxing::BitMatrix;
using zxing::DecodeHints;
using zxing::ArrayRef;
const int Decoder::MAX_ERRORS = 3;
const int Decoder::MAX_EC_CODEWORDS = 512;
Ref<DecoderResult> Decoder::decode(Ref<BitMatrix> bits, DecodeHints const& hints) {
(void)hints;
// Construct a parser to read the data codewords and error-correction level
BitMatrixParser parser(bits);
ArrayRef<int> codewords(parser.readCodewords());
if (codewords->size() == 0) {
throw FormatException("PDF:Decoder:decode: cannot read codewords");
}
int ecLevel = parser.getECLevel();
int numECCodewords = 1 << (ecLevel + 1);
ArrayRef<int> erasures = parser.getErasures();
correctErrors(codewords, erasures, numECCodewords);
verifyCodewordCount(codewords, numECCodewords);
// Decode the codewords
return DecodedBitStreamParser::decode(codewords);
}
/**
* Verify that all is OK with the codeword array.
*
* @param codewords
* @return an index to the first data codeword.
* @throws FormatException
*/
void Decoder::verifyCodewordCount(ArrayRef<int> codewords, int numECCodewords) {
int cwsize = codewords->size();
if (cwsize < 4) {
// Codeword array size should be at least 4 allowing for
// Count CW, At least one Data CW, Error Correction CW, Error Correction CW
throw FormatException("PDF:Decoder:verifyCodewordCount: codeword array too small!");
}
// The first codeword, the Symbol Length Descriptor, shall always encode the total number of data
// codewords in the symbol, including the Symbol Length Descriptor itself, data codewords and pad
// codewords, but excluding the number of error correction codewords.
int numberOfCodewords = codewords[0];
if (numberOfCodewords > cwsize) {
throw FormatException("PDF:Decoder:verifyCodewordCount: bad codeword number descriptor!");
}
if (numberOfCodewords == 0) {
// Reset to the length of the array - 8 (Allow for at least level 3 Error Correction (8 Error Codewords)
if (numECCodewords < cwsize) {
codewords[0] = cwsize - numECCodewords;
} else {
throw FormatException("PDF:Decoder:verifyCodewordCount: bad error correction cw number!");
}
}
}
/**
* Correct errors whenever it is possible using Reed-Solomom algorithm
*
* @param codewords, erasures, numECCodewords
* @return 0.
* @throws FormatException
*/
void Decoder::correctErrors(ArrayRef<int> codewords,
ArrayRef<int> erasures, int numECCodewords) {
if (erasures->size() > numECCodewords / 2 + MAX_ERRORS ||
numECCodewords < 0 || numECCodewords > MAX_EC_CODEWORDS) {
throw FormatException("PDF:Decoder:correctErrors: Too many errors or EC Codewords corrupted");
}
Ref<ErrorCorrection> errorCorrection(new ErrorCorrection);
errorCorrection->decode(codewords, numECCodewords, erasures);
// 2012-06-27 HFN if, despite of error correction, there are still codewords with invalid
// value, throw an exception here:
for (int i = 0; i < codewords->size(); i++) {
if (codewords[i]<0) {
throw FormatException("PDF:Decoder:correctErrors: Error correction did not succeed!");
}
}
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/pdf417/decoder/Decoder3.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 1,092
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
* 2012-09-19 HFN translation from Java into C++
*/
#include <zxing/pdf417/decoder/ec/ModulusPoly.h>
#include <zxing/pdf417/decoder/ec/ModulusGF.h>
using zxing::Ref;
using zxing::ArrayRef;
using zxing::pdf417::decoder::ec::ModulusGF;
using zxing::pdf417::decoder::ec::ModulusPoly;
/**
* @author Sean Owen
* @see com.google.zxing.common.reedsolomon.GenericGFPoly
*/
ModulusPoly::ModulusPoly(ModulusGF& field, ArrayRef<int> coefficients)
: field_(field)
{
if (coefficients->size() == 0) {
throw IllegalArgumentException("no coefficients!");
}
int coefficientsLength = coefficients->size();
if (coefficientsLength > 1 && coefficients[0] == 0) {
// Leading term must be non-zero for anything except the constant polynomial "0"
int firstNonZero = 1;
while (firstNonZero < coefficientsLength && coefficients[firstNonZero] == 0) {
firstNonZero++;
}
if (firstNonZero == coefficientsLength) {
coefficientsLength = field_.getZero()->getCoefficients()->size();
coefficients_.reset(new Array<int> (coefficientsLength));
*coefficients_ = *(field_.getZero()->getCoefficients());
} else {
ArrayRef<int> c(coefficients);
coefficientsLength -= firstNonZero;
coefficients_.reset(new Array<int> (coefficientsLength));
for (int i = 0; i < coefficientsLength; i++) {
coefficients_[i] = c[i + firstNonZero];
}
/*
coefficientsLength -= firstNonZero;
coefficients_.reset(new Array<int>(coefficientsLength - firstNonZero));
for (int i = 0; i < coefficientsLength; i++) {
coefficients_[i] = coefficients[i + firstNonZero];
}
*/
}
} else {
coefficients_ = coefficients;
}
}
ArrayRef<int> ModulusPoly::getCoefficients() {
return coefficients_;
}
/**
* @return degree of this polynomial
*/
int ModulusPoly::getDegree() {
return coefficients_->size() - 1;
}
/**
* @return true iff this polynomial is the monomial "0"
*/
bool ModulusPoly::isZero() {
return coefficients_[0] == 0;
}
/**
* @return coefficient of x^degree term in this polynomial
*/
int ModulusPoly::getCoefficient(int degree) {
return coefficients_[coefficients_->size() - 1 - degree];
}
/**
* @return evaluation of this polynomial at a given point
*/
int ModulusPoly::evaluateAt(int a) {
int i;
if (a == 0) {
// Just return the x^0 coefficient
return getCoefficient(0);
}
int size = coefficients_->size();
if (a == 1) {
// Just the sum of the coefficients
int result = 0;
for (i = 0; i < size; i++) {
result = field_.add(result, coefficients_[i]);
}
return result;
}
int result = coefficients_[0];
for (i = 1; i < size; i++) {
result = field_.add(field_.multiply(a, result), coefficients_[i]);
}
return result;
}
Ref<ModulusPoly> ModulusPoly::add(Ref<ModulusPoly> other) {
if (&field_ != &other->field_) {
throw IllegalArgumentException("ModulusPolys do not have same ModulusGF field");
}
if (isZero()) {
return other;
}
if (other->isZero()) {
return Ref<ModulusPoly>(this);
}
ArrayRef<int> smallerCoefficients = coefficients_;
ArrayRef<int> largerCoefficients = other->coefficients_;
if (smallerCoefficients->size() > largerCoefficients->size()) {
ArrayRef<int> temp(smallerCoefficients);
smallerCoefficients = largerCoefficients;
largerCoefficients = temp;
}
ArrayRef<int> sumDiff (new Array<int>(largerCoefficients->size()));
int lengthDiff = largerCoefficients->size() - smallerCoefficients->size();
// Copy high-order terms only found in higher-degree polynomial's coefficients
for (int i = 0; i < lengthDiff; i++) {
sumDiff[i] = largerCoefficients[i];
}
for (int i = lengthDiff; i < largerCoefficients->size(); i++) {
sumDiff[i] = field_.add(smallerCoefficients[i - lengthDiff], largerCoefficients[i]);
}
return Ref<ModulusPoly>(new ModulusPoly(field_, sumDiff));
}
Ref<ModulusPoly> ModulusPoly::subtract(Ref<ModulusPoly> other) {
if (&field_ != &other->field_) {
throw new IllegalArgumentException("ModulusPolys do not have same ModulusGF field");
}
if (other->isZero()) {
return Ref<ModulusPoly>(this);
}
return add(other->negative());
}
Ref<ModulusPoly> ModulusPoly::multiply(Ref<ModulusPoly> other) {
if (&field_ != &other->field_) {
throw new IllegalArgumentException("ModulusPolys do not have same ModulusGF field");
}
if (isZero() || other->isZero()) {
return field_.getZero();
}
int i,j;
ArrayRef<int> aCoefficients = coefficients_;
int aLength = aCoefficients->size();
ArrayRef<int> bCoefficients = other->coefficients_;
int bLength = bCoefficients->size();
ArrayRef<int> product (new Array<int>(aLength + bLength - 1));
for (i = 0; i < aLength; i++) {
int aCoeff = aCoefficients[i];
for (j = 0; j < bLength; j++) {
product[i + j] = field_.add(product[i + j], field_.multiply(aCoeff, bCoefficients[j]));
}
}
return Ref<ModulusPoly>(new ModulusPoly(field_, product));
}
Ref<ModulusPoly> ModulusPoly::negative() {
int size = coefficients_->size();
ArrayRef<int> negativeCoefficients (new Array<int>(size));
for (int i = 0; i < size; i++) {
negativeCoefficients[i] = field_.subtract(0, coefficients_[i]);
}
return Ref<ModulusPoly>(new ModulusPoly(field_, negativeCoefficients));
}
Ref<ModulusPoly> ModulusPoly::multiply(int scalar) {
if (scalar == 0) {
return field_.getZero();
}
if (scalar == 1) {
return Ref<ModulusPoly>(this);
}
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);
}
return Ref<ModulusPoly>(new ModulusPoly(field_, product));
}
Ref<ModulusPoly> ModulusPoly::multiplyByMonomial(int degree, int coefficient) {
if (degree < 0) {
throw new IllegalArgumentException("negative degree!");
}
if (coefficient == 0) {
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);
}
return Ref<ModulusPoly>(new ModulusPoly(field_, product));
}
std::vector<Ref<ModulusPoly> > ModulusPoly::divide(Ref<ModulusPoly> other) {
if (&field_ != &other->field_) {
throw new IllegalArgumentException("ModulusPolys do not have same ModulusGF field");
}
if (other->isZero()) {
throw new IllegalArgumentException("Divide by 0");
}
Ref<ModulusPoly> quotient (field_.getZero());
Ref<ModulusPoly> remainder (this);
int denominatorLeadingTerm = other->getCoefficient(other->getDegree());
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);
Ref<ModulusPoly> term (other->multiplyByMonomial(degreeDifference, scale));
Ref<ModulusPoly> iterationQuotient (field_.buildMonomial(degreeDifference, scale));
quotient = quotient->add(iterationQuotient);
remainder = remainder->subtract(term);
}
std::vector<Ref<ModulusPoly> > result(2);
result[0] = quotient;
result[1] = remainder;
return result;
}
#if 0
@Override
public String toString() {
StringBuilder result = new StringBuilder(8 * getDegree());
for (int degree = getDegree(); degree >= 0; degree--) {
int coefficient = getCoefficient(degree);
if (coefficient != 0) {
if (coefficient < 0) {
result.append(" - ");
coefficient = -coefficient;
} else {
if (result.length() > 0) {
result.append(" + ");
}
}
if (degree == 0 || coefficient != 1) {
result.append(coefficient);
}
if (degree != 0) {
if (degree == 1) {
result.append('x');
} else {
result.append("x^");
result.append(degree);
}
}
}
}
return result.toString();
}
#endif
ModulusPoly::~ModulusPoly() {}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/pdf417/decoder/ec/ModulusPoly.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 2,261
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
* 2012-09-19 HFN translation from Java into C++
*/
#include <zxing/pdf417/decoder/ec/ErrorCorrection.h>
#include <zxing/pdf417/decoder/ec/ModulusPoly.h>
#include <zxing/pdf417/decoder/ec/ModulusGF.h>
using std::vector;
using zxing::Ref;
using zxing::ArrayRef;
using zxing::pdf417::decoder::ec::ErrorCorrection;
using zxing::pdf417::decoder::ec::ModulusPoly;
using zxing::pdf417::decoder::ec::ModulusGF;
/**
* <p>PDF417 error correction implementation.</p>
*
* <p>This <a href="path_to_url#Example">example</a>
* is quite useful in understanding the algorithm.</p>
*
* @author Sean Owen
* @see com.google.zxing.common.reedsolomon.ReedSolomonDecoder
*/
ErrorCorrection::ErrorCorrection()
: field_(ModulusGF::PDF417_GF)
{
}
void ErrorCorrection::decode(ArrayRef<int> received,
int numECCodewords,
ArrayRef<int> erasures)
{
Ref<ModulusPoly> poly (new ModulusPoly(field_, received));
ArrayRef<int> S( new Array<int>(numECCodewords));
bool error = false;
for (int i = numECCodewords; i > 0; i--) {
int eval = poly->evaluateAt(field_.exp(i));
S[numECCodewords - i] = eval;
if (eval != 0) {
error = true;
}
}
if (error) {
Ref<ModulusPoly> knownErrors = field_.getOne();
for (int i=0;i<erasures->size();i++) {
int b = field_.exp(received->size() - 1 - erasures[i]);
// Add (1 - bx) term:
ArrayRef<int> one_minus_b_x(new Array<int>(2));
one_minus_b_x[1]=field_.subtract(0,b);
one_minus_b_x[0]=1;
Ref<ModulusPoly> term (new ModulusPoly(field_,one_minus_b_x));
knownErrors = knownErrors->multiply(term);
}
Ref<ModulusPoly> syndrome (new ModulusPoly(field_, S));
//syndrome = syndrome.multiply(knownErrors);
vector<Ref<ModulusPoly> > sigmaOmega (
runEuclideanAlgorithm(field_.buildMonomial(numECCodewords, 1), syndrome, numECCodewords));
Ref<ModulusPoly> sigma = sigmaOmega[0];
Ref<ModulusPoly> omega = sigmaOmega[1];
//sigma = sigma.multiply(knownErrors);
ArrayRef<int> errorLocations = findErrorLocations(sigma);
ArrayRef<int> errorMagnitudes = findErrorMagnitudes(omega, sigma, errorLocations);
for (int i = 0; i < errorLocations->size(); i++) {
int position = received->size() - 1 - field_.log(errorLocations[i]);
if (position < 0) {
throw ReedSolomonException("Bad error location!");
}
received[position] = field_.subtract(received[position], errorMagnitudes[i]);
#if (defined (DEBUG) && defined _WIN32)
{
WCHAR szmsg[256];
swprintf(szmsg,L"ErrorCorrection::decode: fix @ %d, new value = %d\n",
position, received[position]);
OutputDebugString(szmsg);
}
#endif
}
}
}
vector<Ref<ModulusPoly> > ErrorCorrection::runEuclideanAlgorithm(Ref<ModulusPoly> a, Ref<ModulusPoly> b, int R)
{
// Assume a's degree is >= b's
if (a->getDegree() < b->getDegree()) {
Ref<ModulusPoly> temp = a;
a = b;
b = temp;
}
Ref<ModulusPoly> rLast ( a);
Ref<ModulusPoly> r ( b);
Ref<ModulusPoly> tLast ( field_.getZero());
Ref<ModulusPoly> t ( field_.getOne());
// Run Euclidean algorithm until r's degree is less than R/2
while (r->getDegree() >= R / 2) {
Ref<ModulusPoly> rLastLast (rLast);
Ref<ModulusPoly> tLastLast (tLast);
rLast = r;
tLast = t;
// Divide rLastLast by rLast, with quotient in q and remainder in r
if (rLast->isZero()) {
// Oops, Euclidean algorithm already terminated?
throw ReedSolomonException("Euclidean algorithm already terminated?");
}
r = rLastLast;
Ref<ModulusPoly> q (field_.getZero());
int denominatorLeadingTerm = rLast->getCoefficient(rLast->getDegree());
int dltInverse = field_.inverse(denominatorLeadingTerm);
while (r->getDegree() >= rLast->getDegree() && !r->isZero()) {
int degreeDiff = r->getDegree() - rLast->getDegree();
int scale = field_.multiply(r->getCoefficient(r->getDegree()), dltInverse);
q = q->add(field_.buildMonomial(degreeDiff, scale));
r = r->subtract(rLast->multiplyByMonomial(degreeDiff, scale));
}
t = q->multiply(tLast)->subtract(tLastLast)->negative();
}
int sigmaTildeAtZero = t->getCoefficient(0);
if (sigmaTildeAtZero == 0) {
throw ReedSolomonException("sigmaTilde = 0!");
}
int inverse = field_.inverse(sigmaTildeAtZero);
Ref<ModulusPoly> sigma (t->multiply(inverse));
Ref<ModulusPoly> omega (r->multiply(inverse));
vector<Ref<ModulusPoly> > v(2);
v[0] = sigma;
v[1] = omega;
return v;
}
ArrayRef<int> ErrorCorrection::findErrorLocations(Ref<ModulusPoly> errorLocator) {
// This is a direct application of Chien's search
int numErrors = errorLocator->getDegree();
ArrayRef<int> result( new Array<int>(numErrors));
int e = 0;
for (int i = 1; i < field_.getSize() && e < numErrors; i++) {
if (errorLocator->evaluateAt(i) == 0) {
result[e] = field_.inverse(i);
e++;
}
}
if (e != numErrors) {
#if (defined (DEBUG) && defined _WIN32)
char sz[128];
sprintf(sz,"Error number inconsistency, %d/%d!",e,numErrors);
throw ReedSolomonException(sz);
#else
throw ReedSolomonException("Error number inconsistency!");
#endif
}
#if (defined (DEBUG) && defined _WIN32)
{
WCHAR szmsg[256];
swprintf(szmsg,L"ErrorCorrection::findErrorLocations: found %d errors.\n",
e);
OutputDebugString(szmsg);
}
#endif
return result;
}
ArrayRef<int> ErrorCorrection::findErrorMagnitudes(Ref<ModulusPoly> errorEvaluator,
Ref<ModulusPoly> errorLocator,
ArrayRef<int> errorLocations) {
int i;
int errorLocatorDegree = errorLocator->getDegree();
ArrayRef<int> formalDerivativeCoefficients (new Array<int>(errorLocatorDegree));
for (i = 1; i <= errorLocatorDegree; i++) {
formalDerivativeCoefficients[errorLocatorDegree - i] =
field_.multiply(i, errorLocator->getCoefficient(i));
}
Ref<ModulusPoly> formalDerivative (new ModulusPoly(field_, formalDerivativeCoefficients));
// This is directly applying Forney's Formula
int s = errorLocations->size();
ArrayRef<int> result ( new Array<int>(s));
for (i = 0; i < s; i++) {
int xiInverse = field_.inverse(errorLocations[i]);
int numerator = field_.subtract(0, errorEvaluator->evaluateAt(xiInverse));
int denominator = field_.inverse(formalDerivative->evaluateAt(xiInverse));
result[i] = field_.multiply(numerator, denominator);
}
return result;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/pdf417/decoder/ec/ErrorCorrection.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 1,901
|
```objective-c
#ifndef __MODULUS_GFPOLY_PDF_H__
#define __MODULUS_GFPOLY_PDF_H__
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
* 2012-09-17 HFN translation from Java into C++
*/
#include <zxing/common/Counted.h>
#include <zxing/common/Array.h>
#include <zxing/common/DecoderResult.h>
#include <zxing/common/BitMatrix.h>
namespace zxing {
namespace pdf417 {
namespace decoder {
namespace ec {
class ModulusGF;
/**
* @author Sean Owen
* @see com.google.zxing.common.reedsolomon.GenericGFPoly
*/
class ModulusPoly: public Counted {
private:
ModulusGF &field_;
ArrayRef<int> coefficients_;
public:
ModulusPoly(ModulusGF& field, ArrayRef<int> coefficients);
~ModulusPoly();
ArrayRef<int> getCoefficients();
int getDegree();
bool isZero();
int getCoefficient(int degree);
int evaluateAt(int a);
Ref<ModulusPoly> add(Ref<ModulusPoly> other);
Ref<ModulusPoly> subtract(Ref<ModulusPoly> other);
Ref<ModulusPoly> multiply(Ref<ModulusPoly> other);
Ref<ModulusPoly> negative();
Ref<ModulusPoly> multiply(int scalar);
Ref<ModulusPoly> multiplyByMonomial(int degree, int coefficient);
std::vector<Ref<ModulusPoly> > divide(Ref<ModulusPoly> other);
#if 0
public String toString();
#endif
};
}
}
}
}
#endif /* __MODULUS_GFPOLY_PDF_H__ */
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/pdf417/decoder/ec/ModulusPoly.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 387
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
* 2012-09-19 HFN translation from Java into C++
*/
#include <zxing/pdf417/decoder/ec/ModulusGF.h>
#include <zxing/pdf417/decoder/ec/ModulusPoly.h>
using zxing::Ref;
using zxing::pdf417::decoder::ec::ModulusGF;
using zxing::pdf417::decoder::ec::ModulusPoly;
/**
* The central Modulus Galois Field for PDF417 with prime number 929
* and generator 3.
*/
ModulusGF ModulusGF::PDF417_GF(929,3);
/**
* <p>A field based on powers of a generator integer, modulo some modulus.</p>
*
* @author Sean Owen
* @see com.google.zxing.common.reedsolomon.GenericGF
*/
ModulusGF::ModulusGF(int modulus, int generator)
: modulus_(modulus) {
expTable_ = new Array<int>(modulus_);
logTable_ = new Array<int>(modulus_);
int x = 1,i;
for (i = 0; i < modulus_; i++) {
expTable_[i] = x;
x = (x * generator) % modulus_;
}
for (i = 0; i < modulus_-1; i++) {
logTable_[expTable_[i]] = i;
}
// logTable[0] == 0 but this should never be used
ArrayRef<int>aZero(new Array<int>(1)),aOne(new Array<int>(1));
aZero[0]=0;aOne[0]=1;
zero_ = new ModulusPoly(*this, aZero);
one_ = new ModulusPoly(*this, aOne);
}
Ref<ModulusPoly> ModulusGF::getZero() {
return zero_;
}
Ref<ModulusPoly> ModulusGF::getOne() {
return one_;
}
Ref<ModulusPoly> ModulusGF::buildMonomial(int degree, int coefficient)
{
if (degree < 0) {
throw IllegalArgumentException("monomial: degree < 0!");
}
if (coefficient == 0) {
return zero_;
}
int nCoefficients = degree + 1;
ArrayRef<int> coefficients (new Array<int>(nCoefficients));
coefficients[0] = coefficient;
Ref<ModulusPoly> result(new ModulusPoly(*this,coefficients));
return result;
}
int ModulusGF::add(int a, int b) {
return (a + b) % modulus_;
}
int ModulusGF::subtract(int a, int b) {
return (modulus_ + a - b) % modulus_;
}
int ModulusGF::exp(int a) {
return expTable_[a];
}
int ModulusGF::log(int a) {
if (a == 0) {
throw IllegalArgumentException("log of zero!");
}
return logTable_[a];
}
int ModulusGF::inverse(int a) {
if (a == 0) {
throw IllegalArgumentException("inverse of zero!");;
}
return expTable_[modulus_ - logTable_[a] - 1];
}
int ModulusGF::multiply(int a, int b) {
if (a == 0 || b == 0) {
return 0;
}
return expTable_[(logTable_[a] + logTable_[b]) % (modulus_ - 1)];
}
int ModulusGF::getSize() {
return modulus_;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/pdf417/decoder/ec/ModulusGF.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 810
|
```objective-c
#ifndef __MODULUS_GF_PDF_H__
#define __MODULUS_GF_PDF_H__
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
* 2012-09-17 HFN translation from Java into C++
*/
#include <zxing/common/Counted.h>
#include <zxing/common/Array.h>
#include <zxing/common/DecoderResult.h>
#include <zxing/common/BitMatrix.h>
namespace zxing {
namespace pdf417 {
namespace decoder {
namespace ec {
class ModulusPoly;
/**
* <p>A field based on powers of a generator integer, modulo some modulus.</p>
*
* @author Sean Owen
* @see com.google.zxing.common.reedsolomon.GenericGF
*/
class ModulusGF {
public:
static ModulusGF PDF417_GF;
private:
ArrayRef<int> expTable_;
ArrayRef<int> logTable_;
Ref<ModulusPoly> zero_;
Ref<ModulusPoly> one_;
int modulus_;
public:
ModulusGF(int modulus, int generator);
Ref<ModulusPoly> getZero();
Ref<ModulusPoly> getOne();
Ref<ModulusPoly> buildMonomial(int degree, int coefficient);
int add(int a, int b);
int subtract(int a, int b);
int exp(int a);
int log(int a);
int inverse(int a);
int multiply(int a, int b);
int getSize();
};
}
}
}
}
#endif /* __MODULUS_GF_PDF_H__ */
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/pdf417/decoder/ec/ModulusGF.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 342
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
#ifndef __ERROR_CORRECTION_PDF_H__
#define __ERROR_CORRECTION_PDF_H__
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
* 2012-09-17 HFN translation from Java into C++
*/
#include <zxing/common/Counted.h>
#include <zxing/common/Array.h>
#include <zxing/common/DecoderResult.h>
#include <zxing/common/BitMatrix.h>
#include <zxing/pdf417/decoder/ec/ModulusGF.h>
#include <zxing/pdf417/decoder/ec/ModulusPoly.h>
#include <zxing/common/reedsolomon/ReedSolomonException.h>
namespace zxing {
namespace pdf417 {
namespace decoder {
namespace ec {
/**
* <p>PDF417 error correction implementation.</p>
*
* <p>This <a href="path_to_url#Example">example</a>
* is quite useful in understanding the algorithm.</p>
*
* @author Sean Owen
* @see com.google.zxing.common.reedsolomon.ReedSolomonDecoder
*/
class ErrorCorrection: public Counted {
private:
ModulusGF &field_;
public:
ErrorCorrection();
void decode(ArrayRef<int> received,
int numECCodewords,
ArrayRef<int> erasures);
private:
std::vector<Ref<ModulusPoly> > runEuclideanAlgorithm(Ref<ModulusPoly> a, Ref<ModulusPoly> b, int R);
ArrayRef<int> findErrorLocations(Ref<ModulusPoly> errorLocator);
ArrayRef<int> findErrorMagnitudes(Ref<ModulusPoly> errorEvaluator,
Ref<ModulusPoly> errorLocator,
ArrayRef<int> errorLocations);
};
}
}
}
}
#endif /* __ERROR_CORRECTION_PDF_H__ */
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/pdf417/decoder/ec/ErrorCorrection.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 426
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
* Modified by Hartmut Neubauer (HFN)
*
* 2012-06-27 HFN plausibility checks of outer columns and modulus-3 conditions
* of rows added.
* 2012-09-?? HFN because the Detector now counts the rows, there is no more
* need to check the equality of consecutive rows. All rows are
* parsed now.
*/
#include <zxing/pdf417/decoder/BitMatrixParser.h>
using zxing::pdf417::decoder::BitMatrixParser;
using zxing::ArrayRef;
// VC++
using zxing::Ref;
using zxing::BitMatrix;
const int BitMatrixParser::MAX_ROWS = 90;
// Maximum Codewords (Data + Error)
const int BitMatrixParser::MAX_CW_CAPACITY = 929;
const int BitMatrixParser::MODULES_IN_SYMBOL = 17;
BitMatrixParser::BitMatrixParser(Ref<BitMatrix> bitMatrix)
: bitMatrix_(bitMatrix)
{
rows_ = 0;
leftColumnECData_ = 0;
rightColumnECData_ = 0;
for (int i = 0; i < 3; i++) {
aLeftColumnTriple_[i]=0;
aRightColumnTriple_[i]=0;
}
eraseCount_ = 0;
ecLevel_ = -1;
}
/**
* To ensure separability of rows, codewords of consecutive rows belong to
* different subsets of all possible codewords. This routine scans the
* symbols in the barcode. When it finds a number of consecutive rows which
* are the same, it assumes that this is a row of codewords and processes
* them into a codeword array.
*
* 2012-09-12 HFN: Because now, at an earlier stage, the Detector has counted
* the rows, now it is no more necessary to check the equality of consecutive
* rows. We now have to check every row.
*
* @return an array of codewords.
* @throw FormatException for example if number of rows is too big or something
* with row processing is bad
*/
ArrayRef<int> BitMatrixParser::readCodewords()
{
//int width = bitMatrix_->getWidth();
int height = bitMatrix_->getHeight();
erasures_ = new Array<int>(MAX_CW_CAPACITY);
ArrayRef<int> codewords (new Array<int>(MAX_CW_CAPACITY));
int next = 0;
int rowNumber = 0;
for (int i = 0; i < height; i++) {
if (rowNumber >= MAX_ROWS) {
// Something is wrong, since we have exceeded
// the maximum rows in the specification.
throw FormatException("BitMatrixParser::readCodewords(PDF): Too many rows!");
}
// Process Row
next = processRow(rowNumber, codewords, next);
rowNumber++;
}
erasures_ = trimArray(erasures_, eraseCount_);
return trimArray(codewords, next);
}
/**
* Convert the symbols in the row to codewords.
* Each PDF417 symbol character consists of four bar elements and four space
* elements, each of which can be one to six modules wide. The four bar and
* four space elements shall measure 17 modules in total.
*
* @param rowNumber the current row number of codewords.
* @param codewords the codeword array to save codewords into.
* @param next the next available index into the codewords array.
* @return the next available index into the codeword array after processing
* this row.
*/
int BitMatrixParser::processRow(int rowNumber, ArrayRef<int> codewords, int next) {
int width = bitMatrix_->getWidth();
int columnNumber = 0;
int cwClusterNumber = -1;
int64_t symbol = 0;
for (int i = 0; i < width; i += MODULES_IN_SYMBOL) {
for (int mask = MODULES_IN_SYMBOL - 1; mask >= 0; mask--) {
if (bitMatrix_->get(i + (MODULES_IN_SYMBOL - 1 - mask), rowNumber)) {
symbol |= int64_t(1) << mask;
}
}
if (columnNumber > 0) {
cwClusterNumber = -1;
int cw = getCodeword(symbol,&cwClusterNumber);
// 2012-06-27 HFN: cwClusterNumber should be the modulus of the row number by 3; otherwise,
// handle the codeword as erasure:
if ((cwClusterNumber >= 0) && (cwClusterNumber != rowNumber % 3)) {
cw = -1;
}
if (cw < 0 && i < width - MODULES_IN_SYMBOL) {
// Skip errors on the Right row indicator column
if (eraseCount_ >= (int)erasures_->size()) {
throw FormatException("BitMatrixParser::processRow(PDF417): eraseCount too big!");
}
erasures_[eraseCount_] = next;
next++;
eraseCount_++;
} else {
if (next >= codewords->size()) {
throw FormatException("BitMatrixParser::processRow(PDF417): codewords index out of bound.");
}
codewords[next++] = cw;
}
} else {
// Left row indicator column
cwClusterNumber = -1;
int cw = getCodeword(symbol,&cwClusterNumber);
aLeftColumnTriple_[rowNumber % 3] = cw; /* added 2012-06-22 hfn */
if (ecLevel_ < 0 && rowNumber % 3 == 1) {
leftColumnECData_ = cw;
}
}
symbol = 0;
columnNumber++;
}
if (columnNumber > 1) {
// Right row indicator column is in codeword[next]
// Overwrite the last codeword i.e. Right Row Indicator
--next;
aRightColumnTriple_[rowNumber % 3] = codewords[next]; /* added 2012-06-22 hfn */
if (rowNumber % 3 == 2) {
if (ecLevel_ < 0) {
rightColumnECData_ = codewords[next];
if (rightColumnECData_ == leftColumnECData_ && (int)leftColumnECData_ > 0) { /* leftColumnECData_ != 0 */
ecLevel_ = ((rightColumnECData_ % 30) - rows_ % 3) / 3;
}
}
// 2012-06-22 hfn: verify whether outer columns are still okay:
if (!VerifyOuterColumns(rowNumber)) {
throw FormatException("BitMatrixParser::processRow(PDF417): outer columns corrupted!");
}
}
codewords[next] = 0;
}
return next;
}
/* Static methods. */
/**
* Trim the array to the required size.
*
* @param array the array
* @param size the size to trim it to
* @return the new trimmed array
*/
ArrayRef<int> BitMatrixParser::trimArray(ArrayRef<int> array, int size)
{
if (size < 0) {
throw IllegalArgumentException("BitMatrixParser::trimArray: negative size!");
}
// 2012-10-12 hfn don't throw "NoErrorException" when size == 0
ArrayRef<int> a = new Array<int>(size);
for (int i = 0; i < size; i++) {
a[i] = array[i];
}
return a;
}
/**
* Translate the symbol into a codeword.
*
* @param symbol
* @return the codeword corresponding to the symbol.
*/
/**
* 2012-06-27 hfn With the second argument, it is possible to verify in which of the three
* "blocks" of the codeword table the codeword has been found: 0, 1 or 2.
*/
int BitMatrixParser::getCodeword(int64_t symbol, int *pi)
{
int64_t sym = symbol & 0x3FFFF;
int i = findCodewordIndex(sym);
if (i == -1) {
return -1;
} else {
int cw = CODEWORD_TABLE[i] - 1;
if (pi!= NULL) {
*pi = cw / 929;
}
cw %= 929;
return cw;
}
}
/**
* Use a binary search to find the index of the codeword corresponding to
* this symbol.
*
* @param symbol the symbol from the barcode.
* @return the index into the codeword table.
*/
int BitMatrixParser::findCodewordIndex(int64_t symbol)
{
int first = 0;
int upto = SYMBOL_TABLE_LENGTH;
while (first < upto) {
int mid = ((unsigned int)(first + upto)) >> 1; // Compute mid point.
if (symbol < SYMBOL_TABLE[mid]) {
upto = mid; // repeat search in bottom half.
} else if (symbol > SYMBOL_TABLE[mid]) {
first = mid + 1; // Repeat search in top half.
} else {
return mid; // Found it. return position
}
}
return -1;
}
/*
* 2012-06-22 hfn additional verification of outer columns
*/
bool BitMatrixParser::VerifyOuterColumns(int rownumber)
{
return IsEqual(aLeftColumnTriple_[0], aRightColumnTriple_[1], rownumber)
&& IsEqual(aLeftColumnTriple_[1], aRightColumnTriple_[2], rownumber)
&& IsEqual(aLeftColumnTriple_[2], aRightColumnTriple_[0], rownumber);
}
/*
* Verifies whether two codewords are equal or at least one of the codewords has not
* been recognized.
*/
bool BitMatrixParser::IsEqual(int &a, int &b, int rownumber)
{
int ret = (a == b) || (a == -1) || (b == -1);
if (!ret) {
int row3 = rownumber / 3;
int row30 = row3 * 30;
int row59 = row30 + 29;
if (a < row30 || a > row59) {
a = -1;
}
if (b < row30 || b > row59) {
b = -1;
}
}
return true;
}
const int BitMatrixParser::SYMBOL_TABLE[] =
{
0x1025e, 0x1027a, 0x1029e,
0x102bc, 0x102f2, 0x102f4, 0x1032e, 0x1034e, 0x1035c, 0x10396,
0x103a6, 0x103ac, 0x10422, 0x10428, 0x10436, 0x10442, 0x10444,
0x10448, 0x10450, 0x1045e, 0x10466, 0x1046c, 0x1047a, 0x10482,
0x1049e, 0x104a0, 0x104bc, 0x104c6, 0x104d8, 0x104ee, 0x104f2,
0x104f4, 0x10504, 0x10508, 0x10510, 0x1051e, 0x10520, 0x1053c,
0x10540, 0x10578, 0x10586, 0x1058c, 0x10598, 0x105b0, 0x105be,
0x105ce, 0x105dc, 0x105e2, 0x105e4, 0x105e8, 0x105f6, 0x1062e,
0x1064e, 0x1065c, 0x1068e, 0x1069c, 0x106b8, 0x106de, 0x106fa,
0x10716, 0x10726, 0x1072c, 0x10746, 0x1074c, 0x10758, 0x1076e,
0x10792, 0x10794, 0x107a2, 0x107a4, 0x107a8, 0x107b6, 0x10822,
0x10828, 0x10842, 0x10848, 0x10850, 0x1085e, 0x10866, 0x1086c,
0x1087a, 0x10882, 0x10884, 0x10890, 0x1089e, 0x108a0, 0x108bc,
0x108c6, 0x108cc, 0x108d8, 0x108ee, 0x108f2, 0x108f4, 0x10902,
0x10908, 0x1091e, 0x10920, 0x1093c, 0x10940, 0x10978, 0x10986,
0x10998, 0x109b0, 0x109be, 0x109ce, 0x109dc, 0x109e2, 0x109e4,
0x109e8, 0x109f6, 0x10a08, 0x10a10, 0x10a1e, 0x10a20, 0x10a3c,
0x10a40, 0x10a78, 0x10af0, 0x10b06, 0x10b0c, 0x10b18, 0x10b30,
0x10b3e, 0x10b60, 0x10b7c, 0x10b8e, 0x10b9c, 0x10bb8, 0x10bc2,
0x10bc4, 0x10bc8, 0x10bd0, 0x10bde, 0x10be6, 0x10bec, 0x10c2e,
0x10c4e, 0x10c5c, 0x10c62, 0x10c64, 0x10c68, 0x10c76, 0x10c8e,
0x10c9c, 0x10cb8, 0x10cc2, 0x10cc4, 0x10cc8, 0x10cd0, 0x10cde,
0x10ce6, 0x10cec, 0x10cfa, 0x10d0e, 0x10d1c, 0x10d38, 0x10d70,
0x10d7e, 0x10d82, 0x10d84, 0x10d88, 0x10d90, 0x10d9e, 0x10da0,
0x10dbc, 0x10dc6, 0x10dcc, 0x10dd8, 0x10dee, 0x10df2, 0x10df4,
0x10e16, 0x10e26, 0x10e2c, 0x10e46, 0x10e58, 0x10e6e, 0x10e86,
0x10e8c, 0x10e98, 0x10eb0, 0x10ebe, 0x10ece, 0x10edc, 0x10f0a,
0x10f12, 0x10f14, 0x10f22, 0x10f28, 0x10f36, 0x10f42, 0x10f44,
0x10f48, 0x10f50, 0x10f5e, 0x10f66, 0x10f6c, 0x10fb2, 0x10fb4,
0x11022, 0x11028, 0x11042, 0x11048, 0x11050, 0x1105e, 0x1107a,
0x11082, 0x11084, 0x11090, 0x1109e, 0x110a0, 0x110bc, 0x110c6,
0x110cc, 0x110d8, 0x110ee, 0x110f2, 0x110f4, 0x11102, 0x1111e,
0x11120, 0x1113c, 0x11140, 0x11178, 0x11186, 0x11198, 0x111b0,
0x111be, 0x111ce, 0x111dc, 0x111e2, 0x111e4, 0x111e8, 0x111f6,
0x11208, 0x1121e, 0x11220, 0x11278, 0x112f0, 0x1130c, 0x11330,
0x1133e, 0x11360, 0x1137c, 0x1138e, 0x1139c, 0x113b8, 0x113c2,
0x113c8, 0x113d0, 0x113de, 0x113e6, 0x113ec, 0x11408, 0x11410,
0x1141e, 0x11420, 0x1143c, 0x11440, 0x11478, 0x114f0, 0x115e0,
0x1160c, 0x11618, 0x11630, 0x1163e, 0x11660, 0x1167c, 0x116c0,
0x116f8, 0x1171c, 0x11738, 0x11770, 0x1177e, 0x11782, 0x11784,
0x11788, 0x11790, 0x1179e, 0x117a0, 0x117bc, 0x117c6, 0x117cc,
0x117d8, 0x117ee, 0x1182e, 0x11834, 0x1184e, 0x1185c, 0x11862,
0x11864, 0x11868, 0x11876, 0x1188e, 0x1189c, 0x118b8, 0x118c2,
0x118c8, 0x118d0, 0x118de, 0x118e6, 0x118ec, 0x118fa, 0x1190e,
0x1191c, 0x11938, 0x11970, 0x1197e, 0x11982, 0x11984, 0x11990,
0x1199e, 0x119a0, 0x119bc, 0x119c6, 0x119cc, 0x119d8, 0x119ee,
0x119f2, 0x119f4, 0x11a0e, 0x11a1c, 0x11a38, 0x11a70, 0x11a7e,
0x11ae0, 0x11afc, 0x11b08, 0x11b10, 0x11b1e, 0x11b20, 0x11b3c,
0x11b40, 0x11b78, 0x11b8c, 0x11b98, 0x11bb0, 0x11bbe, 0x11bce,
0x11bdc, 0x11be2, 0x11be4, 0x11be8, 0x11bf6, 0x11c16, 0x11c26,
0x11c2c, 0x11c46, 0x11c4c, 0x11c58, 0x11c6e, 0x11c86, 0x11c98,
0x11cb0, 0x11cbe, 0x11cce, 0x11cdc, 0x11ce2, 0x11ce4, 0x11ce8,
0x11cf6, 0x11d06, 0x11d0c, 0x11d18, 0x11d30, 0x11d3e, 0x11d60,
0x11d7c, 0x11d8e, 0x11d9c, 0x11db8, 0x11dc4, 0x11dc8, 0x11dd0,
0x11dde, 0x11de6, 0x11dec, 0x11dfa, 0x11e0a, 0x11e12, 0x11e14,
0x11e22, 0x11e24, 0x11e28, 0x11e36, 0x11e42, 0x11e44, 0x11e50,
0x11e5e, 0x11e66, 0x11e6c, 0x11e82, 0x11e84, 0x11e88, 0x11e90,
0x11e9e, 0x11ea0, 0x11ebc, 0x11ec6, 0x11ecc, 0x11ed8, 0x11eee,
0x11f1a, 0x11f2e, 0x11f32, 0x11f34, 0x11f4e, 0x11f5c, 0x11f62,
0x11f64, 0x11f68, 0x11f76, 0x12048, 0x1205e, 0x12082, 0x12084,
0x12090, 0x1209e, 0x120a0, 0x120bc, 0x120d8, 0x120f2, 0x120f4,
0x12108, 0x1211e, 0x12120, 0x1213c, 0x12140, 0x12178, 0x12186,
0x12198, 0x121b0, 0x121be, 0x121e2, 0x121e4, 0x121e8, 0x121f6,
0x12204, 0x12210, 0x1221e, 0x12220, 0x12278, 0x122f0, 0x12306,
0x1230c, 0x12330, 0x1233e, 0x12360, 0x1237c, 0x1238e, 0x1239c,
0x123b8, 0x123c2, 0x123c8, 0x123d0, 0x123e6, 0x123ec, 0x1241e,
0x12420, 0x1243c, 0x124f0, 0x125e0, 0x12618, 0x1263e, 0x12660,
0x1267c, 0x126c0, 0x126f8, 0x12738, 0x12770, 0x1277e, 0x12782,
0x12784, 0x12790, 0x1279e, 0x127a0, 0x127bc, 0x127c6, 0x127cc,
0x127d8, 0x127ee, 0x12820, 0x1283c, 0x12840, 0x12878, 0x128f0,
0x129e0, 0x12bc0, 0x12c18, 0x12c30, 0x12c3e, 0x12c60, 0x12c7c,
0x12cc0, 0x12cf8, 0x12df0, 0x12e1c, 0x12e38, 0x12e70, 0x12e7e,
0x12ee0, 0x12efc, 0x12f04, 0x12f08, 0x12f10, 0x12f20, 0x12f3c,
0x12f40, 0x12f78, 0x12f86, 0x12f8c, 0x12f98, 0x12fb0, 0x12fbe,
0x12fce, 0x12fdc, 0x1302e, 0x1304e, 0x1305c, 0x13062, 0x13068,
0x1308e, 0x1309c, 0x130b8, 0x130c2, 0x130c8, 0x130d0, 0x130de,
0x130ec, 0x130fa, 0x1310e, 0x13138, 0x13170, 0x1317e, 0x13182,
0x13184, 0x13190, 0x1319e, 0x131a0, 0x131bc, 0x131c6, 0x131cc,
0x131d8, 0x131f2, 0x131f4, 0x1320e, 0x1321c, 0x13270, 0x1327e,
0x132e0, 0x132fc, 0x13308, 0x1331e, 0x13320, 0x1333c, 0x13340,
0x13378, 0x13386, 0x13398, 0x133b0, 0x133be, 0x133ce, 0x133dc,
0x133e2, 0x133e4, 0x133e8, 0x133f6, 0x1340e, 0x1341c, 0x13438,
0x13470, 0x1347e, 0x134e0, 0x134fc, 0x135c0, 0x135f8, 0x13608,
0x13610, 0x1361e, 0x13620, 0x1363c, 0x13640, 0x13678, 0x136f0,
0x1370c, 0x13718, 0x13730, 0x1373e, 0x13760, 0x1377c, 0x1379c,
0x137b8, 0x137c2, 0x137c4, 0x137c8, 0x137d0, 0x137de, 0x137e6,
0x137ec, 0x13816, 0x13826, 0x1382c, 0x13846, 0x1384c, 0x13858,
0x1386e, 0x13874, 0x13886, 0x13898, 0x138b0, 0x138be, 0x138ce,
0x138dc, 0x138e2, 0x138e4, 0x138e8, 0x13906, 0x1390c, 0x13930,
0x1393e, 0x13960, 0x1397c, 0x1398e, 0x1399c, 0x139b8, 0x139c8,
0x139d0, 0x139de, 0x139e6, 0x139ec, 0x139fa, 0x13a06, 0x13a0c,
0x13a18, 0x13a30, 0x13a3e, 0x13a60, 0x13a7c, 0x13ac0, 0x13af8,
0x13b0e, 0x13b1c, 0x13b38, 0x13b70, 0x13b7e, 0x13b88, 0x13b90,
0x13b9e, 0x13ba0, 0x13bbc, 0x13bcc, 0x13bd8, 0x13bee, 0x13bf2,
0x13bf4, 0x13c12, 0x13c14, 0x13c22, 0x13c24, 0x13c28, 0x13c36,
0x13c42, 0x13c48, 0x13c50, 0x13c5e, 0x13c66, 0x13c6c, 0x13c82,
0x13c84, 0x13c90, 0x13c9e, 0x13ca0, 0x13cbc, 0x13cc6, 0x13ccc,
0x13cd8, 0x13cee, 0x13d02, 0x13d04, 0x13d08, 0x13d10, 0x13d1e,
0x13d20, 0x13d3c, 0x13d40, 0x13d78, 0x13d86, 0x13d8c, 0x13d98,
0x13db0, 0x13dbe, 0x13dce, 0x13ddc, 0x13de4, 0x13de8, 0x13df6,
0x13e1a, 0x13e2e, 0x13e32, 0x13e34, 0x13e4e, 0x13e5c, 0x13e62,
0x13e64, 0x13e68, 0x13e76, 0x13e8e, 0x13e9c, 0x13eb8, 0x13ec2,
0x13ec4, 0x13ec8, 0x13ed0, 0x13ede, 0x13ee6, 0x13eec, 0x13f26,
0x13f2c, 0x13f3a, 0x13f46, 0x13f4c, 0x13f58, 0x13f6e, 0x13f72,
0x13f74, 0x14082, 0x1409e, 0x140a0, 0x140bc, 0x14104, 0x14108,
0x14110, 0x1411e, 0x14120, 0x1413c, 0x14140, 0x14178, 0x1418c,
0x14198, 0x141b0, 0x141be, 0x141e2, 0x141e4, 0x141e8, 0x14208,
0x14210, 0x1421e, 0x14220, 0x1423c, 0x14240, 0x14278, 0x142f0,
0x14306, 0x1430c, 0x14318, 0x14330, 0x1433e, 0x14360, 0x1437c,
0x1438e, 0x143c2, 0x143c4, 0x143c8, 0x143d0, 0x143e6, 0x143ec,
0x14408, 0x14410, 0x1441e, 0x14420, 0x1443c, 0x14440, 0x14478,
0x144f0, 0x145e0, 0x1460c, 0x14618, 0x14630, 0x1463e, 0x14660,
0x1467c, 0x146c0, 0x146f8, 0x1471c, 0x14738, 0x14770, 0x1477e,
0x14782, 0x14784, 0x14788, 0x14790, 0x147a0, 0x147bc, 0x147c6,
0x147cc, 0x147d8, 0x147ee, 0x14810, 0x14820, 0x1483c, 0x14840,
0x14878, 0x148f0, 0x149e0, 0x14bc0, 0x14c30, 0x14c3e, 0x14c60,
0x14c7c, 0x14cc0, 0x14cf8, 0x14df0, 0x14e38, 0x14e70, 0x14e7e,
0x14ee0, 0x14efc, 0x14f04, 0x14f08, 0x14f10, 0x14f1e, 0x14f20,
0x14f3c, 0x14f40, 0x14f78, 0x14f86, 0x14f8c, 0x14f98, 0x14fb0,
0x14fce, 0x14fdc, 0x15020, 0x15040, 0x15078, 0x150f0, 0x151e0,
0x153c0, 0x15860, 0x1587c, 0x158c0, 0x158f8, 0x159f0, 0x15be0,
0x15c70, 0x15c7e, 0x15ce0, 0x15cfc, 0x15dc0, 0x15df8, 0x15e08,
0x15e10, 0x15e20, 0x15e40, 0x15e78, 0x15ef0, 0x15f0c, 0x15f18,
0x15f30, 0x15f60, 0x15f7c, 0x15f8e, 0x15f9c, 0x15fb8, 0x1604e,
0x1605c, 0x1608e, 0x1609c, 0x160b8, 0x160c2, 0x160c4, 0x160c8,
0x160de, 0x1610e, 0x1611c, 0x16138, 0x16170, 0x1617e, 0x16184,
0x16188, 0x16190, 0x1619e, 0x161a0, 0x161bc, 0x161c6, 0x161cc,
0x161d8, 0x161f2, 0x161f4, 0x1620e, 0x1621c, 0x16238, 0x16270,
0x1627e, 0x162e0, 0x162fc, 0x16304, 0x16308, 0x16310, 0x1631e,
0x16320, 0x1633c, 0x16340, 0x16378, 0x16386, 0x1638c, 0x16398,
0x163b0, 0x163be, 0x163ce, 0x163dc, 0x163e2, 0x163e4, 0x163e8,
0x163f6, 0x1640e, 0x1641c, 0x16438, 0x16470, 0x1647e, 0x164e0,
0x164fc, 0x165c0, 0x165f8, 0x16610, 0x1661e, 0x16620, 0x1663c,
0x16640, 0x16678, 0x166f0, 0x16718, 0x16730, 0x1673e, 0x16760,
0x1677c, 0x1678e, 0x1679c, 0x167b8, 0x167c2, 0x167c4, 0x167c8,
0x167d0, 0x167de, 0x167e6, 0x167ec, 0x1681c, 0x16838, 0x16870,
0x168e0, 0x168fc, 0x169c0, 0x169f8, 0x16bf0, 0x16c10, 0x16c1e,
0x16c20, 0x16c3c, 0x16c40, 0x16c78, 0x16cf0, 0x16de0, 0x16e18,
0x16e30, 0x16e3e, 0x16e60, 0x16e7c, 0x16ec0, 0x16ef8, 0x16f1c,
0x16f38, 0x16f70, 0x16f7e, 0x16f84, 0x16f88, 0x16f90, 0x16f9e,
0x16fa0, 0x16fbc, 0x16fc6, 0x16fcc, 0x16fd8, 0x17026, 0x1702c,
0x17046, 0x1704c, 0x17058, 0x1706e, 0x17086, 0x1708c, 0x17098,
0x170b0, 0x170be, 0x170ce, 0x170dc, 0x170e8, 0x17106, 0x1710c,
0x17118, 0x17130, 0x1713e, 0x17160, 0x1717c, 0x1718e, 0x1719c,
0x171b8, 0x171c2, 0x171c4, 0x171c8, 0x171d0, 0x171de, 0x171e6,
0x171ec, 0x171fa, 0x17206, 0x1720c, 0x17218, 0x17230, 0x1723e,
0x17260, 0x1727c, 0x172c0, 0x172f8, 0x1730e, 0x1731c, 0x17338,
0x17370, 0x1737e, 0x17388, 0x17390, 0x1739e, 0x173a0, 0x173bc,
0x173cc, 0x173d8, 0x173ee, 0x173f2, 0x173f4, 0x1740c, 0x17418,
0x17430, 0x1743e, 0x17460, 0x1747c, 0x174c0, 0x174f8, 0x175f0,
0x1760e, 0x1761c, 0x17638, 0x17670, 0x1767e, 0x176e0, 0x176fc,
0x17708, 0x17710, 0x1771e, 0x17720, 0x1773c, 0x17740, 0x17778,
0x17798, 0x177b0, 0x177be, 0x177dc, 0x177e2, 0x177e4, 0x177e8,
0x17822, 0x17824, 0x17828, 0x17836, 0x17842, 0x17844, 0x17848,
0x17850, 0x1785e, 0x17866, 0x1786c, 0x17882, 0x17884, 0x17888,
0x17890, 0x1789e, 0x178a0, 0x178bc, 0x178c6, 0x178cc, 0x178d8,
0x178ee, 0x178f2, 0x178f4, 0x17902, 0x17904, 0x17908, 0x17910,
0x1791e, 0x17920, 0x1793c, 0x17940, 0x17978, 0x17986, 0x1798c,
0x17998, 0x179b0, 0x179be, 0x179ce, 0x179dc, 0x179e2, 0x179e4,
0x179e8, 0x179f6, 0x17a04, 0x17a08, 0x17a10, 0x17a1e, 0x17a20,
0x17a3c, 0x17a40, 0x17a78, 0x17af0, 0x17b06, 0x17b0c, 0x17b18,
0x17b30, 0x17b3e, 0x17b60, 0x17b7c, 0x17b8e, 0x17b9c, 0x17bb8,
0x17bc4, 0x17bc8, 0x17bd0, 0x17bde, 0x17be6, 0x17bec, 0x17c2e,
0x17c32, 0x17c34, 0x17c4e, 0x17c5c, 0x17c62, 0x17c64, 0x17c68,
0x17c76, 0x17c8e, 0x17c9c, 0x17cb8, 0x17cc2, 0x17cc4, 0x17cc8,
0x17cd0, 0x17cde, 0x17ce6, 0x17cec, 0x17d0e, 0x17d1c, 0x17d38,
0x17d70, 0x17d82, 0x17d84, 0x17d88, 0x17d90, 0x17d9e, 0x17da0,
0x17dbc, 0x17dc6, 0x17dcc, 0x17dd8, 0x17dee, 0x17e26, 0x17e2c,
0x17e3a, 0x17e46, 0x17e4c, 0x17e58, 0x17e6e, 0x17e72, 0x17e74,
0x17e86, 0x17e8c, 0x17e98, 0x17eb0, 0x17ece, 0x17edc, 0x17ee2,
0x17ee4, 0x17ee8, 0x17ef6, 0x1813a, 0x18172, 0x18174, 0x18216,
0x18226, 0x1823a, 0x1824c, 0x18258, 0x1826e, 0x18272, 0x18274,
0x18298, 0x182be, 0x182e2, 0x182e4, 0x182e8, 0x182f6, 0x1835e,
0x1837a, 0x183ae, 0x183d6, 0x18416, 0x18426, 0x1842c, 0x1843a,
0x18446, 0x18458, 0x1846e, 0x18472, 0x18474, 0x18486, 0x184b0,
0x184be, 0x184ce, 0x184dc, 0x184e2, 0x184e4, 0x184e8, 0x184f6,
0x18506, 0x1850c, 0x18518, 0x18530, 0x1853e, 0x18560, 0x1857c,
0x1858e, 0x1859c, 0x185b8, 0x185c2, 0x185c4, 0x185c8, 0x185d0,
0x185de, 0x185e6, 0x185ec, 0x185fa, 0x18612, 0x18614, 0x18622,
0x18628, 0x18636, 0x18642, 0x18650, 0x1865e, 0x1867a, 0x18682,
0x18684, 0x18688, 0x18690, 0x1869e, 0x186a0, 0x186bc, 0x186c6,
0x186cc, 0x186d8, 0x186ee, 0x186f2, 0x186f4, 0x1872e, 0x1874e,
0x1875c, 0x18796, 0x187a6, 0x187ac, 0x187d2, 0x187d4, 0x18826,
0x1882c, 0x1883a, 0x18846, 0x1884c, 0x18858, 0x1886e, 0x18872,
0x18874, 0x18886, 0x18898, 0x188b0, 0x188be, 0x188ce, 0x188dc,
0x188e2, 0x188e4, 0x188e8, 0x188f6, 0x1890c, 0x18930, 0x1893e,
0x18960, 0x1897c, 0x1898e, 0x189b8, 0x189c2, 0x189c8, 0x189d0,
0x189de, 0x189e6, 0x189ec, 0x189fa, 0x18a18, 0x18a30, 0x18a3e,
0x18a60, 0x18a7c, 0x18ac0, 0x18af8, 0x18b1c, 0x18b38, 0x18b70,
0x18b7e, 0x18b82, 0x18b84, 0x18b88, 0x18b90, 0x18b9e, 0x18ba0,
0x18bbc, 0x18bc6, 0x18bcc, 0x18bd8, 0x18bee, 0x18bf2, 0x18bf4,
0x18c22, 0x18c24, 0x18c28, 0x18c36, 0x18c42, 0x18c48, 0x18c50,
0x18c5e, 0x18c66, 0x18c7a, 0x18c82, 0x18c84, 0x18c90, 0x18c9e,
0x18ca0, 0x18cbc, 0x18ccc, 0x18cf2, 0x18cf4, 0x18d04, 0x18d08,
0x18d10, 0x18d1e, 0x18d20, 0x18d3c, 0x18d40, 0x18d78, 0x18d86,
0x18d98, 0x18dce, 0x18de2, 0x18de4, 0x18de8, 0x18e2e, 0x18e32,
0x18e34, 0x18e4e, 0x18e5c, 0x18e62, 0x18e64, 0x18e68, 0x18e8e,
0x18e9c, 0x18eb8, 0x18ec2, 0x18ec4, 0x18ec8, 0x18ed0, 0x18efa,
0x18f16, 0x18f26, 0x18f2c, 0x18f46, 0x18f4c, 0x18f58, 0x18f6e,
0x18f8a, 0x18f92, 0x18f94, 0x18fa2, 0x18fa4, 0x18fa8, 0x18fb6,
0x1902c, 0x1903a, 0x19046, 0x1904c, 0x19058, 0x19072, 0x19074,
0x19086, 0x19098, 0x190b0, 0x190be, 0x190ce, 0x190dc, 0x190e2,
0x190e8, 0x190f6, 0x19106, 0x1910c, 0x19130, 0x1913e, 0x19160,
0x1917c, 0x1918e, 0x1919c, 0x191b8, 0x191c2, 0x191c8, 0x191d0,
0x191de, 0x191e6, 0x191ec, 0x191fa, 0x19218, 0x1923e, 0x19260,
0x1927c, 0x192c0, 0x192f8, 0x19338, 0x19370, 0x1937e, 0x19382,
0x19384, 0x19390, 0x1939e, 0x193a0, 0x193bc, 0x193c6, 0x193cc,
0x193d8, 0x193ee, 0x193f2, 0x193f4, 0x19430, 0x1943e, 0x19460,
0x1947c, 0x194c0, 0x194f8, 0x195f0, 0x19638, 0x19670, 0x1967e,
0x196e0, 0x196fc, 0x19702, 0x19704, 0x19708, 0x19710, 0x19720,
0x1973c, 0x19740, 0x19778, 0x19786, 0x1978c, 0x19798, 0x197b0,
0x197be, 0x197ce, 0x197dc, 0x197e2, 0x197e4, 0x197e8, 0x19822,
0x19824, 0x19842, 0x19848, 0x19850, 0x1985e, 0x19866, 0x1987a,
0x19882, 0x19884, 0x19890, 0x1989e, 0x198a0, 0x198bc, 0x198cc,
0x198f2, 0x198f4, 0x19902, 0x19908, 0x1991e, 0x19920, 0x1993c,
0x19940, 0x19978, 0x19986, 0x19998, 0x199ce, 0x199e2, 0x199e4,
0x199e8, 0x19a08, 0x19a10, 0x19a1e, 0x19a20, 0x19a3c, 0x19a40,
0x19a78, 0x19af0, 0x19b18, 0x19b3e, 0x19b60, 0x19b9c, 0x19bc2,
0x19bc4, 0x19bc8, 0x19bd0, 0x19be6, 0x19c2e, 0x19c34, 0x19c4e,
0x19c5c, 0x19c62, 0x19c64, 0x19c68, 0x19c8e, 0x19c9c, 0x19cb8,
0x19cc2, 0x19cc8, 0x19cd0, 0x19ce6, 0x19cfa, 0x19d0e, 0x19d1c,
0x19d38, 0x19d70, 0x19d7e, 0x19d82, 0x19d84, 0x19d88, 0x19d90,
0x19da0, 0x19dcc, 0x19df2, 0x19df4, 0x19e16, 0x19e26, 0x19e2c,
0x19e46, 0x19e4c, 0x19e58, 0x19e74, 0x19e86, 0x19e8c, 0x19e98,
0x19eb0, 0x19ebe, 0x19ece, 0x19ee2, 0x19ee4, 0x19ee8, 0x19f0a,
0x19f12, 0x19f14, 0x19f22, 0x19f24, 0x19f28, 0x19f42, 0x19f44,
0x19f48, 0x19f50, 0x19f5e, 0x19f6c, 0x19f9a, 0x19fae, 0x19fb2,
0x19fb4, 0x1a046, 0x1a04c, 0x1a072, 0x1a074, 0x1a086, 0x1a08c,
0x1a098, 0x1a0b0, 0x1a0be, 0x1a0e2, 0x1a0e4, 0x1a0e8, 0x1a0f6,
0x1a106, 0x1a10c, 0x1a118, 0x1a130, 0x1a13e, 0x1a160, 0x1a17c,
0x1a18e, 0x1a19c, 0x1a1b8, 0x1a1c2, 0x1a1c4, 0x1a1c8, 0x1a1d0,
0x1a1de, 0x1a1e6, 0x1a1ec, 0x1a218, 0x1a230, 0x1a23e, 0x1a260,
0x1a27c, 0x1a2c0, 0x1a2f8, 0x1a31c, 0x1a338, 0x1a370, 0x1a37e,
0x1a382, 0x1a384, 0x1a388, 0x1a390, 0x1a39e, 0x1a3a0, 0x1a3bc,
0x1a3c6, 0x1a3cc, 0x1a3d8, 0x1a3ee, 0x1a3f2, 0x1a3f4, 0x1a418,
0x1a430, 0x1a43e, 0x1a460, 0x1a47c, 0x1a4c0, 0x1a4f8, 0x1a5f0,
0x1a61c, 0x1a638, 0x1a670, 0x1a67e, 0x1a6e0, 0x1a6fc, 0x1a702,
0x1a704, 0x1a708, 0x1a710, 0x1a71e, 0x1a720, 0x1a73c, 0x1a740,
0x1a778, 0x1a786, 0x1a78c, 0x1a798, 0x1a7b0, 0x1a7be, 0x1a7ce,
0x1a7dc, 0x1a7e2, 0x1a7e4, 0x1a7e8, 0x1a830, 0x1a860, 0x1a87c,
0x1a8c0, 0x1a8f8, 0x1a9f0, 0x1abe0, 0x1ac70, 0x1ac7e, 0x1ace0,
0x1acfc, 0x1adc0, 0x1adf8, 0x1ae04, 0x1ae08, 0x1ae10, 0x1ae20,
0x1ae3c, 0x1ae40, 0x1ae78, 0x1aef0, 0x1af06, 0x1af0c, 0x1af18,
0x1af30, 0x1af3e, 0x1af60, 0x1af7c, 0x1af8e, 0x1af9c, 0x1afb8,
0x1afc4, 0x1afc8, 0x1afd0, 0x1afde, 0x1b042, 0x1b05e, 0x1b07a,
0x1b082, 0x1b084, 0x1b088, 0x1b090, 0x1b09e, 0x1b0a0, 0x1b0bc,
0x1b0cc, 0x1b0f2, 0x1b0f4, 0x1b102, 0x1b104, 0x1b108, 0x1b110,
0x1b11e, 0x1b120, 0x1b13c, 0x1b140, 0x1b178, 0x1b186, 0x1b198,
0x1b1ce, 0x1b1e2, 0x1b1e4, 0x1b1e8, 0x1b204, 0x1b208, 0x1b210,
0x1b21e, 0x1b220, 0x1b23c, 0x1b240, 0x1b278, 0x1b2f0, 0x1b30c,
0x1b33e, 0x1b360, 0x1b39c, 0x1b3c2, 0x1b3c4, 0x1b3c8, 0x1b3d0,
0x1b3e6, 0x1b410, 0x1b41e, 0x1b420, 0x1b43c, 0x1b440, 0x1b478,
0x1b4f0, 0x1b5e0, 0x1b618, 0x1b660, 0x1b67c, 0x1b6c0, 0x1b738,
0x1b782, 0x1b784, 0x1b788, 0x1b790, 0x1b79e, 0x1b7a0, 0x1b7cc,
0x1b82e, 0x1b84e, 0x1b85c, 0x1b88e, 0x1b89c, 0x1b8b8, 0x1b8c2,
0x1b8c4, 0x1b8c8, 0x1b8d0, 0x1b8e6, 0x1b8fa, 0x1b90e, 0x1b91c,
0x1b938, 0x1b970, 0x1b97e, 0x1b982, 0x1b984, 0x1b988, 0x1b990,
0x1b99e, 0x1b9a0, 0x1b9cc, 0x1b9f2, 0x1b9f4, 0x1ba0e, 0x1ba1c,
0x1ba38, 0x1ba70, 0x1ba7e, 0x1bae0, 0x1bafc, 0x1bb08, 0x1bb10,
0x1bb20, 0x1bb3c, 0x1bb40, 0x1bb98, 0x1bbce, 0x1bbe2, 0x1bbe4,
0x1bbe8, 0x1bc16, 0x1bc26, 0x1bc2c, 0x1bc46, 0x1bc4c, 0x1bc58,
0x1bc72, 0x1bc74, 0x1bc86, 0x1bc8c, 0x1bc98, 0x1bcb0, 0x1bcbe,
0x1bcce, 0x1bce2, 0x1bce4, 0x1bce8, 0x1bd06, 0x1bd0c, 0x1bd18,
0x1bd30, 0x1bd3e, 0x1bd60, 0x1bd7c, 0x1bd9c, 0x1bdc2, 0x1bdc4,
0x1bdc8, 0x1bdd0, 0x1bde6, 0x1bdfa, 0x1be12, 0x1be14, 0x1be22,
0x1be24, 0x1be28, 0x1be42, 0x1be44, 0x1be48, 0x1be50, 0x1be5e,
0x1be66, 0x1be82, 0x1be84, 0x1be88, 0x1be90, 0x1be9e, 0x1bea0,
0x1bebc, 0x1becc, 0x1bef4, 0x1bf1a, 0x1bf2e, 0x1bf32, 0x1bf34,
0x1bf4e, 0x1bf5c, 0x1bf62, 0x1bf64, 0x1bf68, 0x1c09a, 0x1c0b2,
0x1c0b4, 0x1c11a, 0x1c132, 0x1c134, 0x1c162, 0x1c164, 0x1c168,
0x1c176, 0x1c1ba, 0x1c21a, 0x1c232, 0x1c234, 0x1c24e, 0x1c25c,
0x1c262, 0x1c264, 0x1c268, 0x1c276, 0x1c28e, 0x1c2c2, 0x1c2c4,
0x1c2c8, 0x1c2d0, 0x1c2de, 0x1c2e6, 0x1c2ec, 0x1c2fa, 0x1c316,
0x1c326, 0x1c33a, 0x1c346, 0x1c34c, 0x1c372, 0x1c374, 0x1c41a,
0x1c42e, 0x1c432, 0x1c434, 0x1c44e, 0x1c45c, 0x1c462, 0x1c464,
0x1c468, 0x1c476, 0x1c48e, 0x1c49c, 0x1c4b8, 0x1c4c2, 0x1c4c8,
0x1c4d0, 0x1c4de, 0x1c4e6, 0x1c4ec, 0x1c4fa, 0x1c51c, 0x1c538,
0x1c570, 0x1c57e, 0x1c582, 0x1c584, 0x1c588, 0x1c590, 0x1c59e,
0x1c5a0, 0x1c5bc, 0x1c5c6, 0x1c5cc, 0x1c5d8, 0x1c5ee, 0x1c5f2,
0x1c5f4, 0x1c616, 0x1c626, 0x1c62c, 0x1c63a, 0x1c646, 0x1c64c,
0x1c658, 0x1c66e, 0x1c672, 0x1c674, 0x1c686, 0x1c68c, 0x1c698,
0x1c6b0, 0x1c6be, 0x1c6ce, 0x1c6dc, 0x1c6e2, 0x1c6e4, 0x1c6e8,
0x1c712, 0x1c714, 0x1c722, 0x1c728, 0x1c736, 0x1c742, 0x1c744,
0x1c748, 0x1c750, 0x1c75e, 0x1c766, 0x1c76c, 0x1c77a, 0x1c7ae,
0x1c7d6, 0x1c7ea, 0x1c81a, 0x1c82e, 0x1c832, 0x1c834, 0x1c84e,
0x1c85c, 0x1c862, 0x1c864, 0x1c868, 0x1c876, 0x1c88e, 0x1c89c,
0x1c8b8, 0x1c8c2, 0x1c8c8, 0x1c8d0, 0x1c8de, 0x1c8e6, 0x1c8ec,
0x1c8fa, 0x1c90e, 0x1c938, 0x1c970, 0x1c97e, 0x1c982, 0x1c984,
0x1c990, 0x1c99e, 0x1c9a0, 0x1c9bc, 0x1c9c6, 0x1c9cc, 0x1c9d8,
0x1c9ee, 0x1c9f2, 0x1c9f4, 0x1ca38, 0x1ca70, 0x1ca7e, 0x1cae0,
0x1cafc, 0x1cb02, 0x1cb04, 0x1cb08, 0x1cb10, 0x1cb20, 0x1cb3c,
0x1cb40, 0x1cb78, 0x1cb86, 0x1cb8c, 0x1cb98, 0x1cbb0, 0x1cbbe,
0x1cbce, 0x1cbdc, 0x1cbe2, 0x1cbe4, 0x1cbe8, 0x1cbf6, 0x1cc16,
0x1cc26, 0x1cc2c, 0x1cc3a, 0x1cc46, 0x1cc58, 0x1cc72, 0x1cc74,
0x1cc86, 0x1ccb0, 0x1ccbe, 0x1ccce, 0x1cce2, 0x1cce4, 0x1cce8,
0x1cd06, 0x1cd0c, 0x1cd18, 0x1cd30, 0x1cd3e, 0x1cd60, 0x1cd7c,
0x1cd9c, 0x1cdc2, 0x1cdc4, 0x1cdc8, 0x1cdd0, 0x1cdde, 0x1cde6,
0x1cdfa, 0x1ce22, 0x1ce28, 0x1ce42, 0x1ce50, 0x1ce5e, 0x1ce66,
0x1ce7a, 0x1ce82, 0x1ce84, 0x1ce88, 0x1ce90, 0x1ce9e, 0x1cea0,
0x1cebc, 0x1cecc, 0x1cef2, 0x1cef4, 0x1cf2e, 0x1cf32, 0x1cf34,
0x1cf4e, 0x1cf5c, 0x1cf62, 0x1cf64, 0x1cf68, 0x1cf96, 0x1cfa6,
0x1cfac, 0x1cfca, 0x1cfd2, 0x1cfd4, 0x1d02e, 0x1d032, 0x1d034,
0x1d04e, 0x1d05c, 0x1d062, 0x1d064, 0x1d068, 0x1d076, 0x1d08e,
0x1d09c, 0x1d0b8, 0x1d0c2, 0x1d0c4, 0x1d0c8, 0x1d0d0, 0x1d0de,
0x1d0e6, 0x1d0ec, 0x1d0fa, 0x1d11c, 0x1d138, 0x1d170, 0x1d17e,
0x1d182, 0x1d184, 0x1d188, 0x1d190, 0x1d19e, 0x1d1a0, 0x1d1bc,
0x1d1c6, 0x1d1cc, 0x1d1d8, 0x1d1ee, 0x1d1f2, 0x1d1f4, 0x1d21c,
0x1d238, 0x1d270, 0x1d27e, 0x1d2e0, 0x1d2fc, 0x1d302, 0x1d304,
0x1d308, 0x1d310, 0x1d31e, 0x1d320, 0x1d33c, 0x1d340, 0x1d378,
0x1d386, 0x1d38c, 0x1d398, 0x1d3b0, 0x1d3be, 0x1d3ce, 0x1d3dc,
0x1d3e2, 0x1d3e4, 0x1d3e8, 0x1d3f6, 0x1d470, 0x1d47e, 0x1d4e0,
0x1d4fc, 0x1d5c0, 0x1d5f8, 0x1d604, 0x1d608, 0x1d610, 0x1d620,
0x1d640, 0x1d678, 0x1d6f0, 0x1d706, 0x1d70c, 0x1d718, 0x1d730,
0x1d73e, 0x1d760, 0x1d77c, 0x1d78e, 0x1d79c, 0x1d7b8, 0x1d7c2,
0x1d7c4, 0x1d7c8, 0x1d7d0, 0x1d7de, 0x1d7e6, 0x1d7ec, 0x1d826,
0x1d82c, 0x1d83a, 0x1d846, 0x1d84c, 0x1d858, 0x1d872, 0x1d874,
0x1d886, 0x1d88c, 0x1d898, 0x1d8b0, 0x1d8be, 0x1d8ce, 0x1d8e2,
0x1d8e4, 0x1d8e8, 0x1d8f6, 0x1d90c, 0x1d918, 0x1d930, 0x1d93e,
0x1d960, 0x1d97c, 0x1d99c, 0x1d9c2, 0x1d9c4, 0x1d9c8, 0x1d9d0,
0x1d9e6, 0x1d9fa, 0x1da0c, 0x1da18, 0x1da30, 0x1da3e, 0x1da60,
0x1da7c, 0x1dac0, 0x1daf8, 0x1db38, 0x1db82, 0x1db84, 0x1db88,
0x1db90, 0x1db9e, 0x1dba0, 0x1dbcc, 0x1dbf2, 0x1dbf4, 0x1dc22,
0x1dc42, 0x1dc44, 0x1dc48, 0x1dc50, 0x1dc5e, 0x1dc66, 0x1dc7a,
0x1dc82, 0x1dc84, 0x1dc88, 0x1dc90, 0x1dc9e, 0x1dca0, 0x1dcbc,
0x1dccc, 0x1dcf2, 0x1dcf4, 0x1dd04, 0x1dd08, 0x1dd10, 0x1dd1e,
0x1dd20, 0x1dd3c, 0x1dd40, 0x1dd78, 0x1dd86, 0x1dd98, 0x1ddce,
0x1dde2, 0x1dde4, 0x1dde8, 0x1de2e, 0x1de32, 0x1de34, 0x1de4e,
0x1de5c, 0x1de62, 0x1de64, 0x1de68, 0x1de8e, 0x1de9c, 0x1deb8,
0x1dec2, 0x1dec4, 0x1dec8, 0x1ded0, 0x1dee6, 0x1defa, 0x1df16,
0x1df26, 0x1df2c, 0x1df46, 0x1df4c, 0x1df58, 0x1df72, 0x1df74,
0x1df8a, 0x1df92, 0x1df94, 0x1dfa2, 0x1dfa4, 0x1dfa8, 0x1e08a,
0x1e092, 0x1e094, 0x1e0a2, 0x1e0a4, 0x1e0a8, 0x1e0b6, 0x1e0da,
0x1e10a, 0x1e112, 0x1e114, 0x1e122, 0x1e124, 0x1e128, 0x1e136,
0x1e142, 0x1e144, 0x1e148, 0x1e150, 0x1e166, 0x1e16c, 0x1e17a,
0x1e19a, 0x1e1b2, 0x1e1b4, 0x1e20a, 0x1e212, 0x1e214, 0x1e222,
0x1e224, 0x1e228, 0x1e236, 0x1e242, 0x1e248, 0x1e250, 0x1e25e,
0x1e266, 0x1e26c, 0x1e27a, 0x1e282, 0x1e284, 0x1e288, 0x1e290,
0x1e2a0, 0x1e2bc, 0x1e2c6, 0x1e2cc, 0x1e2d8, 0x1e2ee, 0x1e2f2,
0x1e2f4, 0x1e31a, 0x1e332, 0x1e334, 0x1e35c, 0x1e362, 0x1e364,
0x1e368, 0x1e3ba, 0x1e40a, 0x1e412, 0x1e414, 0x1e422, 0x1e428,
0x1e436, 0x1e442, 0x1e448, 0x1e450, 0x1e45e, 0x1e466, 0x1e46c,
0x1e47a, 0x1e482, 0x1e484, 0x1e490, 0x1e49e, 0x1e4a0, 0x1e4bc,
0x1e4c6, 0x1e4cc, 0x1e4d8, 0x1e4ee, 0x1e4f2, 0x1e4f4, 0x1e502,
0x1e504, 0x1e508, 0x1e510, 0x1e51e, 0x1e520, 0x1e53c, 0x1e540,
0x1e578, 0x1e586, 0x1e58c, 0x1e598, 0x1e5b0, 0x1e5be, 0x1e5ce,
0x1e5dc, 0x1e5e2, 0x1e5e4, 0x1e5e8, 0x1e5f6, 0x1e61a, 0x1e62e,
0x1e632, 0x1e634, 0x1e64e, 0x1e65c, 0x1e662, 0x1e668, 0x1e68e,
0x1e69c, 0x1e6b8, 0x1e6c2, 0x1e6c4, 0x1e6c8, 0x1e6d0, 0x1e6e6,
0x1e6fa, 0x1e716, 0x1e726, 0x1e72c, 0x1e73a, 0x1e746, 0x1e74c,
0x1e758, 0x1e772, 0x1e774, 0x1e792, 0x1e794, 0x1e7a2, 0x1e7a4,
0x1e7a8, 0x1e7b6, 0x1e812, 0x1e814, 0x1e822, 0x1e824, 0x1e828,
0x1e836, 0x1e842, 0x1e844, 0x1e848, 0x1e850, 0x1e85e, 0x1e866,
0x1e86c, 0x1e87a, 0x1e882, 0x1e884, 0x1e888, 0x1e890, 0x1e89e,
0x1e8a0, 0x1e8bc, 0x1e8c6, 0x1e8cc, 0x1e8d8, 0x1e8ee, 0x1e8f2,
0x1e8f4, 0x1e902, 0x1e904, 0x1e908, 0x1e910, 0x1e920, 0x1e93c,
0x1e940, 0x1e978, 0x1e986, 0x1e98c, 0x1e998, 0x1e9b0, 0x1e9be,
0x1e9ce, 0x1e9dc, 0x1e9e2, 0x1e9e4, 0x1e9e8, 0x1e9f6, 0x1ea04,
0x1ea08, 0x1ea10, 0x1ea20, 0x1ea40, 0x1ea78, 0x1eaf0, 0x1eb06,
0x1eb0c, 0x1eb18, 0x1eb30, 0x1eb3e, 0x1eb60, 0x1eb7c, 0x1eb8e,
0x1eb9c, 0x1ebb8, 0x1ebc2, 0x1ebc4, 0x1ebc8, 0x1ebd0, 0x1ebde,
0x1ebe6, 0x1ebec, 0x1ec1a, 0x1ec2e, 0x1ec32, 0x1ec34, 0x1ec4e,
0x1ec5c, 0x1ec62, 0x1ec64, 0x1ec68, 0x1ec8e, 0x1ec9c, 0x1ecb8,
0x1ecc2, 0x1ecc4, 0x1ecc8, 0x1ecd0, 0x1ece6, 0x1ecfa, 0x1ed0e,
0x1ed1c, 0x1ed38, 0x1ed70, 0x1ed7e, 0x1ed82, 0x1ed84, 0x1ed88,
0x1ed90, 0x1ed9e, 0x1eda0, 0x1edcc, 0x1edf2, 0x1edf4, 0x1ee16,
0x1ee26, 0x1ee2c, 0x1ee3a, 0x1ee46, 0x1ee4c, 0x1ee58, 0x1ee6e,
0x1ee72, 0x1ee74, 0x1ee86, 0x1ee8c, 0x1ee98, 0x1eeb0, 0x1eebe,
0x1eece, 0x1eedc, 0x1eee2, 0x1eee4, 0x1eee8, 0x1ef12, 0x1ef22,
0x1ef24, 0x1ef28, 0x1ef36, 0x1ef42, 0x1ef44, 0x1ef48, 0x1ef50,
0x1ef5e, 0x1ef66, 0x1ef6c, 0x1ef7a, 0x1efae, 0x1efb2, 0x1efb4,
0x1efd6, 0x1f096, 0x1f0a6, 0x1f0ac, 0x1f0ba, 0x1f0ca, 0x1f0d2,
0x1f0d4, 0x1f116, 0x1f126, 0x1f12c, 0x1f13a, 0x1f146, 0x1f14c,
0x1f158, 0x1f16e, 0x1f172, 0x1f174, 0x1f18a, 0x1f192, 0x1f194,
0x1f1a2, 0x1f1a4, 0x1f1a8, 0x1f1da, 0x1f216, 0x1f226, 0x1f22c,
0x1f23a, 0x1f246, 0x1f258, 0x1f26e, 0x1f272, 0x1f274, 0x1f286,
0x1f28c, 0x1f298, 0x1f2b0, 0x1f2be, 0x1f2ce, 0x1f2dc, 0x1f2e2,
0x1f2e4, 0x1f2e8, 0x1f2f6, 0x1f30a, 0x1f312, 0x1f314, 0x1f322,
0x1f328, 0x1f342, 0x1f344, 0x1f348, 0x1f350, 0x1f35e, 0x1f366,
0x1f37a, 0x1f39a, 0x1f3ae, 0x1f3b2, 0x1f3b4, 0x1f416, 0x1f426,
0x1f42c, 0x1f43a, 0x1f446, 0x1f44c, 0x1f458, 0x1f46e, 0x1f472,
0x1f474, 0x1f486, 0x1f48c, 0x1f498, 0x1f4b0, 0x1f4be, 0x1f4ce,
0x1f4dc, 0x1f4e2, 0x1f4e4, 0x1f4e8, 0x1f4f6, 0x1f506, 0x1f50c,
0x1f518, 0x1f530, 0x1f53e, 0x1f560, 0x1f57c, 0x1f58e, 0x1f59c,
0x1f5b8, 0x1f5c2, 0x1f5c4, 0x1f5c8, 0x1f5d0, 0x1f5de, 0x1f5e6,
0x1f5ec, 0x1f5fa, 0x1f60a, 0x1f612, 0x1f614, 0x1f622, 0x1f624,
0x1f628, 0x1f636, 0x1f642, 0x1f644, 0x1f648, 0x1f650, 0x1f65e,
0x1f666, 0x1f67a, 0x1f682, 0x1f684, 0x1f688, 0x1f690, 0x1f69e,
0x1f6a0, 0x1f6bc, 0x1f6cc, 0x1f6f2, 0x1f6f4, 0x1f71a, 0x1f72e,
0x1f732, 0x1f734, 0x1f74e, 0x1f75c, 0x1f762, 0x1f764, 0x1f768,
0x1f776, 0x1f796, 0x1f7a6, 0x1f7ac, 0x1f7ba, 0x1f7d2, 0x1f7d4,
0x1f89a, 0x1f8ae, 0x1f8b2, 0x1f8b4, 0x1f8d6, 0x1f8ea, 0x1f91a,
0x1f92e, 0x1f932, 0x1f934, 0x1f94e, 0x1f95c, 0x1f962, 0x1f964,
0x1f968, 0x1f976, 0x1f996, 0x1f9a6, 0x1f9ac, 0x1f9ba, 0x1f9ca,
0x1f9d2, 0x1f9d4, 0x1fa1a, 0x1fa2e, 0x1fa32, 0x1fa34, 0x1fa4e,
0x1fa5c, 0x1fa62, 0x1fa64, 0x1fa68, 0x1fa76, 0x1fa8e, 0x1fa9c,
0x1fab8, 0x1fac2, 0x1fac4, 0x1fac8, 0x1fad0, 0x1fade, 0x1fae6,
0x1faec, 0x1fb16, 0x1fb26, 0x1fb2c, 0x1fb3a, 0x1fb46, 0x1fb4c,
0x1fb58, 0x1fb6e, 0x1fb72, 0x1fb74, 0x1fb8a, 0x1fb92, 0x1fb94,
0x1fba2, 0x1fba4, 0x1fba8, 0x1fbb6, 0x1fbda
};
const int BitMatrixParser::CODEWORD_TABLE[] =
{
2627, 1819, 2622, 2621, 1813, 1812, 2729, 2724, 2723,
2779, 2774, 2773, 902, 896, 908, 868, 865, 861,
859, 2511, 873, 871, 1780, 835, 2493, 825, 2491,
842, 837, 844, 1764, 1762, 811, 810, 809, 2483,
807, 2482, 806, 2480, 815, 814, 813, 812, 2484,
817, 816, 1745, 1744, 1742, 1746, 2655, 2637, 2635,
2626, 2625, 2623, 2628, 1820, 2752, 2739, 2737, 2728,
2727, 2725, 2730, 2785, 2783, 2778, 2777, 2775, 2780,
787, 781, 747, 739, 736, 2413, 754, 752, 1719,
692, 689, 681, 2371, 678, 2369, 700, 697, 694,
703, 1688, 1686, 642, 638, 2343, 631, 2341, 627,
2338, 651, 646, 643, 2345, 654, 652, 1652, 1650,
1647, 1654, 601, 599, 2322, 596, 2321, 594, 2319,
2317, 611, 610, 608, 606, 2324, 603, 2323, 615,
614, 612, 1617, 1616, 1614, 1612, 616, 1619, 1618,
2575, 2538, 2536, 905, 901, 898, 909, 2509, 2507,
2504, 870, 867, 864, 860, 2512, 875, 872, 1781,
2490, 2489, 2487, 2485, 1748, 836, 834, 832, 830,
2494, 827, 2492, 843, 841, 839, 845, 1765, 1763,
2701, 2676, 2674, 2653, 2648, 2656, 2634, 2633, 2631,
2629, 1821, 2638, 2636, 2770, 2763, 2761, 2750, 2745,
2753, 2736, 2735, 2733, 2731, 1848, 2740, 2738, 2786,
2784, 591, 588, 576, 569, 566, 2296, 1590, 537,
534, 526, 2276, 522, 2274, 545, 542, 539, 548,
1572, 1570, 481, 2245, 466, 2242, 462, 2239, 492,
485, 482, 2249, 496, 494, 1534, 1531, 1528, 1538,
413, 2196, 406, 2191, 2188, 425, 419, 2202, 415,
2199, 432, 430, 427, 1472, 1467, 1464, 433, 1476,
1474, 368, 367, 2160, 365, 2159, 362, 2157, 2155,
2152, 378, 377, 375, 2166, 372, 2165, 369, 2162,
383, 381, 379, 2168, 1419, 1418, 1416, 1414, 385,
1411, 384, 1423, 1422, 1420, 1424, 2461, 802, 2441,
2439, 790, 786, 783, 794, 2409, 2406, 2403, 750,
742, 738, 2414, 756, 753, 1720, 2367, 2365, 2362,
2359, 1663, 693, 691, 684, 2373, 680, 2370, 702,
699, 696, 704, 1690, 1687, 2337, 2336, 2334, 2332,
1624, 2329, 1622, 640, 637, 2344, 634, 2342, 630,
2340, 650, 648, 645, 2346, 655, 653, 1653, 1651,
1649, 1655, 2612, 2597, 2595, 2571, 2568, 2565, 2576,
2534, 2529, 2526, 1787, 2540, 2537, 907, 904, 900,
910, 2503, 2502, 2500, 2498, 1768, 2495, 1767, 2510,
2508, 2506, 869, 866, 863, 2513, 876, 874, 1782,
2720, 2713, 2711, 2697, 2694, 2691, 2702, 2672, 2670,
2664, 1828, 2678, 2675, 2647, 2646, 2644, 2642, 1823,
2639, 1822, 2654, 2652, 2650, 2657, 2771, 1855, 2765,
2762, 1850, 1849, 2751, 2749, 2747, 2754, 353, 2148,
344, 342, 336, 2142, 332, 2140, 345, 1375, 1373,
306, 2130, 299, 2128, 295, 2125, 319, 314, 311,
2132, 1354, 1352, 1349, 1356, 262, 257, 2101, 253,
2096, 2093, 274, 273, 267, 2107, 263, 2104, 280,
278, 275, 1316, 1311, 1308, 1320, 1318, 2052, 202,
2050, 2044, 2040, 219, 2063, 212, 2060, 208, 2055,
224, 221, 2066, 1260, 1258, 1252, 231, 1248, 229,
1266, 1264, 1261, 1268, 155, 1998, 153, 1996, 1994,
1991, 1988, 165, 164, 2007, 162, 2006, 159, 2003,
2000, 172, 171, 169, 2012, 166, 2010, 1186, 1184,
1182, 1179, 175, 1176, 173, 1192, 1191, 1189, 1187,
176, 1194, 1193, 2313, 2307, 2305, 592, 589, 2294,
2292, 2289, 578, 572, 568, 2297, 580, 1591, 2272,
2267, 2264, 1547, 538, 536, 529, 2278, 525, 2275,
547, 544, 541, 1574, 1571, 2237, 2235, 2229, 1493,
2225, 1489, 478, 2247, 470, 2244, 465, 2241, 493,
488, 484, 2250, 498, 495, 1536, 1533, 1530, 1539,
2187, 2186, 2184, 2182, 1432, 2179, 1430, 2176, 1427,
414, 412, 2197, 409, 2195, 405, 2193, 2190, 426,
424, 421, 2203, 418, 2201, 431, 429, 1473, 1471,
1469, 1466, 434, 1477, 1475, 2478, 2472, 2470, 2459,
2457, 2454, 2462, 803, 2437, 2432, 2429, 1726, 2443,
2440, 792, 789, 785, 2401, 2399, 2393, 1702, 2389,
1699, 2411, 2408, 2405, 745, 741, 2415, 758, 755,
1721, 2358, 2357, 2355, 2353, 1661, 2350, 1660, 2347,
1657, 2368, 2366, 2364, 2361, 1666, 690, 687, 2374,
683, 2372, 701, 698, 705, 1691, 1689, 2619, 2617,
2610, 2608, 2605, 2613, 2593, 2588, 2585, 1803, 2599,
2596, 2563, 2561, 2555, 1797, 2551, 1795, 2573, 2570,
2567, 2577, 2525, 2524, 2522, 2520, 1786, 2517, 1785,
2514, 1783, 2535, 2533, 2531, 2528, 1788, 2541, 2539,
906, 903, 911, 2721, 1844, 2715, 2712, 1838, 1836,
2699, 2696, 2693, 2703, 1827, 1826, 1824, 2673, 2671,
2669, 2666, 1829, 2679, 2677, 1858, 1857, 2772, 1854,
1853, 1851, 1856, 2766, 2764, 143, 1987, 139, 1986,
135, 133, 131, 1984, 128, 1983, 125, 1981, 138,
137, 136, 1985, 1133, 1132, 1130, 112, 110, 1974,
107, 1973, 104, 1971, 1969, 122, 121, 119, 117,
1977, 114, 1976, 124, 1115, 1114, 1112, 1110, 1117,
1116, 84, 83, 1953, 81, 1952, 78, 1950, 1948,
1945, 94, 93, 91, 1959, 88, 1958, 85, 1955,
99, 97, 95, 1961, 1086, 1085, 1083, 1081, 1078,
100, 1090, 1089, 1087, 1091, 49, 47, 1917, 44,
1915, 1913, 1910, 1907, 59, 1926, 56, 1925, 53,
1922, 1919, 66, 64, 1931, 61, 1929, 1042, 1040,
1038, 71, 1035, 70, 1032, 68, 1048, 1047, 1045,
1043, 1050, 1049, 12, 10, 1869, 1867, 1864, 1861,
21, 1880, 19, 1877, 1874, 1871, 28, 1888, 25,
1886, 22, 1883, 982, 980, 977, 974, 32, 30,
991, 989, 987, 984, 34, 995, 994, 992, 2151,
2150, 2147, 2146, 2144, 356, 355, 354, 2149, 2139,
2138, 2136, 2134, 1359, 343, 341, 338, 2143, 335,
2141, 348, 347, 346, 1376, 1374, 2124, 2123, 2121,
2119, 1326, 2116, 1324, 310, 308, 305, 2131, 302,
2129, 298, 2127, 320, 318, 316, 313, 2133, 322,
321, 1355, 1353, 1351, 1357, 2092, 2091, 2089, 2087,
1276, 2084, 1274, 2081, 1271, 259, 2102, 256, 2100,
252, 2098, 2095, 272, 269, 2108, 266, 2106, 281,
279, 277, 1317, 1315, 1313, 1310, 282, 1321, 1319,
2039, 2037, 2035, 2032, 1203, 2029, 1200, 1197, 207,
2053, 205, 2051, 201, 2049, 2046, 2043, 220, 218,
2064, 215, 2062, 211, 2059, 228, 226, 223, 2069,
1259, 1257, 1254, 232, 1251, 230, 1267, 1265, 1263,
2316, 2315, 2312, 2311, 2309, 2314, 2304, 2303, 2301,
2299, 1593, 2308, 2306, 590, 2288, 2287, 2285, 2283,
1578, 2280, 1577, 2295, 2293, 2291, 579, 577, 574,
571, 2298, 582, 581, 1592, 2263, 2262, 2260, 2258,
1545, 2255, 1544, 2252, 1541, 2273, 2271, 2269, 2266,
1550, 535, 532, 2279, 528, 2277, 546, 543, 549,
1575, 1573, 2224, 2222, 2220, 1486, 2217, 1485, 2214,
1482, 1479, 2238, 2236, 2234, 2231, 1496, 2228, 1492,
480, 477, 2248, 473, 2246, 469, 2243, 490, 487,
2251, 497, 1537, 1535, 1532, 2477, 2476, 2474, 2479,
2469, 2468, 2466, 2464, 1730, 2473, 2471, 2453, 2452,
2450, 2448, 1729, 2445, 1728, 2460, 2458, 2456, 2463,
805, 804, 2428, 2427, 2425, 2423, 1725, 2420, 1724,
2417, 1722, 2438, 2436, 2434, 2431, 1727, 2444, 2442,
793, 791, 788, 795, 2388, 2386, 2384, 1697, 2381,
1696, 2378, 1694, 1692, 2402, 2400, 2398, 2395, 1703,
2392, 1701, 2412, 2410, 2407, 751, 748, 744, 2416,
759, 757, 1807, 2620, 2618, 1806, 1805, 2611, 2609,
2607, 2614, 1802, 1801, 1799, 2594, 2592, 2590, 2587,
1804, 2600, 2598, 1794, 1793, 1791, 1789, 2564, 2562,
2560, 2557, 1798, 2554, 1796, 2574, 2572, 2569, 2578,
1847, 1846, 2722, 1843, 1842, 1840, 1845, 2716, 2714,
1835, 1834, 1832, 1830, 1839, 1837, 2700, 2698, 2695,
2704, 1817, 1811, 1810, 897, 862, 1777, 829, 826,
838, 1760, 1758, 808, 2481, 1741, 1740, 1738, 1743,
2624, 1818, 2726, 2776, 782, 740, 737, 1715, 686,
679, 695, 1682, 1680, 639, 628, 2339, 647, 644,
1645, 1643, 1640, 1648, 602, 600, 597, 595, 2320,
593, 2318, 609, 607, 604, 1611, 1610, 1608, 1606,
613, 1615, 1613, 2328, 926, 924, 892, 886, 899,
857, 850, 2505, 1778, 824, 823, 821, 819, 2488,
818, 2486, 833, 831, 828, 840, 1761, 1759, 2649,
2632, 2630, 2746, 2734, 2732, 2782, 2781, 570, 567,
1587, 531, 527, 523, 540, 1566, 1564, 476, 467,
463, 2240, 486, 483, 1524, 1521, 1518, 1529, 411,
403, 2192, 399, 2189, 423, 416, 1462, 1457, 1454,
428, 1468, 1465, 2210, 366, 363, 2158, 360, 2156,
357, 2153, 376, 373, 370, 2163, 1410, 1409, 1407,
1405, 382, 1402, 380, 1417, 1415, 1412, 1421, 2175,
2174, 777, 774, 771, 784, 732, 725, 722, 2404,
743, 1716, 676, 674, 668, 2363, 665, 2360, 685,
1684, 1681, 626, 624, 622, 2335, 620, 2333, 617,
2330, 641, 635, 649, 1646, 1644, 1642, 2566, 928,
925, 2530, 2527, 894, 891, 888, 2501, 2499, 2496,
858, 856, 854, 851, 1779, 2692, 2668, 2665, 2645,
2643, 2640, 2651, 2768, 2759, 2757, 2744, 2743, 2741,
2748, 352, 1382, 340, 337, 333, 1371, 1369, 307,
300, 296, 2126, 315, 312, 1347, 1342, 1350, 261,
258, 250, 2097, 246, 2094, 271, 268, 264, 1306,
1301, 1298, 276, 1312, 1309, 2115, 203, 2048, 195,
2045, 191, 2041, 213, 209, 2056, 1246, 1244, 1238,
225, 1234, 222, 1256, 1253, 1249, 1262, 2080, 2079,
154, 1997, 150, 1995, 147, 1992, 1989, 163, 160,
2004, 156, 2001, 1175, 1174, 1172, 1170, 1167, 170,
1164, 167, 1185, 1183, 1180, 1177, 174, 1190, 1188,
2025, 2024, 2022, 587, 586, 564, 559, 556, 2290,
573, 1588, 520, 518, 512, 2268, 508, 2265, 530,
1568, 1565, 461, 457, 2233, 450, 2230, 446, 2226,
479, 471, 489, 1526, 1523, 1520, 397, 395, 2185,
392, 2183, 389, 2180, 2177, 410, 2194, 402, 422,
1463, 1461, 1459, 1456, 1470, 2455, 799, 2433, 2430,
779, 776, 773, 2397, 2394, 2390, 734, 728, 724,
746, 1717, 2356, 2354, 2351, 2348, 1658, 677, 675,
673, 670, 667, 688, 1685, 1683, 2606, 2589, 2586,
2559, 2556, 2552, 927, 2523, 2521, 2518, 2515, 1784,
2532, 895, 893, 890, 2718, 2709, 2707, 2689, 2687,
2684, 2663, 2662, 2660, 2658, 1825, 2667, 2769, 1852,
2760, 2758, 142, 141, 1139, 1138, 134, 132, 129,
126, 1982, 1129, 1128, 1126, 1131, 113, 111, 108,
105, 1972, 101, 1970, 120, 118, 115, 1109, 1108,
1106, 1104, 123, 1113, 1111, 82, 79, 1951, 75,
1949, 72, 1946, 92, 89, 86, 1956, 1077, 1076,
1074, 1072, 98, 1069, 96, 1084, 1082, 1079, 1088,
1968, 1967, 48, 45, 1916, 42, 1914, 39, 1911,
1908, 60, 57, 54, 1923, 50, 1920, 1031, 1030,
1028, 1026, 67, 1023, 65, 1020, 62, 1041, 1039,
1036, 1033, 69, 1046, 1044, 1944, 1943, 1941, 11,
9, 1868, 7, 1865, 1862, 1859, 20, 1878, 16,
1875, 13, 1872, 970, 968, 966, 963, 29, 960,
26, 23, 983, 981, 978, 975, 33, 971, 31,
990, 988, 985, 1906, 1904, 1902, 993, 351, 2145,
1383, 331, 330, 328, 326, 2137, 323, 2135, 339,
1372, 1370, 294, 293, 291, 289, 2122, 286, 2120,
283, 2117, 309, 303, 317, 1348, 1346, 1344, 245,
244, 242, 2090, 239, 2088, 236, 2085, 2082, 260,
2099, 249, 270, 1307, 1305, 1303, 1300, 1314, 189,
2038, 186, 2036, 183, 2033, 2030, 2026, 206, 198,
2047, 194, 216, 1247, 1245, 1243, 1240, 227, 1237,
1255, 2310, 2302, 2300, 2286, 2284, 2281, 565, 563,
561, 558, 575, 1589, 2261, 2259, 2256, 2253, 1542,
521, 519, 517, 514, 2270, 511, 533, 1569, 1567,
2223, 2221, 2218, 2215, 1483, 2211, 1480, 459, 456,
453, 2232, 449, 474, 491, 1527, 1525, 1522, 2475,
2467, 2465, 2451, 2449, 2446, 801, 800, 2426, 2424,
2421, 2418, 1723, 2435, 780, 778, 775, 2387, 2385,
2382, 2379, 1695, 2375, 1693, 2396, 735, 733, 730,
727, 749, 1718, 2616, 2615, 2604, 2603, 2601, 2584,
2583, 2581, 2579, 1800, 2591, 2550, 2549, 2547, 2545,
1792, 2542, 1790, 2558, 929, 2719, 1841, 2710, 2708,
1833, 1831, 2690, 2688, 2686, 1815, 1809, 1808, 1774,
1756, 1754, 1737, 1736, 1734, 1739, 1816, 1711, 1676,
1674, 633, 629, 1638, 1636, 1633, 1641, 598, 1605,
1604, 1602, 1600, 605, 1609, 1607, 2327, 887, 853,
1775, 822, 820, 1757, 1755, 1584, 524, 1560, 1558,
468, 464, 1514, 1511, 1508, 1519, 408, 404, 400,
1452, 1447, 1444, 417, 1458, 1455, 2208, 364, 361,
358, 2154, 1401, 1400, 1398, 1396, 374, 1393, 371,
1408, 1406, 1403, 1413, 2173, 2172, 772, 726, 723,
1712, 672, 669, 666, 682, 1678, 1675, 625, 623,
621, 618, 2331, 636, 632, 1639, 1637, 1635, 920,
918, 884, 880, 889, 849, 848, 847, 846, 2497,
855, 852, 1776, 2641, 2742, 2787, 1380, 334, 1367,
1365, 301, 297, 1340, 1338, 1335, 1343, 255, 251,
247, 1296, 1291, 1288, 265, 1302, 1299, 2113, 204,
196, 192, 2042, 1232, 1230, 1224, 214, 1220, 210,
1242, 1239, 1235, 1250, 2077, 2075, 151, 148, 1993,
144, 1990, 1163, 1162, 1160, 1158, 1155, 161, 1152,
157, 1173, 1171, 1168, 1165, 168, 1181, 1178, 2021,
2020, 2018, 2023, 585, 560, 557, 1585, 516, 509,
1562, 1559, 458, 447, 2227, 472, 1516, 1513, 1510,
398, 396, 393, 390, 2181, 386, 2178, 407, 1453,
1451, 1449, 1446, 420, 1460, 2209, 769, 764, 720,
712, 2391, 729, 1713, 664, 663, 661, 659, 2352,
656, 2349, 671, 1679, 1677, 2553, 922, 919, 2519,
2516, 885, 883, 881, 2685, 2661, 2659, 2767, 2756,
2755, 140, 1137, 1136, 130, 127, 1125, 1124, 1122,
1127, 109, 106, 102, 1103, 1102, 1100, 1098, 116,
1107, 1105, 1980, 80, 76, 73, 1947, 1068, 1067,
1065, 1063, 90, 1060, 87, 1075, 1073, 1070, 1080,
1966, 1965, 46, 43, 40, 1912, 36, 1909, 1019,
1018, 1016, 1014, 58, 1011, 55, 1008, 51, 1029,
1027, 1024, 1021, 63, 1037, 1034, 1940, 1939, 1937,
1942, 8, 1866, 4, 1863, 1, 1860, 956, 954,
952, 949, 946, 17, 14, 969, 967, 964, 961,
27, 957, 24, 979, 976, 972, 1901, 1900, 1898,
1896, 986, 1905, 1903, 350, 349, 1381, 329, 327,
324, 1368, 1366, 292, 290, 287, 284, 2118, 304,
1341, 1339, 1337, 1345, 243, 240, 237, 2086, 233,
2083, 254, 1297, 1295, 1293, 1290, 1304, 2114, 190,
187, 184, 2034, 180, 2031, 177, 2027, 199, 1233,
1231, 1229, 1226, 217, 1223, 1241, 2078, 2076, 584,
555, 554, 552, 550, 2282, 562, 1586, 507, 506,
504, 502, 2257, 499, 2254, 515, 1563, 1561, 445,
443, 441, 2219, 438, 2216, 435, 2212, 460, 454,
475, 1517, 1515, 1512, 2447, 798, 797, 2422, 2419,
770, 768, 766, 2383, 2380, 2376, 721, 719, 717,
714, 731, 1714, 2602, 2582, 2580, 2548, 2546, 2543,
923, 921, 2717, 2706, 2705, 2683, 2682, 2680, 1771,
1752, 1750, 1733, 1732, 1731, 1735, 1814, 1707, 1670,
1668, 1631, 1629, 1626, 1634, 1599, 1598, 1596, 1594,
1603, 1601, 2326, 1772, 1753, 1751, 1581, 1554, 1552,
1504, 1501, 1498, 1509, 1442, 1437, 1434, 401, 1448,
1445, 2206, 1392, 1391, 1389, 1387, 1384, 359, 1399,
1397, 1394, 1404, 2171, 2170, 1708, 1672, 1669, 619,
1632, 1630, 1628, 1773, 1378, 1363, 1361, 1333, 1328,
1336, 1286, 1281, 1278, 248, 1292, 1289, 2111, 1218,
1216, 1210, 197, 1206, 193, 1228, 1225, 1221, 1236,
2073, 2071, 1151, 1150, 1148, 1146, 152, 1143, 149,
1140, 145, 1161, 1159, 1156, 1153, 158, 1169, 1166,
2017, 2016, 2014, 2019, 1582, 510, 1556, 1553, 452,
448, 1506, 1500, 394, 391, 387, 1443, 1441, 1439,
1436, 1450, 2207, 765, 716, 713, 1709, 662, 660,
657, 1673, 1671, 916, 914, 879, 878, 877, 882,
1135, 1134, 1121, 1120, 1118, 1123, 1097, 1096, 1094,
1092, 103, 1101, 1099, 1979, 1059, 1058, 1056, 1054,
77, 1051, 74, 1066, 1064, 1061, 1071, 1964, 1963,
1007, 1006, 1004, 1002, 999, 41, 996, 37, 1017,
1015, 1012, 1009, 52, 1025, 1022, 1936, 1935, 1933,
1938, 942, 940, 938, 935, 932, 5, 2, 955,
953, 950, 947, 18, 943, 15, 965, 962, 958,
1895, 1894, 1892, 1890, 973, 1899, 1897, 1379, 325,
1364, 1362, 288, 285, 1334, 1332, 1330, 241, 238,
234, 1287, 1285, 1283, 1280, 1294, 2112, 188, 185,
181, 178, 2028, 1219, 1217, 1215, 1212, 200, 1209,
1227, 2074, 2072, 583, 553, 551, 1583, 505, 503,
500, 513, 1557, 1555, 444, 442, 439, 436, 2213,
455, 451, 1507, 1505, 1502, 796, 763, 762, 760,
767, 711, 710, 708, 706, 2377, 718, 715, 1710,
2544, 917, 915, 2681, 1627, 1597, 1595, 2325, 1769,
1749, 1747, 1499, 1438, 1435, 2204, 1390, 1388, 1385,
1395, 2169, 2167, 1704, 1665, 1662, 1625, 1623, 1620,
1770, 1329, 1282, 1279, 2109, 1214, 1207, 1222, 2068,
2065, 1149, 1147, 1144, 1141, 146, 1157, 1154, 2013,
2011, 2008, 2015, 1579, 1549, 1546, 1495, 1487, 1433,
1431, 1428, 1425, 388, 1440, 2205, 1705, 658, 1667,
1664, 1119, 1095, 1093, 1978, 1057, 1055, 1052, 1062,
1962, 1960, 1005, 1003, 1000, 997, 38, 1013, 1010,
1932, 1930, 1927, 1934, 941, 939, 936, 933, 6,
930, 3, 951, 948, 944, 1889, 1887, 1884, 1881,
959, 1893, 1891, 35, 1377, 1360, 1358, 1327, 1325,
1322, 1331, 1277, 1275, 1272, 1269, 235, 1284, 2110,
1205, 1204, 1201, 1198, 182, 1195, 179, 1213, 2070,
2067, 1580, 501, 1551, 1548, 440, 437, 1497, 1494,
1490, 1503, 761, 709, 707, 1706, 913, 912, 2198,
1386, 2164, 2161, 1621, 1766, 2103, 1208, 2058, 2054,
1145, 1142, 2005, 2002, 1999, 2009, 1488, 1429, 1426,
2200, 1698, 1659, 1656, 1975, 1053, 1957, 1954, 1001,
998, 1924, 1921, 1918, 1928, 937, 934, 931, 1879,
1876, 1873, 1870, 945, 1885, 1882, 1323, 1273, 1270,
2105, 1202, 1199, 1196, 1211, 2061, 2057, 1576, 1543,
1540, 1484, 1481, 1478, 1491, 1700
};
const int BitMatrixParser::SYMBOL_TABLE_LENGTH =
sizeof(BitMatrixParser::SYMBOL_TABLE) / sizeof(int);
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/pdf417/decoder/BitMatrixParser2.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 34,151
|
```objective-c
#ifndef __LINESSAMPLER_H__
#define __LINESSAMPLER_H__
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <map>
#include <zxing/common/BitMatrix.h>
#include <zxing/ResultPoint.h>
#include <zxing/common/Point.h>
namespace zxing {
namespace pdf417 {
namespace detector {
class LinesSampler {
protected:
enum {
MODULES_IN_SYMBOL = 17,
BARS_IN_SYMBOL = 8,
POSSIBLE_SYMBOLS = 2787,
BARCODE_START_OFFSET = 2
};
static const std::vector<float> RATIOS_TABLE;
static std::vector<float> init_ratios_table();
Ref<BitMatrix> linesMatrix_;
int symbolsPerLine_;
int dimension_;
static std::vector<Ref<ResultPoint> > findVertices(Ref<BitMatrix> matrix, int rowStep);
static std::vector<Ref<ResultPoint> > findVertices180(Ref<BitMatrix> matrix, int rowStep);
static ArrayRef<int> findGuardPattern(Ref<BitMatrix> matrix,
int column,
int row,
int width,
bool whiteFirst,
const int pattern[],
int patternSize,
ArrayRef<int> counters);
static int patternMatchVariance(ArrayRef<int> counters, const int pattern[],
int maxIndividualVariance);
static void correctVertices(Ref<BitMatrix> matrix,
std::vector<Ref<ResultPoint> > &vertices,
bool upsideDown);
static void findWideBarTopBottom(Ref<BitMatrix> matrix,
std::vector<Ref<ResultPoint> > &vertices,
int offsetVertice,
int startWideBar,
int lenWideBar,
int lenPattern,
int nIncrement);
static void findCrossingPoint(std::vector<Ref<ResultPoint> > &vertices,
int idxResult,
int idxLineA1,int idxLineA2,
int idxLineB1,int idxLineB2,
Ref<BitMatrix> matrix);
static float computeModuleWidth(std::vector<Ref<ResultPoint> > &vertices);
static int computeDimension(Ref<ResultPoint> topLeft,
Ref<ResultPoint> topRight,
Ref<ResultPoint> bottomLeft,
Ref<ResultPoint> bottomRight,
float moduleWidth);
int computeYDimension(Ref<ResultPoint> topLeft,
Ref<ResultPoint> topRight,
Ref<ResultPoint> bottomLeft,
Ref<ResultPoint> bottomRight,
float moduleWidth);
Ref<BitMatrix> sampleLines(std::vector<Ref<ResultPoint> > const &vertices,
int dimensionY,
int dimension);
static void codewordsToBitMatrix(std::vector<std::vector<int> > &codewords,
Ref<BitMatrix> &matrix);
static int calculateClusterNumber(int codeword);
static Ref<BitMatrix> sampleGrid(Ref<BitMatrix> image,
int dimension);
static void computeSymbolWidths(std::vector<float>& symbolWidths,
const int symbolsPerLine, Ref<BitMatrix> linesMatrix);
static void linesMatrixToCodewords(std::vector<std::vector<int> > &clusterNumbers,
const int symbolsPerLine,
const std::vector<float> &symbolWidths,
Ref<BitMatrix> linesMatrix,
std::vector<std::vector<int> > &codewords);
static std::vector<std::vector<std::map<int, int> > >
distributeVotes(const int symbolsPerLine,
const std::vector<std::vector<int> >& codewords,
const std::vector<std::vector<int> >& clusterNumbers);
static std::vector<int>
findMissingLines(const int symbolsPerLine,
std::vector<std::vector<int> > &detectedCodeWords);
static int decodeRowCount(const int symbolsPerLine,
std::vector<std::vector<int> > &detectedCodeWords,
std::vector<int> &insertLinesAt);
static int round(float d);
static Point intersection(Line a, Line b);
public:
LinesSampler(Ref<BitMatrix> linesMatrix, int dimension);
Ref<BitMatrix> sample();
};
}
}
}
#endif // __LINESSAMPLER_H__
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/pdf417/detector/LinesSampler.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 932
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <map>
#include <zxing/pdf417/detector/LinesSampler.h>
#include <zxing/pdf417/decoder/BitMatrixParser.h>
#include <zxing/NotFoundException.h>
#include <zxing/common/Point.h>
#include <algorithm>
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;
using zxing::BitMatrix;
using zxing::NotFoundException;
using zxing::Point;
// VC++
using zxing::Line;
namespace {
class VoteResult {
private:
bool indecisive;
int vote;
public:
VoteResult() : indecisive(false), vote(0) {}
bool isIndecisive() {
return indecisive;
}
void setIndecisive(bool indecisive) {
this->indecisive = indecisive;
}
int getVote() {
return vote;
}
void setVote(int vote) {
this->vote = vote;
}
};
VoteResult getValueWithMaxVotes(map<int, int>& votes) {
VoteResult result;
int maxVotes = 0;
for (map<int, int>::iterator i = votes.begin(); i != votes.end(); i++) {
if (i->second > maxVotes) {
maxVotes = i->second;
result.setVote(i->first);
result.setIndecisive(false);
} else if (i->second == maxVotes) {
result.setIndecisive(true);
}
}
return result;
}
}
vector<float> LinesSampler::init_ratios_table() {
// Pre-computes and outputs the symbol ratio table.
vector<vector<float> > table (BitMatrixParser::SYMBOL_TABLE_LENGTH);
for(int i=0; i < (int)table.size(); ++i) {
table[i].resize(LinesSampler::BARS_IN_SYMBOL);
}
vector<float> RATIOS_TABLE (BitMatrixParser::SYMBOL_TABLE_LENGTH * LinesSampler::BARS_IN_SYMBOL);
int x = 0;
for (int i = 0; i < BitMatrixParser::SYMBOL_TABLE_LENGTH; i++) {
int currentSymbol = BitMatrixParser::SYMBOL_TABLE[i];
int currentBit = currentSymbol & 0x1;
for (int j = 0; j < BARS_IN_SYMBOL; j++) {
float size = 0.0f;
while ((currentSymbol & 0x1) == currentBit) {
size += 1.0f;
currentSymbol >>= 1;
}
currentBit = currentSymbol & 0x1;
table[i][BARS_IN_SYMBOL - j - 1] = size / MODULES_IN_SYMBOL;
}
for (int j = 0; j < BARS_IN_SYMBOL; j++) {
RATIOS_TABLE[x] = table[i][j];
x++;
}
}
return RATIOS_TABLE;
}
const vector<float> LinesSampler::RATIOS_TABLE = init_ratios_table();
LinesSampler::LinesSampler(Ref<BitMatrix> linesMatrix, int dimension)
: linesMatrix_(linesMatrix), dimension_(dimension) {}
/**
* Samples a grid from a lines matrix.
*
* @return the potentially decodable bit matrix.
*/
Ref<BitMatrix> LinesSampler::sample() {
const int symbolsPerLine = dimension_ / MODULES_IN_SYMBOL;
// XXX
vector<float> symbolWidths;
computeSymbolWidths(symbolWidths, symbolsPerLine, linesMatrix_);
// XXX
vector<vector<int> > codewords(linesMatrix_->getHeight());
vector<vector<int> > clusterNumbers(linesMatrix_->getHeight());
linesMatrixToCodewords(clusterNumbers, symbolsPerLine, symbolWidths, linesMatrix_, codewords);
// XXX
vector<vector<map<int, int> > > votes =
distributeVotes(symbolsPerLine, codewords, clusterNumbers);
// XXX
vector<vector<int> > detectedCodeWords(votes.size());
for (int i = 0; i < (int)votes.size(); i++) {
detectedCodeWords[i].resize(votes[i].size(), 0);
for (int j = 0; j < (int)votes[i].size(); j++) {
if (!votes[i][j].empty()) {
detectedCodeWords[i][j] = getValueWithMaxVotes(votes[i][j]).getVote();
}
}
}
// XXX
vector<int> insertLinesAt = findMissingLines(symbolsPerLine, detectedCodeWords);
// XXX
int rowCount = decodeRowCount(symbolsPerLine, detectedCodeWords, insertLinesAt);
detectedCodeWords.resize(rowCount);
// XXX
Ref<BitMatrix> grid(new BitMatrix(dimension_, detectedCodeWords.size()));
codewordsToBitMatrix(detectedCodeWords, grid);
return grid;
}
/**
* @brief LinesSampler::codewordsToBitMatrix
* @param codewords
* @param matrix
*/
void LinesSampler::codewordsToBitMatrix(vector<vector<int> > &codewords, Ref<BitMatrix> &matrix) {
for (int i = 0; i < (int)codewords.size(); i++) {
for (int j = 0; j < (int)codewords[i].size(); j++) {
int moduleOffset = j * MODULES_IN_SYMBOL;
for (int k = 0; k < MODULES_IN_SYMBOL; k++) {
if ((codewords[i][j] & (1 << (MODULES_IN_SYMBOL - k - 1))) > 0) {
matrix->set(moduleOffset + k, i);
}
}
}
}
}
/**
* @brief LinesSampler::calculateClusterNumber
* @param codeword
* @return
*/
int LinesSampler::calculateClusterNumber(int codeword) {
if (codeword == 0) {
return -1;
}
int barNumber = 0;
bool blackBar = true;
int clusterNumber = 0;
for (int i = 0; i < MODULES_IN_SYMBOL; i++) {
if ((codeword & (1 << i)) > 0) {
if (!blackBar) {
blackBar = true;
barNumber++;
}
if (barNumber % 2 == 0) {
clusterNumber++;
} else {
clusterNumber--;
}
} else {
if (blackBar) {
blackBar = false;
}
}
}
return (clusterNumber + 9) % 9;
}
//#define OUTPUT_SYMBOL_WIDTH 1
//#define OUTPUT_BAR_WIDTH 1
//#define OUTPUT_CW_STARTS 1
//#define OUTPUT_CLUSTER_NUMBERS 1
//#define OUTPUT_EC_LEVEL 1
void LinesSampler::computeSymbolWidths(vector<float> &symbolWidths, const int symbolsPerLine, Ref<BitMatrix> linesMatrix)
{
int symbolStart = 0;
bool lastWasSymbolStart = true;
const float symbolWidth = symbolsPerLine > 0 ? (float)linesMatrix->getWidth() / (float)symbolsPerLine : (float)linesMatrix->getWidth();
// Use the following property of PDF417 barcodes to detect symbols:
// Every symbol starts with a black module and every symbol is 17 modules wide,
// therefore there have to be columns in the line matrix that are completely composed of black pixels.
vector<int> blackCount(linesMatrix->getWidth(), 0);
for (int x = BARCODE_START_OFFSET; x < linesMatrix->getWidth(); x++) {
for (int y = 0; y < linesMatrix->getHeight(); y++) {
if (linesMatrix->get(x, y)) {
blackCount[x]++;
}
}
if (blackCount[x] == linesMatrix->getHeight()) {
if (!lastWasSymbolStart) {
float currentWidth = (float)(x - symbolStart);
// Make sure we really found a symbol by asserting a minimal size of 75% of the expected symbol width.
// This might break highly distorted barcodes, but fixes an issue with barcodes where there is a
// full black column from top to bottom within a symbol.
if (currentWidth > 0.75 * symbolWidth) {
// The actual symbol width might be slightly bigger than the expected symbol width,
// but if we are more than half an expected symbol width bigger, we assume that
// we missed one or more symbols and assume that they were the expected symbol width.
while (currentWidth > 1.5 * symbolWidth) {
symbolWidths.push_back(symbolWidth);
currentWidth -= symbolWidth;
}
symbolWidths.push_back(currentWidth);
lastWasSymbolStart = true;
symbolStart = x;
}
}
} else {
if (lastWasSymbolStart) {
lastWasSymbolStart = false;
}
}
}
// The last symbol ends at the right edge of the matrix, where there usually is no black bar.
float currentWidth = (float)(linesMatrix->getWidth() - symbolStart);
while (currentWidth > 1.5 * symbolWidth) {
symbolWidths.push_back(symbolWidth);
currentWidth -= symbolWidth;
}
symbolWidths.push_back(currentWidth);
#if PDF417_DIAG && OUTPUT_SYMBOL_WIDTH
{
cout << "symbols per line: " << symbolsPerLine << endl;
cout << "symbol width (" << symbolWidths.size() << "): ";
for (int i = 0; i < symbolWidths.size(); i++) {
cout << symbolWidths[i] << ", ";
}
cout << endl;
}
#endif
}
void LinesSampler::linesMatrixToCodewords(vector<vector<int> >& clusterNumbers,
const int symbolsPerLine,
const vector<float>& symbolWidths,
Ref<BitMatrix> linesMatrix,
vector<vector<int> >& codewords)
{
for (int y = 0; y < linesMatrix->getHeight(); y++) {
// Not sure if this is the right way to handle this but avoids an error:
if (symbolsPerLine > (int)symbolWidths.size()) {
throw NotFoundException("Inconsistent number of symbols in this line.");
}
// TODO: use symbolWidths.size() instead of symbolsPerLine to at least decode some codewords
codewords[y].resize(symbolsPerLine, 0);
clusterNumbers[y].resize(symbolsPerLine, -1);
int line = y;
vector<int> barWidths(1, 0);
int barCount = 0;
// Runlength encode the bars in the scanned linesMatrix.
// We assume that the first bar is black, as determined by the PDF417 standard.
bool isSetBar = true;
// Filter small white bars at the beginning of the barcode.
// Small white bars may occur due to small deviations in scan line sampling.
barWidths[0] += BARCODE_START_OFFSET;
for (int x = BARCODE_START_OFFSET; x < linesMatrix->getWidth(); x++) {
if (linesMatrix->get(x, line)) {
if (!isSetBar) {
isSetBar = true;
barCount++;
barWidths.resize(barWidths.size() + 1);
}
} else {
if (isSetBar) {
isSetBar = false;
barCount++;
barWidths.resize(barWidths.size() + 1);
}
}
barWidths[barCount]++;
}
// Don't forget the last bar.
barCount++;
barWidths.resize(barWidths.size() + 1);
#if PDF417_DIAG && OUTPUT_BAR_WIDTH
{
for (int i = 0; i < barWidths.size(); i++) {
cout << barWidths[i] << ", ";
}
cout << endl;
}
#endif
//////////////////////////////////////////////////
// Find the symbols in the line by counting bar lengths until we reach symbolWidth.
// We make sure, that the last bar of a symbol is always white, as determined by the PDF417 standard.
// This helps to reduce the amount of errors done during the symbol recognition.
// The symbolWidth usually is not constant over the width of the barcode.
int cwWidth = 0;
int cwCount = 0;
vector<int> cwStarts(symbolsPerLine, 0);
cwStarts[0] = 0;
cwCount++;
for (int i = 0; i < barCount && cwCount < symbolsPerLine; i++) {
cwWidth += barWidths[i];
if ((float)cwWidth > symbolWidths[cwCount - 1]) {
if ((i % 2) == 1) { // check if bar is white
i++;
}
cwWidth = barWidths[i];
cwStarts[cwCount] = i;
cwCount++;
}
}
#if PDF417_DIAG && OUTPUT_CW_STARTS
{
for (int i = 0; i < cwStarts.size(); i++) {
cout << cwStarts[i] << ", ";
}
cout << endl;
}
#endif
///////////////////////////////////////////
vector<vector<float> > cwRatios(symbolsPerLine);
// Distribute bar widths to modules of a codeword.
for (int i = 0; i < symbolsPerLine; i++) {
cwRatios[i].resize(BARS_IN_SYMBOL, 0.0f);
const int cwStart = cwStarts[i];
const int cwEnd = (i == symbolsPerLine - 1) ? barCount : cwStarts[i + 1];
const int cwLength = cwEnd - cwStart;
if (cwLength < 7 || cwLength > 9) {
// We try to recover smybols with 7 or 9 bars and spaces with heuristics, but everything else is beyond repair.
continue;
}
float cwWidth = 0;
// For symbols with 9 bar length simply ignore the last bar.
for (int j = 0; j < min((int)LinesSampler::BARS_IN_SYMBOL, cwLength); ++j) {
cwWidth += (float)barWidths[cwStart + j];
}
// If there were only 7 bars and spaces detected use the following heuristic:
// Assume the length of the symbol is symbolWidth and the last (unrecognized) bar uses all remaining space.
if (cwLength == 7) {
for (int j = 0; j < cwLength; ++j) {
cwRatios[i][j] = (float)barWidths[cwStart + j] / symbolWidths[i];
}
cwRatios[i][7] = (symbolWidths[i] - cwWidth) / symbolWidths[i];
} else {
for (int j = 0; j < (int)cwRatios[i].size(); ++j) {
cwRatios[i][j] = (float)barWidths[cwStart + j] / cwWidth;
}
}
float bestMatchError = std::numeric_limits<float>::max();
int bestMatch = 0;
// Search for the most possible codeword by comparing the ratios of bar size to symbol width.
// The sum of the squared differences is used as similarity metric.
// (Picture it as the square euclidian distance in the space of eight tuples where a tuple represents the bar ratios.)
for (int j = 0; j < POSSIBLE_SYMBOLS; j++) {
float error = 0.0f;
for (int k = 0; k < BARS_IN_SYMBOL; k++) {
float diff = RATIOS_TABLE[j * BARS_IN_SYMBOL + k] - cwRatios[i][k];
error += diff * diff;
if (error >= bestMatchError) {
break;
}
}
if (error < bestMatchError) {
bestMatchError = error;
bestMatch = BitMatrixParser::SYMBOL_TABLE[j];
}
}
codewords[y][i] = bestMatch;
clusterNumbers[y][i] = calculateClusterNumber(bestMatch);
}
}
#if PDF417_DIAG && OUTPUT_CLUSTER_NUMBERS
{
for (int i = 0; i < clusterNumbers.size(); i++) {
for (int j = 0; j < clusterNumbers[i].size(); j++) {
cout << clusterNumbers[i][j] << ", ";
}
cout << endl;
}
}
#endif
#if PDF417_DIAG
{
Ref<BitMatrix> bits(new BitMatrix(symbolsPerLine * MODULES_IN_SYMBOL, codewords.size()));
codewordsToBitMatrix(codewords, bits);
static int __cnt__ = 0;
stringstream ss;
ss << "pdf417-detectedRaw" << __cnt__++ << ".png";
bits->writePng(ss.str().c_str(), 8, 16);
}
#endif
}
vector<vector<map<int, int> > >
LinesSampler::distributeVotes(const int symbolsPerLine,
const vector<vector<int> >& codewords,
const vector<vector<int> >& clusterNumbers)
{
// Matrix of votes for codewords which are possible at this position.
vector<vector<map<int, int> > > votes(1);
votes[0].resize(symbolsPerLine);
int currentRow = 0;
map<int, int> clusterNumberVotes;
int lastLineClusterNumber = -1;
for (int y = 0; y < (int)codewords.size(); y++) {
// Vote for the most probable cluster number for this row.
clusterNumberVotes.clear();
for (int i = 0; i < (int)codewords[y].size(); i++) {
if (clusterNumbers[y][i] != -1) {
clusterNumberVotes[clusterNumbers[y][i]] = clusterNumberVotes[clusterNumbers[y][i]] + 1;
}
}
// Ignore lines where no codeword could be read.
if (!clusterNumberVotes.empty()) {
VoteResult voteResult = getValueWithMaxVotes(clusterNumberVotes);
bool lineClusterNumberIsIndecisive = voteResult.isIndecisive();
int lineClusterNumber = voteResult.getVote();
// If there are to few votes on the lines cluster number, we keep the old one.
// This avoids switching lines because of damaged inter line readings, but
// may cause problems for barcodes with four or less rows.
if (lineClusterNumberIsIndecisive) {
lineClusterNumber = lastLineClusterNumber;
}
if ((lineClusterNumber != ((lastLineClusterNumber + 3) % 9)) && (lastLineClusterNumber != -1)) {
lineClusterNumber = lastLineClusterNumber;
}
// Ignore broken lines at the beginning of the barcode.
if ((lineClusterNumber == 0 && lastLineClusterNumber == -1) || (lastLineClusterNumber != -1)) {
if ((lineClusterNumber == ((lastLineClusterNumber + 3) % 9)) && (lastLineClusterNumber != -1)) {
currentRow++;
if ((int)votes.size() < currentRow + 1) {
votes.resize(currentRow + 1);
votes[currentRow].resize(symbolsPerLine);
}
}
if ((lineClusterNumber == ((lastLineClusterNumber + 6) % 9)) && (lastLineClusterNumber != -1)) {
currentRow += 2;
if ((int)votes.size() < currentRow + 1) {
votes.resize(currentRow + 1);
votes[currentRow].resize(symbolsPerLine);
}
}
for (int i = 0; i < (int)codewords[y].size(); i++) {
if (clusterNumbers[y][i] != -1) {
if (clusterNumbers[y][i] == lineClusterNumber) {
votes[currentRow][i][codewords[y][i]] = votes[currentRow][i][codewords[y][i]] + 1;
} else if (clusterNumbers[y][i] == ((lineClusterNumber + 3) % 9)) {
if ((int)votes.size() < currentRow + 2) {
votes.resize(currentRow + 2);
votes[currentRow + 1].resize(symbolsPerLine);
}
votes[currentRow + 1][i][codewords[y][i]] = votes[currentRow + 1][i][codewords[y][i]] + 1;
} else if ((clusterNumbers[y][i] == ((lineClusterNumber + 6) % 9)) && (currentRow > 0)) {
votes[currentRow - 1][i][codewords[y][i]] = votes[currentRow - 1][i][codewords[y][i]] + 1;
}
}
}
lastLineClusterNumber = lineClusterNumber;
}
}
}
return votes;
}
vector<int>
LinesSampler::findMissingLines(const int symbolsPerLine, vector<vector<int> > &detectedCodeWords) {
vector<int> insertLinesAt;
if (detectedCodeWords.size() > 1) {
for (int i = 0; i < (int)detectedCodeWords.size() - 1; i++) {
int clusterNumberRow = -1;
for (int j = 0; j < (int)detectedCodeWords[i].size() && clusterNumberRow == -1; j++) {
int clusterNumber = calculateClusterNumber(detectedCodeWords[i][j]);
if (clusterNumber != -1) {
clusterNumberRow = clusterNumber;
}
}
if (i == 0) {
// The first line must have the cluster number 0. Insert empty lines to match this.
if (clusterNumberRow > 0) {
insertLinesAt.push_back(0);
if (clusterNumberRow > 3) {
insertLinesAt.push_back(0);
}
}
}
int clusterNumberNextRow = -1;
for (int j = 0; j < (int)detectedCodeWords[i + 1].size() && clusterNumberNextRow == -1; j++) {
int clusterNumber = calculateClusterNumber(detectedCodeWords[i + 1][j]);
if (clusterNumber != -1) {
clusterNumberNextRow = clusterNumber;
}
}
if ((clusterNumberRow + 3) % 9 != clusterNumberNextRow
&& clusterNumberRow != -1
&& clusterNumberNextRow != -1) {
// The cluster numbers are not consecutive. Insert an empty line between them.
insertLinesAt.push_back(i + 1);
if (clusterNumberRow == clusterNumberNextRow) {
// There may be two lines missing. This is detected when two consecutive lines have the same cluster number.
insertLinesAt.push_back(i + 1);
}
}
}
}
for (int i = 0; i < (int)insertLinesAt.size(); i++) {
detectedCodeWords.insert(detectedCodeWords.begin() + insertLinesAt[i] + i, vector<int>(symbolsPerLine, 0));
}
return insertLinesAt;
}
int LinesSampler::decodeRowCount(const int symbolsPerLine, vector<vector<int> > &detectedCodeWords, vector<int> &insertLinesAt)
{
// Use the information in the first and last column to determin the number of rows and find more missing rows.
// For missing rows insert blank space, so the error correction can try to fill them in.
map<int, int> rowCountVotes;
map<int, int> ecLevelVotes;
map<int, int> rowNumberVotes;
int lastRowNumber = -1;
insertLinesAt.clear();
for (int i = 0; i + 2 < (int)detectedCodeWords.size(); i += 3) {
rowNumberVotes.clear();
int firstCodewordDecodedLeft = -1;
int secondCodewordDecodedLeft = -1;
int thirdCodewordDecodedLeft = -1;
int firstCodewordDecodedRight = -1;
int secondCodewordDecodedRight = -1;
int thirdCodewordDecodedRight = -1;
if (detectedCodeWords[i][0] != 0) {
firstCodewordDecodedLeft = BitMatrixParser::getCodeword(detectedCodeWords[i][0]);
}
if (detectedCodeWords[i + 1][0] != 0) {
secondCodewordDecodedLeft = BitMatrixParser::getCodeword(detectedCodeWords[i + 1][0]);
}
if (detectedCodeWords[i + 2][0] != 0) {
thirdCodewordDecodedLeft = BitMatrixParser::getCodeword(detectedCodeWords[i + 2][0]);
}
if (detectedCodeWords[i][detectedCodeWords[i].size() - 1] != 0) {
firstCodewordDecodedRight = BitMatrixParser::getCodeword(detectedCodeWords[i][detectedCodeWords[i].size() - 1]);
}
if (detectedCodeWords[i + 1][detectedCodeWords[i + 1].size() - 1] != 0) {
secondCodewordDecodedRight = BitMatrixParser::getCodeword(detectedCodeWords[i + 1][detectedCodeWords[i + 1].size() - 1]);
}
if (detectedCodeWords[i + 2][detectedCodeWords[i + 2].size() - 1] != 0) {
thirdCodewordDecodedRight = BitMatrixParser::getCodeword(detectedCodeWords[i + 2][detectedCodeWords[i + 2].size() - 1]);
}
if (firstCodewordDecodedLeft != -1 && secondCodewordDecodedLeft != -1) {
int leftRowCount = ((firstCodewordDecodedLeft % 30) * 3) + ((secondCodewordDecodedLeft % 30) % 3);
int leftECLevel = (secondCodewordDecodedLeft % 30) / 3;
rowCountVotes[leftRowCount] = rowCountVotes[leftRowCount] + 1;
ecLevelVotes[leftECLevel] = ecLevelVotes[leftECLevel] + 1;
}
if (secondCodewordDecodedRight != -1 && thirdCodewordDecodedRight != -1) {
int rightRowCount = ((secondCodewordDecodedRight % 30) * 3) + ((thirdCodewordDecodedRight % 30) % 3);
int rightECLevel = (thirdCodewordDecodedRight % 30) / 3;
rowCountVotes[rightRowCount] = rowCountVotes[rightRowCount] + 1;
ecLevelVotes[rightECLevel] = ecLevelVotes[rightECLevel] + 1;
}
if (firstCodewordDecodedLeft != -1) {
int rowNumber = firstCodewordDecodedLeft / 30;
rowNumberVotes[rowNumber] = rowNumberVotes[rowNumber] + 1;
}
if (secondCodewordDecodedLeft != -1) {
int rowNumber = secondCodewordDecodedLeft / 30;
rowNumberVotes[rowNumber] = rowNumberVotes[rowNumber] + 1;
}
if (thirdCodewordDecodedLeft != -1) {
int rowNumber = thirdCodewordDecodedLeft / 30;
rowNumberVotes[rowNumber] = rowNumberVotes[rowNumber] + 1;
}
if (firstCodewordDecodedRight != -1) {
int rowNumber = firstCodewordDecodedRight / 30;
rowNumberVotes[rowNumber] = rowNumberVotes[rowNumber] + 1;
}
if (secondCodewordDecodedRight != -1) {
int rowNumber = secondCodewordDecodedRight / 30;
rowNumberVotes[rowNumber] = rowNumberVotes[rowNumber] + 1;
}
if (thirdCodewordDecodedRight != -1) {
int rowNumber = thirdCodewordDecodedRight / 30;
rowNumberVotes[rowNumber] = rowNumberVotes[rowNumber] + 1;
}
int rowNumber = getValueWithMaxVotes(rowNumberVotes).getVote();
if (lastRowNumber + 1 < rowNumber) {
for (int j = lastRowNumber + 1; j < rowNumber; j++) {
insertLinesAt.push_back(i);
insertLinesAt.push_back(i);
insertLinesAt.push_back(i);
}
}
lastRowNumber = rowNumber;
}
for (int i = 0; i < (int)insertLinesAt.size(); i++) {
detectedCodeWords.insert(detectedCodeWords.begin() + insertLinesAt[i] + i, vector<int>(symbolsPerLine, 0));
}
int rowCount = getValueWithMaxVotes(rowCountVotes).getVote();
// int ecLevel = getValueWithMaxVotes(ecLevelVotes);
#if PDF417_DIAG && OUTPUT_EC_LEVEL
{
cout << "EC Level: " << ecLevel << " (" << ((1 << (ecLevel + 1)) - 2) << " EC Codewords)" << endl;
}
#endif
rowCount += 1;
return rowCount;
}
/**
* Ends up being a bit faster than Math.round(). This merely rounds its
* argument to the nearest int, where x.5 rounds up.
*/
int LinesSampler::round(float d)
{
return (int)(d + 0.5f);
}
Point LinesSampler::intersection(Line a, Line b) {
float dxa = a.start.x - a.end.x;
float dxb = b.start.x - b.end.x;
float dya = a.start.y - a.end.y;
float dyb = b.start.y - b.end.y;
float p = a.start.x * a.end.y - a.start.y * a.end.x;
float q = b.start.x * b.end.y - b.start.y * b.end.x;
float denom = dxa * dyb - dya * dxb;
if(abs(denom) < 1e-12) // Lines don't intersect (replaces "denom == 0")
return Point(std::numeric_limits<float>::infinity(),
std::numeric_limits<float>::infinity());
float x = (p * dxb - dxa * q) / denom;
float y = (p * dyb - dya * q) / denom;
return Point(x, y);
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/pdf417/detector/LinesSampler.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 6,846
|
```objective-c
#ifndef __DETECTOR_PDF417_H__
#define __DETECTOR_PDF417_H__
/*
* Detector.h
* zxing
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/common/Point.h>
#include <zxing/common/DetectorResult.h>
#include <zxing/NotFoundException.h>
#include <zxing/BinaryBitmap.h>
#include <zxing/DecodeHints.h>
namespace zxing {
namespace pdf417 {
namespace detector {
class Detector {
protected:
static const int INTEGER_MATH_SHIFT = 8;
static const int PATTERN_MATCH_RESULT_SCALE_FACTOR = 1 << INTEGER_MATH_SHIFT;
static const int MAX_AVG_VARIANCE;
static const int MAX_INDIVIDUAL_VARIANCE;
static const int START_PATTERN[];
static const int START_PATTERN_LENGTH;
static const int START_PATTERN_REVERSE[];
static const int START_PATTERN_REVERSE_LENGTH;
static const int STOP_PATTERN[];
static const int STOP_PATTERN_LENGTH;
static const int STOP_PATTERN_REVERSE[];
static const int STOP_PATTERN_REVERSE_LENGTH;
Ref<BinaryBitmap> image_;
static ArrayRef< Ref<ResultPoint> > findVertices(Ref<BitMatrix> matrix, int rowStep);
static ArrayRef< Ref<ResultPoint> > findVertices180(Ref<BitMatrix> matrix, int rowStep);
static ArrayRef<int> findGuardPattern(Ref<BitMatrix> matrix,
int column,
int row,
int width,
bool whiteFirst,
const int pattern[],
int patternSize,
ArrayRef<int>& counters);
static int patternMatchVariance(ArrayRef<int>& counters, const int pattern[],
int maxIndividualVariance);
static void correctVertices(Ref<BitMatrix> matrix,
ArrayRef< Ref<ResultPoint> >& vertices,
bool upsideDown);
static void findWideBarTopBottom(Ref<BitMatrix> matrix,
ArrayRef< Ref<ResultPoint> >& vertices,
int offsetVertice,
int startWideBar,
int lenWideBar,
int lenPattern,
int nIncrement);
static void findCrossingPoint(ArrayRef< Ref<ResultPoint> >& vertices,
int idxResult,
int idxLineA1,int idxLineA2,
int idxLineB1,int idxLineB2,
Ref<BitMatrix>& matrix);
static Point intersection(Line a, Line b);
static float computeModuleWidth(ArrayRef< Ref<ResultPoint> >& vertices);
static int computeDimension(Ref<ResultPoint> const& topLeft,
Ref<ResultPoint> const& topRight,
Ref<ResultPoint> const& bottomLeft,
Ref<ResultPoint> const& bottomRight,
float moduleWidth);
int computeYDimension(Ref<ResultPoint> const& topLeft,
Ref<ResultPoint> const& topRight,
Ref<ResultPoint> const& bottomLeft,
Ref<ResultPoint> const& bottomRight,
float moduleWidth);
Ref<BitMatrix> sampleLines(ArrayRef< Ref<ResultPoint> > const& vertices, int dimensionY, int dimension);
public:
Detector(Ref<BinaryBitmap> image);
Ref<BinaryBitmap> getImage();
Ref<DetectorResult> detect();
Ref<DetectorResult> detect(DecodeHints const& hints);
};
}
}
}
#endif // __DETECTOR_PDF417_H__
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/pdf417/detector/Detector.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 733
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
* AtztecDetecorResult.cpp
* zxing
*
* Created by Lukas Stabe on 08/02/2012.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/aztec/AztecDetectorResult.h>
using zxing::aztec::AztecDetectorResult;
// VC++
using zxing::Ref;
using zxing::ArrayRef;
using zxing::BitMatrix;
using zxing::ResultPoint;
AztecDetectorResult::AztecDetectorResult(Ref<BitMatrix> bits,
ArrayRef< Ref<ResultPoint> > points,
bool compact,
int nbDatablocks,
int nbLayers)
: DetectorResult(bits, points),
compact_(compact),
nbDatablocks_(nbDatablocks),
nbLayers_(nbLayers) {
}
bool AztecDetectorResult::isCompact() {
return compact_;
}
int AztecDetectorResult::getNBDatablocks() {
return nbDatablocks_;
}
int AztecDetectorResult::getNBLayers() {
return nbLayers_;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/aztec/AztecDetectorResult.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 286
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
* AztecReader.h
* zxing
*
* Created by Lukas Stabe on 08/02/2012.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/Reader.h>
#include <zxing/aztec/decoder/Decoder.h>
#include <zxing/DecodeHints.h>
#ifndef ZXingWidget_AztecReader_h
#define ZXingWidget_AztecReader_h
namespace zxing {
namespace aztec {
class AztecReader : public Reader {
private:
Decoder decoder_;
protected:
Decoder &getDecoder();
public:
AztecReader();
virtual Ref<Result> decode(Ref<BinaryBitmap> image);
virtual Ref<Result> decode(Ref<BinaryBitmap> image, DecodeHints hints);
virtual ~AztecReader();
};
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/aztec/AztecReader.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 226
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
* AztecReader.cpp
* zxing
*
* Created by Lukas Stabe on 08/02/2012.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/aztec/AztecReader.h>
#include <zxing/aztec/detector/Detector.h>
#include <zxing/common/DecoderResult.h>
#include <iostream>
using zxing::Ref;
using zxing::ArrayRef;
using zxing::Result;
using zxing::aztec::AztecReader;
// VC++
using zxing::BinaryBitmap;
using zxing::DecodeHints;
AztecReader::AztecReader() : decoder_() {
// nothing
}
Ref<Result> AztecReader::decode(Ref<zxing::BinaryBitmap> image) {
Detector detector(image->getBlackMatrix());
Ref<AztecDetectorResult> detectorResult(detector.detect());
ArrayRef< Ref<ResultPoint> > points(detectorResult->getPoints());
Ref<DecoderResult> decoderResult(decoder_.decode(detectorResult));
Ref<Result> result(new Result(decoderResult->getText(),
decoderResult->getRawBytes(),
points,
BarcodeFormat::AZTEC));
return result;
}
Ref<Result> AztecReader::decode(Ref<BinaryBitmap> image, DecodeHints) {
//cout << "decoding with hints not supported for aztec" << "\n" << flush;
return this->decode(image);
}
AztecReader::~AztecReader() {
// nothing
}
zxing::aztec::Decoder& AztecReader::getDecoder() {
return decoder_;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/aztec/AztecReader.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 406
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
* AtztecDetecorResult.h
* zxing
*
* Created by Lukas Stabe on 08/02/2012.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/common/DetectorResult.h>
#ifndef ZXingWidget_AtztecDetecorResult_h
#define ZXingWidget_AtztecDetecorResult_h
namespace zxing {
namespace aztec {
class AztecDetectorResult : public DetectorResult {
private:
bool compact_;
int nbDatablocks_, nbLayers_;
public:
AztecDetectorResult(Ref<BitMatrix> bits,
ArrayRef< Ref<ResultPoint> > points,
bool compact,
int nbDatablocks,
int nbLayers);
bool isCompact();
int getNBDatablocks();
int getNBLayers();
};
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/aztec/AztecDetectorResult.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 234
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <limits>
#include <zxing/pdf417/detector/Detector.h>
#include <zxing/pdf417/detector/LinesSampler.h>
#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;
using std::numeric_limits;
using zxing::pdf417::detector::Detector;
using zxing::common::detector::Math;
using zxing::common::detector::MathUtils;
using zxing::Ref;
using zxing::ArrayRef;
using zxing::DetectorResult;
using zxing::ResultPoint;
using zxing::Point;
using zxing::BitMatrix;
using zxing::GridSampler;
// VC++
using zxing::BinaryBitmap;
using zxing::DecodeHints;
using zxing::Line;
/**
* <p>Encapsulates logic that can detect a PDF417 Code in an image, even if the
* PDF417 Code is rotated or skewed, or partially obscured.</p>
*
* @author SITA Lab (kevin.osullivan@sita.aero)
* @author Daniel Switkin (dswitkin@google.com)
* @author Schweers Informationstechnologie GmbH (hartmut.neubauer@schweers.de)
* @author creatale GmbH (christoph.schulz@creatale.de)
*/
const int Detector::MAX_AVG_VARIANCE= (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.42f);
const int Detector::MAX_INDIVIDUAL_VARIANCE = (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.8f);
// B S B S B S B S Bar/Space pattern
// 11111111 0 1 0 1 0 1 000
const int Detector::START_PATTERN[] = {8, 1, 1, 1, 1, 1, 1, 3};
const int Detector::START_PATTERN_LENGTH = sizeof(START_PATTERN) / sizeof(int);
// 11111111 0 1 0 1 0 1 000
const int Detector::START_PATTERN_REVERSE[] = {3, 1, 1, 1, 1, 1, 1, 8};
const int Detector::START_PATTERN_REVERSE_LENGTH = sizeof(START_PATTERN_REVERSE) / sizeof(int);
// 1111111 0 1 000 1 0 1 00 1
const int Detector::STOP_PATTERN[] = {7, 1, 1, 3, 1, 1, 1, 2, 1};
const int Detector::STOP_PATTERN_LENGTH = sizeof(STOP_PATTERN) / sizeof(int);
// B S B S B S B S B Bar/Space pattern
// 1111111 0 1 000 1 0 1 00 1
const int Detector::STOP_PATTERN_REVERSE[] = {1, 2, 1, 1, 1, 3, 1, 1, 7};
const int Detector::STOP_PATTERN_REVERSE_LENGTH = sizeof(STOP_PATTERN_REVERSE) / sizeof(int);
Detector::Detector(Ref<BinaryBitmap> image) : image_(image) {}
Ref<DetectorResult> Detector::detect() {
return detect(DecodeHints());
}
Ref<DetectorResult> Detector::detect(DecodeHints const& hints) {
(void)hints;
// Fetch the 1 bit matrix once up front.
Ref<BitMatrix> matrix = image_->getBlackMatrix();
// Try to find the vertices assuming the image is upright.
const int rowStep = 8;
ArrayRef< Ref<ResultPoint> > vertices (findVertices(matrix, rowStep));
if (!vertices) {
// Maybe the image is rotated 180 degrees?
vertices = findVertices180(matrix, rowStep);
if (vertices) {
correctVertices(matrix, vertices, true);
}
} else {
correctVertices(matrix, vertices, false);
}
if (!vertices) {
throw NotFoundException("No vertices found.");
}
float moduleWidth = computeModuleWidth(vertices);
if (moduleWidth < 1.0f) {
throw NotFoundException("Bad module width.");
}
int dimension = computeDimension(vertices[12], vertices[14],
vertices[13], vertices[15], moduleWidth);
if (dimension < 1) {
throw NotFoundException("Bad dimension.");
}
int yDimension = max(computeYDimension(vertices[12], vertices[14],
vertices[13], vertices[15], moduleWidth), dimension);
// Deskew and sample lines from image.
Ref<BitMatrix> linesMatrix = sampleLines(vertices, dimension, yDimension);
Ref<BitMatrix> linesGrid(LinesSampler(linesMatrix, dimension).sample());
ArrayRef< Ref<ResultPoint> > points(4);
points[0] = vertices[5];
points[1] = vertices[4];
points[2] = vertices[6];
points[3] = vertices[7];
return Ref<DetectorResult>(new DetectorResult(linesGrid, points));
}
/**
* Locate the vertices and the codewords area of a black blob using the Start
* and Stop patterns as locators.
*
* @param matrix the scanned barcode image.
* @param rowStep the step size for iterating rows (every n-th row).
* @return an array containing the vertices:
* vertices[0] x, y top left barcode
* vertices[1] x, y bottom left barcode
* vertices[2] x, y top right barcode
* vertices[3] x, y bottom right barcode
* vertices[4] x, y top left codeword area
* vertices[5] x, y bottom left codeword area
* vertices[6] x, y top right codeword area
* vertices[7] x, y bottom right codeword area
*/
ArrayRef< Ref<ResultPoint> > Detector::findVertices(Ref<BitMatrix> matrix, int rowStep)
{
const int height = matrix->getHeight();
const int width = matrix->getWidth();
ArrayRef< Ref<ResultPoint> > result(16);
bool found = false;
ArrayRef<int> counters(new Array<int>(START_PATTERN_LENGTH));
// Top Left
for (int i = 0; i < height; i += rowStep) {
ArrayRef<int> loc = findGuardPattern(matrix, 0, i, width, false, START_PATTERN,
START_PATTERN_LENGTH, counters);
if (loc) {
result[0] = new ResultPoint((float)loc[0], (float)i);
result[4] = new ResultPoint((float)loc[1], (float)i);
found = true;
break;
}
}
// Bottom left
if (found) { // Found the Top Left vertex
found = false;
for (int i = height - 1; i > 0; i -= rowStep) {
ArrayRef<int> loc = findGuardPattern(matrix, 0, i, width, false, START_PATTERN,
START_PATTERN_LENGTH, counters);
if (loc) {
result[1] = new ResultPoint((float)loc[0], (float)i);
result[5] = new ResultPoint((float)loc[1], (float)i);
found = true;
break;
}
}
}
counters = new Array<int>(STOP_PATTERN_LENGTH);
// Top right
if (found) { // Found the Bottom Left vertex
found = false;
for (int i = 0; i < height; i += rowStep) {
ArrayRef<int> loc = findGuardPattern(matrix, 0, i, width, false, STOP_PATTERN,
STOP_PATTERN_LENGTH, counters);
if (loc) {
result[2] = new ResultPoint((float)loc[1], (float)i);
result[6] = new ResultPoint((float)loc[0], (float)i);
found = true;
break;
}
}
}
// Bottom right
if (found) { // Found the Top right vertex
found = false;
for (int i = height - 1; i > 0; i -= rowStep) {
ArrayRef<int> loc = findGuardPattern(matrix, 0, i, width, false, STOP_PATTERN,
STOP_PATTERN_LENGTH, counters);
if (loc) {
result[3] = new ResultPoint((float)loc[1], (float)i);
result[7] = new ResultPoint((float)loc[0], (float)i);
found = true;
break;
}
}
}
return found ? result : ArrayRef< Ref<ResultPoint> >();
}
ArrayRef< Ref<ResultPoint> > Detector::findVertices180(Ref<BitMatrix> matrix, int rowStep) {
const int height = matrix->getHeight();
const int width = matrix->getWidth();
const int halfWidth = width >> 1;
ArrayRef< Ref<ResultPoint> > result(16);
bool found = false;
ArrayRef<int> counters = new Array<int>(START_PATTERN_REVERSE_LENGTH);
// Top Left
for (int i = height - 1; i > 0; i -= rowStep) {
ArrayRef<int> loc =
findGuardPattern(matrix, halfWidth, i, halfWidth, true, START_PATTERN_REVERSE,
START_PATTERN_REVERSE_LENGTH, counters);
if (loc) {
result[0] = new ResultPoint((float)loc[1], (float)i);
result[4] = new ResultPoint((float)loc[0], (float)i);
found = true;
break;
}
}
// Bottom Left
if (found) { // Found the Top Left vertex
found = false;
for (int i = 0; i < height; i += rowStep) {
ArrayRef<int> loc =
findGuardPattern(matrix, halfWidth, i, halfWidth, true, START_PATTERN_REVERSE,
START_PATTERN_REVERSE_LENGTH, counters);
if (loc) {
result[1] = new ResultPoint((float)loc[1], (float)i);
result[5] = new ResultPoint((float)loc[0], (float)i);
found = true;
break;
}
}
}
counters = new Array<int>(STOP_PATTERN_REVERSE_LENGTH);
// Top Right
if (found) { // Found the Bottom Left vertex
found = false;
for (int i = height - 1; i > 0; i -= rowStep) {
ArrayRef<int> loc = findGuardPattern(matrix, 0, i, halfWidth, false, STOP_PATTERN_REVERSE,
STOP_PATTERN_REVERSE_LENGTH, counters);
if (loc) {
result[2] = new ResultPoint((float)loc[0], (float)i);
result[6] = new ResultPoint((float)loc[1], (float)i);
found = true;
break;
}
}
}
// Bottom Right
if (found) { // Found the Top Right vertex
found = false;
for (int i = 0; i < height; i += rowStep) {
ArrayRef<int> loc = findGuardPattern(matrix, 0, i, halfWidth, false, STOP_PATTERN_REVERSE,
STOP_PATTERN_REVERSE_LENGTH, counters);
if (loc) {
result[3] = new ResultPoint((float)loc[0], (float)i);
result[7] = new ResultPoint((float)loc[1], (float)i);
found = true;
break;
}
}
}
return found ? result : ArrayRef< Ref<ResultPoint> >();
}
/**
* @param matrix row of black/white values to search
* @param column x position to start search
* @param row y position to start search
* @param width the number of pixels to search on this row
* @param pattern pattern of counts of number of black and white pixels that are
* being searched for as a pattern
* @param counters array of counters, as long as pattern, to re-use
* @return start/end horizontal offset of guard pattern, as an array of two ints.
*/
ArrayRef<int> Detector::findGuardPattern(Ref<BitMatrix> matrix,
int column,
int row,
int width,
bool whiteFirst,
const int pattern[],
int patternSize,
ArrayRef<int>& counters) {
counters->values().assign(counters->size(), 0);
int patternLength = patternSize;
bool isWhite = whiteFirst;
int counterPosition = 0;
int patternStart = column;
for (int x = column; x < column + width; x++) {
bool pixel = matrix->get(x, row);
if (pixel ^ isWhite) {
counters[counterPosition]++;
} else {
if (counterPosition == patternLength - 1) {
if (patternMatchVariance(counters, pattern,
MAX_INDIVIDUAL_VARIANCE) < MAX_AVG_VARIANCE) {
ArrayRef<int> result = new Array<int>(2);
result[0] = patternStart;
result[1] = x;
return result;
}
patternStart += counters[0] + counters[1];
for(int i = 0; i < patternLength - 2; ++i)
counters[i] = counters[ i + 2];
counters[patternLength - 2] = 0;
counters[patternLength - 1] = 0;
counterPosition--;
} else {
counterPosition++;
}
counters[counterPosition] = 1;
isWhite = !isWhite;
}
}
return ArrayRef<int>();
}
/**
* Determines how closely a set of observed counts of runs of black/white
* values matches a given target pattern. This is reported as the ratio of
* the total variance from the expected pattern proportions across all
* pattern elements, to the length of the pattern.
*
* @param counters observed counters
* @param pattern expected pattern
* @param maxIndividualVariance The most any counter can differ before we give up
* @return ratio of total variance between counters and pattern compared to
* total pattern size, where the ratio has been multiplied by 256.
* So, 0 means no variance (perfect match); 256 means the total
* variance between counters and patterns equals the pattern length,
* higher values mean even more variance
*/
int Detector::patternMatchVariance(ArrayRef<int>& counters,
const int pattern[],
int maxIndividualVariance)
{
int numCounters = counters->size();
int total = 0;
int patternLength = 0;
for (int i = 0; i < numCounters; i++) {
total += counters[i];
patternLength += pattern[i];
}
if (total < patternLength) {
// If we don't even have one pixel per unit of bar width, assume this
// is too small to reliably match, so fail:
return numeric_limits<int>::max();
}
// We're going to fake floating-point math in integers. We just need to use more bits.
// Scale up patternLength so that intermediate values below like scaledCounter will have
// more "significant digits".
int unitBarWidth = (total << 8) / patternLength;
maxIndividualVariance = (maxIndividualVariance * unitBarWidth) >> 8;
int totalVariance = 0;
for (int x = 0; x < numCounters; x++) {
int counter = counters[x] << 8;
int scaledPattern = pattern[x] * unitBarWidth;
int variance = counter > scaledPattern ? counter - scaledPattern : scaledPattern - counter;
if (variance > maxIndividualVariance) {
return numeric_limits<int>::max();
}
totalVariance += variance;
}
return totalVariance / total;
}
/**
* <p>Correct the vertices by searching for top and bottom vertices of wide
* bars, then locate the intersections between the upper and lower horizontal
* line and the inner vertices vertical lines.</p>
*
* @param matrix the scanned barcode image.
* @param vertices the vertices vector is extended and the new members are:
* vertices[ 8] x,y point on upper border of left wide bar
* vertices[ 9] x,y point on lower border of left wide bar
* vertices[10] x,y point on upper border of right wide bar
* vertices[11] x,y point on lower border of right wide bar
* vertices[12] x,y final top left codeword area
* vertices[13] x,y final bottom left codeword area
* vertices[14] x,y final top right codeword area
* vertices[15] x,y final bottom right codeword area
* @param upsideDown true if rotated by 180 degree.
*/
void Detector::correctVertices(Ref<BitMatrix> matrix,
ArrayRef< Ref<ResultPoint> >& vertices,
bool upsideDown)
{
bool isLowLeft = abs(vertices[4]->getY() - vertices[5]->getY()) < 20.0;
bool isLowRight = abs(vertices[6]->getY() - vertices[7]->getY()) < 20.0;
if (isLowLeft || isLowRight) {
throw NotFoundException("Cannot find enough PDF417 guard patterns!");
} else {
findWideBarTopBottom(matrix, vertices, 0, 0, 8, 17, upsideDown ? 1 : -1);
findWideBarTopBottom(matrix, vertices, 1, 0, 8, 17, upsideDown ? -1 : 1);
findWideBarTopBottom(matrix, vertices, 2, 11, 7, 18, upsideDown ? 1 : -1);
findWideBarTopBottom(matrix, vertices, 3, 11, 7, 18, upsideDown ? -1 : 1);
findCrossingPoint(vertices, 12, 4, 5, 8, 10, matrix);
findCrossingPoint(vertices, 13, 4, 5, 9, 11, matrix);
findCrossingPoint(vertices, 14, 6, 7, 8, 10, matrix);
findCrossingPoint(vertices, 15, 6, 7, 9, 11, matrix);
}
}
/**
* <p>Locate the top or bottom of one of the two wide black bars of a guard pattern.</p>
*
* <p>Warning: it only searches along the y axis, so the return points would not be
* right if the barcode is too curved.</p>
*
* @param matrix The bit matrix.
* @param vertices The 16 vertices located by findVertices(); the result
* points are stored into vertices[8], ... , vertices[11].
* @param offsetVertice The offset of the outer vertice and the inner
* vertice (+ 4) to be corrected and (+ 8) where the result is stored.
* @param startWideBar start of a wide bar.
* @param lenWideBar length of wide bar.
* @param lenPattern length of the pattern.
* @param rowStep +1 if corner should be exceeded towards the bottom, -1 towards the top.
*/
void Detector::findWideBarTopBottom(Ref<BitMatrix> matrix,
ArrayRef< Ref<ResultPoint> > &vertices,
int offsetVertice,
int startWideBar,
int lenWideBar,
int lenPattern,
int rowStep)
{
Ref<ResultPoint> verticeStart(vertices[offsetVertice]);
Ref<ResultPoint> verticeEnd(vertices[offsetVertice + 4]);
// Start horizontally at the middle of the bar.
int endWideBar = startWideBar + lenWideBar;
float barDiff = verticeEnd->getX() - verticeStart->getX();
float barStart = verticeStart->getX() + barDiff * (float)startWideBar / (float)lenPattern;
float barEnd = verticeStart->getX() + barDiff * (float)endWideBar / (float)lenPattern;
int x = Math::round((barStart + barEnd) / 2.0f);
// Start vertically between the preliminary vertices.
int yStart = Math::round(verticeStart->getY());
int y = yStart;
// Find offset of thin bar to the right as additional safeguard.
int nextBarX = int(max(barStart, barEnd) + 1);
for (; nextBarX < matrix->getWidth(); nextBarX++)
if (!matrix->get(nextBarX - 1, y) && matrix->get(nextBarX, y)) break;
nextBarX -= x;
bool isEnd = false;
while (!isEnd) {
if (matrix->get(x, y)) {
// If the thin bar to the right ended, stop as well
isEnd = !matrix->get(x + nextBarX, y) && !matrix->get(x + nextBarX + 1, y);
y += rowStep;
if (y <= 0 || y >= (int)matrix->getHeight() - 1) {
// End of barcode image reached.
isEnd = true;
}
} else {
// Look sidewise whether black bar continues? (in the case the image is skewed)
if (x > 0 && matrix->get(x - 1, y)) {
x--;
} else if (x < (int)matrix->getWidth() - 1 && matrix->get(x + 1, y)) {
x++;
} else {
// End of pattern regarding big bar and big gap reached.
isEnd = true;
if (y != yStart) {
// Turn back one step, because target has been exceeded.
y -= rowStep;
}
}
}
}
vertices[offsetVertice + 8] = new ResultPoint((float)x, (float)y);
}
/**
* <p>Finds the intersection of two lines.</p>
*
* @param vertices The reference of the vertices vector
* @param idxResult Index of result point inside the vertices vector.
* @param idxLineA1
* @param idxLineA2 Indices two points inside the vertices vector that define the first line.
* @param idxLineB1
* @param idxLineB2 Indices two points inside the vertices vector that define the second line.
* @param matrix: bit matrix, here only for testing whether the result is inside the matrix.
* @return Returns true when the result is valid and lies inside the matrix. Otherwise throws an
* exception.
**/
void Detector::findCrossingPoint(ArrayRef< Ref<ResultPoint> >& vertices,
int idxResult,
int idxLineA1, int idxLineA2,
int idxLineB1, int idxLineB2,
Ref<BitMatrix>& matrix)
{
Point p1(vertices[idxLineA1]->getX(), vertices[idxLineA1]->getY());
Point p2(vertices[idxLineA2]->getX(), vertices[idxLineA2]->getY());
Point p3(vertices[idxLineB1]->getX(), vertices[idxLineB1]->getY());
Point p4(vertices[idxLineB2]->getX(), vertices[idxLineB2]->getY());
Point result(intersection(Line(p1, p2), Line(p3, p4)));
if (result.x == numeric_limits<float>::infinity() ||
result.y == numeric_limits<float>::infinity()) {
throw NotFoundException("PDF:Detector: cannot find the crossing of parallel lines!");
}
int x = Math::round(result.x);
int y = Math::round(result.y);
if (x < 0 || x >= (int)matrix->getWidth() || y < 0 || y >= (int)matrix->getHeight()) {
throw NotFoundException("PDF:Detector: crossing points out of region!");
}
vertices[idxResult] = Ref<ResultPoint>(new ResultPoint(result.x, result.y));
}
/**
* Computes the intersection between two lines.
*/
Point Detector::intersection(Line a, Line b) {
float dxa = a.start.x - a.end.x;
float dxb = b.start.x - b.end.x;
float dya = a.start.y - a.end.y;
float dyb = b.start.y - b.end.y;
float p = a.start.x * a.end.y - a.start.y * a.end.x;
float q = b.start.x * b.end.y - b.start.y * b.end.x;
float denom = dxa * dyb - dya * dxb;
if(abs(denom) < 1e-12) // Lines don't intersect (replaces "denom == 0")
return Point(numeric_limits<float>::infinity(),
numeric_limits<float>::infinity());
float x = (p * dxb - dxa * q) / denom;
float y = (p * dyb - dya * q) / denom;
return Point(x, y);
}
/**
* <p>Estimates module size (pixels in a module) based on the Start and End
* finder patterns.</p>
*
* @param vertices an array of vertices:
* vertices[0] x, y top left barcode
* vertices[1] x, y bottom left barcode
* vertices[2] x, y top right barcode
* vertices[3] x, y bottom right barcode
* vertices[4] x, y top left codeword area
* vertices[5] x, y bottom left codeword area
* vertices[6] x, y top right codeword area
* vertices[7] x, y bottom right codeword area
* @return the module size.
*/
float Detector::computeModuleWidth(ArrayRef< Ref<ResultPoint> >& vertices) {
float pixels1 = ResultPoint::distance(vertices[0], vertices[4]);
float pixels2 = ResultPoint::distance(vertices[1], vertices[5]);
float moduleWidth1 = (pixels1 + pixels2) / (17 * 2.0f);
float pixels3 = ResultPoint::distance(vertices[6], vertices[2]);
float pixels4 = ResultPoint::distance(vertices[7], vertices[3]);
float moduleWidth2 = (pixels3 + pixels4) / (18 * 2.0f);
return (moduleWidth1 + moduleWidth2) / 2.0f;
}
/**
* Computes the dimension (number of modules in a row) of the PDF417 Code
* based on vertices of the codeword area and estimated module size.
*
* @param topLeft of codeword area
* @param topRight of codeword area
* @param bottomLeft of codeword area
* @param bottomRight of codeword are
* @param moduleWidth estimated module size
* @return the number of modules in a row.
*/
int Detector::computeDimension(Ref<ResultPoint> const& topLeft,
Ref<ResultPoint> const& topRight,
Ref<ResultPoint> const& bottomLeft,
Ref<ResultPoint> const& bottomRight,
float moduleWidth)
{
int topRowDimension = MathUtils::round(ResultPoint::distance(topLeft, topRight) / moduleWidth);
int bottomRowDimension =
MathUtils::round(ResultPoint::distance(bottomLeft, bottomRight) / moduleWidth);
return ((((topRowDimension + bottomRowDimension) >> 1) + 8) / 17) * 17;
}
/**
* Computes the y dimension (number of modules in a column) of the PDF417 Code
* based on vertices of the codeword area and estimated module size.
*
* @param topLeft of codeword area
* @param topRight of codeword area
* @param bottomLeft of codeword area
* @param bottomRight of codeword are
* @param moduleWidth estimated module size
* @return the number of modules in a row.
*/
int Detector::computeYDimension(Ref<ResultPoint> const& topLeft,
Ref<ResultPoint> const& topRight,
Ref<ResultPoint> const& bottomLeft,
Ref<ResultPoint> const& bottomRight,
float moduleWidth)
{
int leftColumnDimension =
MathUtils::round(ResultPoint::distance(topLeft, bottomLeft) / moduleWidth);
int rightColumnDimension =
MathUtils::round(ResultPoint::distance(topRight, bottomRight) / moduleWidth);
return (leftColumnDimension + rightColumnDimension) >> 1;
}
/**
* Deskew and over-sample image.
*
* @param vertices vertices from findVertices()
* @param dimension x dimension
* @param yDimension y dimension
* @return an over-sampled BitMatrix.
*/
Ref<BitMatrix> Detector::sampleLines(ArrayRef< Ref<ResultPoint> > const& vertices,
int dimensionY,
int dimension) {
const int sampleDimensionX = dimension * 8;
const int sampleDimensionY = dimensionY * 4;
Ref<PerspectiveTransform> transform(
PerspectiveTransform::quadrilateralToQuadrilateral(
0.0f, 0.0f,
(float)sampleDimensionX, 0.0f,
0.0f, (float)sampleDimensionY,
(float)sampleDimensionX, (float)sampleDimensionY,
vertices[12]->getX(), vertices[12]->getY(),
vertices[14]->getX(), vertices[14]->getY(),
vertices[13]->getX(), vertices[13]->getY(),
vertices[15]->getX(), vertices[15]->getY()));
Ref<BitMatrix> linesMatrix = GridSampler::getInstance().sampleGrid(
image_->getBlackMatrix(), sampleDimensionX, sampleDimensionY, transform);
return linesMatrix;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/pdf417/detector/Detector3.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 6,598
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
* Decoder.h
* zxing
*
* Created by Lukas Stabe on 08/02/2012.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#ifndef __ZXING_AZTEC_DECODER_DECODER_H__
#define __ZXING_AZTEC_DECODER_DECODER_H__
#include <zxing/common/BitMatrix.h>
#include <zxing/common/Str.h>
#include <zxing/aztec/AztecDetectorResult.h>
namespace zxing {
class DecoderResult;
namespace aztec {
class Decoder : public Counted {
private:
enum Table {
UPPER,
LOWER,
MIXED,
DIGIT,
PUNCT,
BINARY
};
static Table getTable(char t);
static const char* getCharacter(Table table, int code);
int numCodewords_;
int codewordSize_;
Ref<AztecDetectorResult> ddata_;
int invertedBitCount_;
Ref<String> getEncodedData(Ref<BitArray> correctedBits);
Ref<BitArray> correctBits(Ref<BitArray> rawbits);
Ref<BitArray> extractBits(Ref<BitMatrix> matrix);
static Ref<BitMatrix> removeDashedLines(Ref<BitMatrix> matrix);
static int readCode(Ref<BitArray> rawbits, int startIndex, int length);
public:
Decoder();
Ref<DecoderResult> decode(Ref<AztecDetectorResult> detectorResult);
};
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/aztec/decoder/Decoder.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 377
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
* Decoder.cpp
* zxing
*
* Created by Lukas Stabe on 08/02/2012.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/aztec/decoder/Decoder.h>
#ifndef NO_ICONV
#include <iconv.h>
#endif
#include <iostream>
#include <zxing/FormatException.h>
#include <zxing/common/reedsolomon/ReedSolomonDecoder.h>
#include <zxing/common/reedsolomon/ReedSolomonException.h>
#include <zxing/common/reedsolomon/GenericGF.h>
#include <zxing/common/IllegalArgumentException.h>
#include <zxing/common/DecoderResult.h>
using zxing::aztec::Decoder;
using zxing::DecoderResult;
using zxing::String;
using zxing::BitArray;
using zxing::BitMatrix;
using zxing::Ref;
using std::string;
namespace {
void add(string& result, char character) {
#ifndef NO_ICONV
char character2 = character & 0xff;
char s[] = {character2};
char* ss = s;
size_t sl = sizeof(s);
char d[4];
char* ds = d;
size_t dl = sizeof(d);
iconv_t ic = iconv_open("UTF-8", "ISO-8859-1");
iconv(ic, &ss, &sl, &ds, &dl);
iconv_close(ic);
d[sizeof(d)-dl] = 0;
result.append(d);
#else
result.push_back(character);
#endif
}
const int NB_BITS_COMPACT[] = {
0, 104, 240, 408, 608
};
const int NB_BITS[] = {
0, 128, 288, 480, 704, 960, 1248, 1568, 1920, 2304, 2720, 3168, 3648, 4160, 4704, 5280, 5888, 6528,
7200, 7904, 8640, 9408, 10208, 11040, 11904, 12800, 13728, 14688, 15680, 16704, 17760, 18848, 19968
};
const int NB_DATABLOCK_COMPACT[] = {
0, 17, 40, 51, 76
};
const int NB_DATABLOCK[] = {
0, 21, 48, 60, 88, 120, 156, 196, 240, 230, 272, 316, 364, 416, 470, 528, 588, 652, 720, 790, 864,
940, 1020, 920, 992, 1066, 1144, 1224, 1306, 1392, 1480, 1570, 1664
};
const char* UPPER_TABLE[] = {
"CTRL_PS", " ", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P",
"Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "CTRL_LL", "CTRL_ML", "CTRL_DL", "CTRL_BS"
};
const char* LOWER_TABLE[] = {
"CTRL_PS", " ", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p",
"q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "CTRL_US", "CTRL_ML", "CTRL_DL", "CTRL_BS"
};
const char* MIXED_TABLE[] = {
"CTRL_PS", " ", "\1", "\2", "\3", "\4", "\5", "\6", "\7", "\b", "\t", "\n",
"\13", "\f", "\r", "\33", "\34", "\35", "\36", "\37", "@", "\\", "^", "_",
"`", "|", "~", "\177", "CTRL_LL", "CTRL_UL", "CTRL_PL", "CTRL_BS"
};
const char* PUNCT_TABLE[] = {
"", "\r", "\r\n", ". ", ", ", ": ", "!", "\"", "#", "$", "%", "&", "'", "(", ")",
"*", "+", ",", "-", ".", "/", ":", ";", "<", "=", ">", "?", "[", "]", "{", "}", "CTRL_UL"
};
const char* DIGIT_TABLE[] = {
"CTRL_PS", " ", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ",", ".", "CTRL_UL", "CTRL_US"
};
}
Decoder::Table Decoder::getTable(char t) {
switch (t) {
case 'L':
return LOWER;
case 'P':
return PUNCT;
case 'M':
return MIXED;
case 'D':
return DIGIT;
case 'B':
return BINARY;
case 'U':
default:
return UPPER;
}
}
const char* Decoder::getCharacter(zxing::aztec::Decoder::Table table, int code) {
switch (table) {
case UPPER:
return UPPER_TABLE[code];
case LOWER:
return LOWER_TABLE[code];
case MIXED:
return MIXED_TABLE[code];
case PUNCT:
return PUNCT_TABLE[code];
case DIGIT:
return DIGIT_TABLE[code];
default:
return "";
}
}
Decoder::Decoder() {
// nothing
}
Ref<DecoderResult> Decoder::decode(Ref<zxing::aztec::AztecDetectorResult> detectorResult) {
ddata_ = detectorResult;
// std::printf("getting bits\n");
Ref<BitMatrix> matrix = detectorResult->getBits();
if (!ddata_->isCompact()) {
// std::printf("removing lines\n");
matrix = removeDashedLines(ddata_->getBits());
}
// std::printf("extracting bits\n");
Ref<BitArray> rawbits = extractBits(matrix);
// std::printf("correcting bits\n");
Ref<BitArray> aCorrectedBits = correctBits(rawbits);
// std::printf("decoding bits\n");
Ref<String> result = getEncodedData(aCorrectedBits);
// std::printf("constructing array\n");
ArrayRef<char> arrayOut(aCorrectedBits->getSize());
for (int i = 0; i < aCorrectedBits->count(); i++) {
arrayOut[i] = (char)aCorrectedBits->get(i);
}
// std::printf("returning\n");
return Ref<DecoderResult>(new DecoderResult(arrayOut, result));
}
Ref<String> Decoder::getEncodedData(Ref<zxing::BitArray> correctedBits) {
int endIndex = codewordSize_ * ddata_->getNBDatablocks() - invertedBitCount_;
if (endIndex > (int)correctedBits->getSize()) {
// std::printf("invalid input\n");
throw FormatException("invalid input data");
}
Table lastTable = UPPER;
Table table = UPPER;
int startIndex = 0;
std::string result;
bool end = false;
bool shift = false;
bool switchShift = false;
bool binaryShift = false;
while (!end) {
// std::printf("decoooooding\n");
if (shift) {
switchShift = true;
} else {
lastTable = table;
}
int code;
if (binaryShift) {
if (endIndex - startIndex < 5) {
break;
}
int length = readCode(correctedBits, startIndex, 5);
startIndex += 5;
if (length == 0) {
if (endIndex - startIndex < 11) {
break;
}
length = readCode(correctedBits, startIndex, 11) + 31;
startIndex += 11;
}
for (int charCount = 0; charCount < length; charCount++) {
if (endIndex - startIndex < 8) {
end = true;
break;
}
code = readCode(correctedBits, startIndex, 8);
add(result, code);
startIndex += 8;
}
binaryShift = false;
} else {
if (table == BINARY) {
if (endIndex - startIndex < 8) {
break;
}
code = readCode(correctedBits, startIndex, 8);
startIndex += 8;
add(result, code);
} else {
int size = 5;
if (table == DIGIT) {
size = 4;
}
if (endIndex - startIndex < size) {
break;
}
code = readCode(correctedBits, startIndex, size);
startIndex += size;
const char *str = getCharacter(table, code);
std::string string(str);
if ((int)string.find("CTRL_") != -1) {
table = getTable(str[5]);
if (str[6] == 'S') {
shift = true;
if (str[5] == 'B') {
binaryShift = true;
}
}
} else {
result.append(string);
}
}
}
if (switchShift) {
table = lastTable;
shift = false;
switchShift = false;
}
}
return Ref<String>(new String(result));
}
Ref<BitArray> Decoder::correctBits(Ref<zxing::BitArray> rawbits) {
//return rawbits;
// std::printf("decoding stuff:%d datablocks in %d layers\n", ddata_->getNBDatablocks(), ddata_->getNBLayers());
Ref<GenericGF> gf = GenericGF::AZTEC_DATA_6;
if (ddata_->getNBLayers() <= 2) {
codewordSize_ = 6;
gf = GenericGF::AZTEC_DATA_6;
} else if (ddata_->getNBLayers() <= 8) {
codewordSize_ = 8;
gf = GenericGF::AZTEC_DATA_8;
} else if (ddata_->getNBLayers() <= 22) {
codewordSize_ = 10;
gf = GenericGF::AZTEC_DATA_10;
} else {
codewordSize_ = 12;
gf = GenericGF::AZTEC_DATA_12;
}
int numDataCodewords = ddata_->getNBDatablocks();
int numECCodewords;
int offset;
if (ddata_->isCompact()) {
offset = NB_BITS_COMPACT[ddata_->getNBLayers()] - numCodewords_ * codewordSize_;
numECCodewords = NB_DATABLOCK_COMPACT[ddata_->getNBLayers()] - numDataCodewords;
} else {
offset = NB_BITS[ddata_->getNBLayers()] - numCodewords_ * codewordSize_;
numECCodewords = NB_DATABLOCK[ddata_->getNBLayers()] - numDataCodewords;
}
ArrayRef<int> dataWords(numCodewords_);
for (int i = 0; i < numCodewords_; i++) {
int flag = 1;
for (int j = 1; j <= codewordSize_; j++) {
if (rawbits->get(codewordSize_ * i + codewordSize_ - j + offset)) {
dataWords[i] += flag;
}
flag <<= 1;
}
//
//
//
}
try {
ReedSolomonDecoder rsDecoder(gf);
rsDecoder.decode(dataWords, numECCodewords);
} catch (ReedSolomonException const& ignored) {
(void)ignored;
// std::printf("got reed solomon exception:%s, throwing formatexception\n", rse.what());
throw FormatException("rs decoding failed");
} catch (IllegalArgumentException const& iae) {
(void)iae;
// std::printf("illegal argument exception: %s", iae.what());
}
offset = 0;
invertedBitCount_ = 0;
Ref<BitArray> correctedBits(new BitArray(numDataCodewords * codewordSize_));
for (int i = 0; i < numDataCodewords; i++) {
bool seriesColor = false;
int seriesCount = 0;
int flag = 1 << (codewordSize_ - 1);
for (int j = 0; j < codewordSize_; j++) {
bool color = (dataWords[i] & flag) == flag;
if (seriesCount == codewordSize_ - 1) {
if (color == seriesColor) {
throw FormatException("bit was not inverted");
}
seriesColor = false;
seriesCount = 0;
offset++;
invertedBitCount_++;
} else {
if (seriesColor == color) {
seriesCount++;
} else {
seriesCount = 1;
seriesColor = color;
}
if (color) correctedBits->set(i * codewordSize_ + j - offset);
}
flag = ((unsigned int)flag) >> 1;
}
}
return correctedBits;
}
Ref<BitArray> Decoder::extractBits(Ref<zxing::BitMatrix> matrix) {
std::vector<bool> rawbits;
if (ddata_->isCompact()) {
if (ddata_->getNBLayers() > 5) { //NB_BITS_COMPACT length
throw FormatException("data is too long");
}
rawbits = std::vector<bool>(NB_BITS_COMPACT[ddata_->getNBLayers()]);
numCodewords_ = NB_DATABLOCK_COMPACT[ddata_->getNBLayers()];
} else {
if (ddata_->getNBLayers() > 33) { //NB_BITS length
throw FormatException("data is too long");
}
rawbits = std::vector<bool>(NB_BITS[ddata_->getNBLayers()]);
numCodewords_ = NB_DATABLOCK[ddata_->getNBLayers()];
}
int layer = ddata_->getNBLayers();
int size = matrix->getHeight();
int rawbitsOffset = 0;
int matrixOffset = 0;
while (layer != 0) {
int flip = 0;
for (int i = 0; i < 2 * size - 4; i++) {
rawbits[rawbitsOffset + i] = matrix->get(matrixOffset + flip, matrixOffset + i / 2);
rawbits[rawbitsOffset + 2 * size - 4 + i] = matrix->get(matrixOffset + i / 2, matrixOffset + size - 1 - flip);
flip = (flip + 1) % 2;
}
flip = 0;
for (int i = 2 * size + 1; i > 5; i--) {
rawbits[rawbitsOffset + 4 * size - 8 + (2 * size - i) + 1] =
matrix->get(matrixOffset + size - 1 - flip, matrixOffset + i / 2 - 1);
rawbits[rawbitsOffset + 6 * size - 12 + (2 * size - i) + 1] =
matrix->get(matrixOffset + i / 2 - 1, matrixOffset + flip);
flip = (flip + 1) % 2;
}
matrixOffset += 2;
rawbitsOffset += 8 * size - 16;
layer--;
size -= 4;
}
Ref<BitArray> returnValue(new BitArray(static_cast<int>(rawbits.size())));
for (int i = 0; i < (int)rawbits.size(); i++) {
if (static_cast<size_t>(rawbits[i])) returnValue->set(i);
}
return returnValue;
}
Ref<BitMatrix> Decoder::removeDashedLines(Ref<zxing::BitMatrix> matrix) {
int nbDashed = 1 + 2 * ((matrix->getWidth() - 1) / 2 / 16);
Ref<BitMatrix> newMatrix(new BitMatrix(matrix->getWidth() - nbDashed, matrix->getHeight() - nbDashed));
int nx = 0;
for (int x = 0; x < (int)matrix->getWidth(); x++) {
if ((matrix->getWidth() / 2 - x) % 16 == 0) {
continue;
}
int ny = 0;
for (int y = 0; y < (int)matrix->getHeight(); y++) {
if ((matrix->getWidth() / 2 - y) % 16 == 0) {
continue;
}
if (matrix->get(x, y)) {
newMatrix->set(nx, ny);
}
ny++;
}
nx++;
}
return newMatrix;
}
int Decoder::readCode(Ref<zxing::BitArray> rawbits, int startIndex, int length) {
int res = 0;
for (int i = startIndex; i < startIndex + length; i++) {
res <<= 1;
if (rawbits->get(i)) {
res ++;
}
}
return res;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/aztec/decoder/Decoder1.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 4,090
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
* Detector.h
* zxing
*
* Created by Lukas Stabe on 08/02/2012.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#ifndef __ZXING_AZTEC_DETECTOR_DETECTOR_H__
#define __ZXING_AZTEC_DETECTOR_DETECTOR_H__
#include <vector>
#include <zxing/common/BitArray.h>
#include <zxing/ResultPoint.h>
#include <zxing/common/BitMatrix.h>
#include <zxing/DecodeHints.h>
#include <zxing/aztec/AztecDetectorResult.h>
namespace zxing {
namespace aztec {
class Point : public Counted {
private:
const int x;
const int y;
public:
Ref<ResultPoint> toResultPoint() {
return Ref<ResultPoint>(new ResultPoint(float(x), float(y)));
}
Point(int ax, int ay) : x(ax), y(ay) {}
int getX() const { return x; }
int getY() const { return y; }
};
class Detector : public Counted {
private:
Ref<BitMatrix> image_;
bool compact_;
int nbLayers_;
int nbDataBlocks_;
int nbCenterLayers_;
int shift_;
void extractParameters(std::vector<Ref<Point> > bullEyeCornerPoints);
ArrayRef< Ref<ResultPoint> > getMatrixCornerPoints(std::vector<Ref<Point> > bullEyeCornerPoints);
static void correctParameterData(Ref<BitArray> parameterData, bool compact);
std::vector<Ref<Point> > getBullEyeCornerPoints(Ref<Point> pCenter);
Ref<Point> getMatrixCenter();
Ref<BitMatrix> sampleGrid(Ref<BitMatrix> image,
Ref<ResultPoint> topLeft,
Ref<ResultPoint> bottomLeft,
Ref<ResultPoint> bottomRight,
Ref<ResultPoint> topRight);
void getParameters(Ref<BitArray> parameterData);
Ref<BitArray> sampleLine(Ref<Point> p1, Ref<Point> p2, int size);
bool isWhiteOrBlackRectangle(Ref<Point> p1,
Ref<Point> p2,
Ref<Point> p3,
Ref<Point> p4);
int getColor(Ref<Point> p1, Ref<Point> p2);
Ref<Point> getFirstDifferent(Ref<Point> init, bool color, int dx, int dy);
bool isValid(int x, int y);
static float distance(Ref<Point> a, Ref<Point> b);
public:
Detector(Ref<BitMatrix> image);
Ref<AztecDetectorResult> detect();
};
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/aztec/detector/Detector.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 620
|
```objective-c
#ifndef __DATA_MATRIX_READER_H__
#define __DATA_MATRIX_READER_H__
/*
* DataMatrixReader.h
* zxing
*
* Created by Luiz Silva on 09/02/2010.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/Reader.h>
#include <zxing/DecodeHints.h>
#include <zxing/datamatrix/decoder/Decoder.h>
namespace zxing {
namespace datamatrix {
class DataMatrixReader : public Reader {
private:
Decoder decoder_;
public:
DataMatrixReader();
virtual Ref<Result> decode(Ref<BinaryBitmap> image, DecodeHints hints);
virtual ~DataMatrixReader();
};
}
}
#endif // __DATA_MATRIX_READER_H__
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/datamatrix/DataMatrixReader.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 182
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
* DataMatrixReader.cpp
* zxing
*
* Created by Luiz Silva on 09/02/2010.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/datamatrix/DataMatrixReader.h>
#include <zxing/datamatrix/detector/Detector.h>
#include <iostream>
namespace zxing {
namespace datamatrix {
using namespace std;
DataMatrixReader::DataMatrixReader() :
decoder_() {
}
Ref<Result> DataMatrixReader::decode(Ref<BinaryBitmap> image, DecodeHints hints) {
(void)hints;
Detector detector(image->getBlackMatrix());
Ref<DetectorResult> detectorResult(detector.detect());
ArrayRef< Ref<ResultPoint> > points(detectorResult->getPoints());
Ref<DecoderResult> decoderResult(decoder_.decode(detectorResult->getBits()));
Ref<Result> result(
new Result(decoderResult->getText(), decoderResult->getRawBytes(), points, BarcodeFormat::DATA_MATRIX));
return result;
}
DataMatrixReader::~DataMatrixReader() {
}
}
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/datamatrix/DataMatrixReader.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 280
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
* Detector.cpp
* zxing
*
* Created by Lukas Stabe on 08/02/2012.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/aztec/detector/Detector.h>
#include <zxing/common/GridSampler.h>
#include <zxing/common/detector/WhiteRectangleDetector.h>
#include <zxing/common/reedsolomon/ReedSolomonDecoder.h>
#include <zxing/common/reedsolomon/ReedSolomonException.h>
#include <zxing/common/reedsolomon/GenericGF.h>
#include <iostream>
#include <zxing/common/detector/MathUtils.h>
#include <zxing/NotFoundException.h>
using std::vector;
using zxing::aztec::Detector;
using zxing::aztec::Point;
using zxing::aztec::AztecDetectorResult;
using zxing::Ref;
using zxing::ArrayRef;
using zxing::ResultPoint;
using zxing::BitArray;
using zxing::BitMatrix;
using zxing::common::detector::MathUtils;
Detector::Detector(Ref<BitMatrix> image):
image_(image),
nbLayers_(0),
nbDataBlocks_(0),
nbCenterLayers_(0) {
}
Ref<AztecDetectorResult> Detector::detect() {
Ref<Point> pCenter = getMatrixCenter();
std::vector<Ref<Point> > bullEyeCornerPoints = getBullEyeCornerPoints(pCenter);
extractParameters(bullEyeCornerPoints);
ArrayRef< Ref<ResultPoint> > corners = getMatrixCornerPoints(bullEyeCornerPoints);
Ref<BitMatrix> bits =
sampleGrid(image_,
corners[shift_%4],
corners[(shift_+3)%4],
corners[(shift_+2)%4],
corners[(shift_+1)%4]);
// std::printf("------------\ndetected: compact:%s, nbDataBlocks:%d, nbLayers:%d\n------------\n",compact_?"YES":"NO", nbDataBlocks_, nbLayers_);
return Ref<AztecDetectorResult>(new AztecDetectorResult(bits, corners, compact_, nbDataBlocks_, nbLayers_));
}
void Detector::extractParameters(std::vector<Ref<Point> > bullEyeCornerPoints) {
int twoCenterLayers = 2 * nbCenterLayers_;
// get the bits around the bull's eye
Ref<BitArray> resab = sampleLine(bullEyeCornerPoints[0], bullEyeCornerPoints[1], twoCenterLayers+1);
Ref<BitArray> resbc = sampleLine(bullEyeCornerPoints[1], bullEyeCornerPoints[2], twoCenterLayers+1);
Ref<BitArray> rescd = sampleLine(bullEyeCornerPoints[2], bullEyeCornerPoints[3], twoCenterLayers+1);
Ref<BitArray> resda = sampleLine(bullEyeCornerPoints[3], bullEyeCornerPoints[0], twoCenterLayers+1);
// determin the orientation of the matrix
if (resab->get(0) && resab->get(twoCenterLayers)) {
shift_ = 0;
} else if (resbc->get(0) && resbc->get(twoCenterLayers)) {
shift_ = 1;
} else if (rescd->get(0) && rescd->get(twoCenterLayers)) {
shift_ = 2;
} else if (resda->get(0) && resda->get(twoCenterLayers)) {
shift_ = 3;
} else {
// std::printf("could not detemine orientation\n");
throw ReaderException("could not determine orientation");
}
//d a
//
//c b
//flatten the bits in a single array
Ref<BitArray> parameterData(new BitArray(compact_?28:40));
Ref<BitArray> shiftedParameterData(new BitArray(compact_?28:40));
if (compact_) {
for (int i = 0; i < 7; i++) {
if (resab->get(2+i)) shiftedParameterData->set(i);
if (resbc->get(2+i)) shiftedParameterData->set(i+7);
if (rescd->get(2+i)) shiftedParameterData->set(i+14);
if (resda->get(2+i)) shiftedParameterData->set(i+21);
}
for (int i = 0; i < 28; i++) {
if (shiftedParameterData->get((i+shift_*7)%28)) parameterData->set(i);
}
} else {
for (int i = 0; i < 11; i++) {
if (i < 5) {
if (resab->get(2+i)) shiftedParameterData->set(i);
if (resbc->get(2+i)) shiftedParameterData->set(i+10);
if (rescd->get(2+i)) shiftedParameterData->set(i+20);
if (resda->get(2+i)) shiftedParameterData->set(i+30);
}
if (i > 5) {
if (resab->get(2+i)) shiftedParameterData->set(i-1);
if (resbc->get(2+i)) shiftedParameterData->set(i+9);
if (rescd->get(2+i)) shiftedParameterData->set(i+19);
if (resda->get(2+i)) shiftedParameterData->set(i+29);
}
}
for (int i = 0; i < 40; i++) {
if (shiftedParameterData->get((i+shift_*10)%40)) parameterData->set(i);
}
}
correctParameterData(parameterData, compact_);
getParameters(parameterData);
}
ArrayRef< Ref<ResultPoint> >
Detector::getMatrixCornerPoints(std::vector<Ref<Point> > bullEyeCornerPoints) {
float ratio = (2 * nbLayers_ + (nbLayers_ > 4 ? 1 : 0) + (nbLayers_ - 4) / 8) / (2.0f * nbCenterLayers_);
int dx = bullEyeCornerPoints[0]->getX() - bullEyeCornerPoints[2]->getX();
dx += dx > 0 ? 1 : -1;
int dy = bullEyeCornerPoints[0]->getY() - bullEyeCornerPoints[2]->getY();
dy += dy > 0 ? 1 : -1;
int targetcx = MathUtils::round(bullEyeCornerPoints[2]->getX() - ratio * dx);
int targetcy = MathUtils::round(bullEyeCornerPoints[2]->getY() - ratio * dy);
int targetax = MathUtils::round(bullEyeCornerPoints[0]->getX() + ratio * dx);
int targetay = MathUtils::round(bullEyeCornerPoints[0]->getY() + ratio * dy);
dx = bullEyeCornerPoints[1]->getX() - bullEyeCornerPoints[3]->getX();
dx += dx > 0 ? 1 : -1;
dy = bullEyeCornerPoints[1]->getY() - bullEyeCornerPoints[3]->getY();
dy += dy > 0 ? 1 : -1;
int targetdx = MathUtils::round(bullEyeCornerPoints[3]->getX() - ratio * dx);
int targetdy = MathUtils::round(bullEyeCornerPoints[3]->getY() - ratio * dy);
int targetbx = MathUtils::round(bullEyeCornerPoints[1]->getX() + ratio * dx);
int targetby = MathUtils::round(bullEyeCornerPoints[1]->getY() + ratio * dy);
if (!isValid(targetax, targetay) ||
!isValid(targetbx, targetby) ||
!isValid(targetcx, targetcy) ||
!isValid(targetdx, targetdy)) {
throw ReaderException("matrix extends over image bounds");
}
Array< Ref<ResultPoint> >* array = new Array< Ref<ResultPoint> >();
vector< Ref<ResultPoint> >& returnValue (array->values());
returnValue.push_back(Ref<ResultPoint>(new ResultPoint(float(targetax), float(targetay))));
returnValue.push_back(Ref<ResultPoint>(new ResultPoint(float(targetbx), float(targetby))));
returnValue.push_back(Ref<ResultPoint>(new ResultPoint(float(targetcx), float(targetcy))));
returnValue.push_back(Ref<ResultPoint>(new ResultPoint(float(targetdx), float(targetdy))));
return ArrayRef< Ref<ResultPoint> >(array);
}
void Detector::correctParameterData(Ref<zxing::BitArray> parameterData, bool compact) {
int numCodewords;
int numDataCodewords;
if (compact) {
numCodewords = 7;
numDataCodewords = 2;
} else {
numCodewords = 10;
numDataCodewords = 4;
}
int numECCodewords = numCodewords - numDataCodewords;
ArrayRef<int> parameterWords(new Array<int>(numCodewords));
int codewordSize = 4;
for (int i = 0; i < numCodewords; i++) {
int flag = 1;
for (int j = 1; j <= codewordSize; j++) {
if (parameterData->get(codewordSize*i + codewordSize - j)) {
parameterWords[i] += flag;
}
flag <<= 1;
}
}
try {
// std::printf("parameter data reed solomon\n");
ReedSolomonDecoder rsDecoder(GenericGF::AZTEC_PARAM);
rsDecoder.decode(parameterWords, numECCodewords);
} catch (ReedSolomonException const& ignored) {
(void)ignored;
// std::printf("reed solomon decoding failed\n");
throw ReaderException("failed to decode parameter data");
}
parameterData->clear();
for (int i = 0; i < numDataCodewords; i++) {
int flag = 1;
for (int j = 1; j <= codewordSize; j++) {
if ((parameterWords[i] & flag) == flag) {
parameterData->set(i*codewordSize+codewordSize-j);
}
flag <<= 1;
}
}
}
std::vector<Ref<Point> > Detector::getBullEyeCornerPoints(Ref<zxing::aztec::Point> pCenter) {
Ref<Point> pina = pCenter;
Ref<Point> pinb = pCenter;
Ref<Point> pinc = pCenter;
Ref<Point> pind = pCenter;
bool color = true;
for (nbCenterLayers_ = 1; nbCenterLayers_ < 9; nbCenterLayers_++) {
Ref<Point> pouta = getFirstDifferent(pina, color, 1, -1);
Ref<Point> poutb = getFirstDifferent(pinb, color, 1, 1);
Ref<Point> poutc = getFirstDifferent(pinc, color, -1, 1);
Ref<Point> poutd = getFirstDifferent(pind, color, -1, -1);
//d a
//
//c b
if (nbCenterLayers_ > 2) {
float q = distance(poutd, pouta) * nbCenterLayers_ / (distance(pind, pina) * (nbCenterLayers_ + 2));
if (q < 0.75 || q > 1.25 || !isWhiteOrBlackRectangle(pouta, poutb, poutc, poutd)) {
break;
}
}
pina = pouta;
pinb = poutb;
pinc = poutc;
pind = poutd;
color = !color;
}
if (nbCenterLayers_ != 5 && nbCenterLayers_ != 7) {
throw ReaderException("encountered wrong bullseye ring count");
}
compact_ = nbCenterLayers_ == 5;
float ratio = 0.75f*2 / (2*nbCenterLayers_-3);
int dx = pina->getX() - pind->getX();
int dy = pina->getY() - pinc->getY();
int targetcx = MathUtils::round(pinc->getX() - ratio * dx);
int targetcy = MathUtils::round(pinc->getY() - ratio * dy);
int targetax = MathUtils::round(pina->getX() + ratio * dx);
int targetay = MathUtils::round(pina->getY() + ratio * dy);
dx = pinb->getX() - pind->getX();
dy = pinb->getY() - pind->getY();
int targetdx = MathUtils::round(pind->getX() - ratio * dx);
int targetdy = MathUtils::round(pind->getY() - ratio * dy);
int targetbx = MathUtils::round(pinb->getX() + ratio * dx);
int targetby = MathUtils::round(pinb->getY() + ratio * dy);
if (!isValid(targetax, targetay) ||
!isValid(targetbx, targetby) ||
!isValid(targetcx, targetcy) ||
!isValid(targetdx, targetdy)) {
throw ReaderException("bullseye extends over image bounds");
}
std::vector<Ref<Point> > returnValue;
returnValue.push_back(Ref<Point>(new Point(targetax, targetay)));
returnValue.push_back(Ref<Point>(new Point(targetbx, targetby)));
returnValue.push_back(Ref<Point>(new Point(targetcx, targetcy)));
returnValue.push_back(Ref<Point>(new Point(targetdx, targetdy)));
return returnValue;
}
Ref<Point> Detector::getMatrixCenter() {
Ref<ResultPoint> pointA, pointB, pointC, pointD;
try {
std::vector<Ref<ResultPoint> > cornerPoints = WhiteRectangleDetector(image_).detect();
pointA = cornerPoints[0];
pointB = cornerPoints[1];
pointC = cornerPoints[2];
pointD = cornerPoints[3];
} catch (NotFoundException const& e) {
(void)e;
int cx = image_->getWidth() / 2;
int cy = image_->getHeight() / 2;
pointA = getFirstDifferent(Ref<Point>(new Point(cx+7, cy-7)), false, 1, -1)->toResultPoint();
pointB = getFirstDifferent(Ref<Point>(new Point(cx+7, cy+7)), false, 1, 1)->toResultPoint();
pointC = getFirstDifferent(Ref<Point>(new Point(cx-7, cy+7)), false, -1, -1)->toResultPoint();
pointD = getFirstDifferent(Ref<Point>(new Point(cx-7, cy-7)), false, -1, -1)->toResultPoint();
}
int cx = MathUtils::round((pointA->getX() + pointD->getX() + pointB->getX() + pointC->getX()) / 4.0f);
int cy = MathUtils::round((pointA->getY() + pointD->getY() + pointB->getY() + pointC->getY()) / 4.0f);
try {
std::vector<Ref<ResultPoint> > cornerPoints = WhiteRectangleDetector(image_, 15, cx, cy).detect();
pointA = cornerPoints[0];
pointB = cornerPoints[1];
pointC = cornerPoints[2];
pointD = cornerPoints[3];
} catch (NotFoundException const& e) {
(void)e;
pointA = getFirstDifferent(Ref<Point>(new Point(cx+7, cy-7)), false, 1, -1)->toResultPoint();
pointB = getFirstDifferent(Ref<Point>(new Point(cx+7, cy+7)), false, 1, 1)->toResultPoint();
pointC = getFirstDifferent(Ref<Point>(new Point(cx-7, cy+7)), false, -1, 1)->toResultPoint();
pointD = getFirstDifferent(Ref<Point>(new Point(cx-7, cy-7)), false, -1, -1)->toResultPoint();
}
cx = MathUtils::round((pointA->getX() + pointD->getX() + pointB->getX() + pointC->getX()) / 4.0f);
cy = MathUtils::round((pointA->getY() + pointD->getY() + pointB->getY() + pointC->getY()) / 4.0f);
return Ref<Point>(new Point(cx, cy));
}
Ref<BitMatrix> Detector::sampleGrid(Ref<zxing::BitMatrix> image,
Ref<zxing::ResultPoint> topLeft,
Ref<zxing::ResultPoint> bottomLeft,
Ref<zxing::ResultPoint> bottomRight,
Ref<zxing::ResultPoint> topRight) {
int dimension;
if (compact_) {
dimension = 4 * nbLayers_+11;
} else {
if (nbLayers_ <= 4) {
dimension = 4 * nbLayers_ + 15;
} else {
dimension = 4 * nbLayers_ + 2 * ((nbLayers_-4)/8 + 1) + 15;
}
}
GridSampler sampler = GridSampler::getInstance();
return sampler.sampleGrid(image,
dimension,
0.5f,
0.5f,
dimension - 0.5f,
0.5f,
dimension - 0.5f,
dimension - 0.5f,
0.5f,
dimension - 0.5f,
topLeft->getX(),
topLeft->getY(),
topRight->getX(),
topRight->getY(),
bottomRight->getX(),
bottomRight->getY(),
bottomLeft->getX(),
bottomLeft->getY());
}
void Detector::getParameters(Ref<zxing::BitArray> parameterData) {
nbLayers_ = 0;
nbDataBlocks_ = 0;
int nbBitsForNbLayers;
int nbBitsForNbDatablocks;
if (compact_) {
nbBitsForNbLayers = 2;
nbBitsForNbDatablocks = 6;
} else {
nbBitsForNbLayers = 5;
nbBitsForNbDatablocks = 11;
}
for (int i = 0; i < nbBitsForNbLayers; i++) {
nbLayers_ <<= 1;
if (parameterData->get(i)) {
nbLayers_++;
}
}
for (int i = nbBitsForNbLayers; i < nbBitsForNbLayers + nbBitsForNbDatablocks; i++) {
nbDataBlocks_ <<= 1;
if (parameterData->get(i)) {
nbDataBlocks_++;
}
}
nbLayers_++;
nbDataBlocks_++;
}
Ref<BitArray> Detector::sampleLine(Ref<zxing::aztec::Point> p1, Ref<zxing::aztec::Point> p2, int size) {
Ref<BitArray> res(new BitArray(size));
float d = distance(p1, p2);
float moduleSize = d / (size-1);
float dx = moduleSize * float(p2->getX() - p1->getX())/d;
float dy = moduleSize * float(p2->getY() - p1->getY())/d;
float px = float(p1->getX());
float py = float(p1->getY());
for (int i = 0; i < size; i++) {
if (image_->get(MathUtils::round(px), MathUtils::round(py))) res->set(i);
px+=dx;
py+=dy;
}
return res;
}
bool Detector::isWhiteOrBlackRectangle(Ref<zxing::aztec::Point> p1,
Ref<zxing::aztec::Point> p2,
Ref<zxing::aztec::Point> p3,
Ref<zxing::aztec::Point> p4) {
int corr = 3;
p1 = new Point(p1->getX() - corr, p1->getY() + corr);
p2 = new Point(p2->getX() - corr, p2->getY() - corr);
p3 = new Point(p3->getX() + corr, p3->getY() - corr);
p4 = new Point(p4->getX() + corr, p4->getY() + corr);
int cInit = getColor(p4, p1);
if (cInit == 0) {
return false;
}
int c = getColor(p1, p2);
if (c != cInit) {
return false;
}
c = getColor(p2, p3);
if (c != cInit) {
return false;
}
c = getColor(p3, p4);
if (c != cInit) {
return false;
}
return true;
}
int Detector::getColor(Ref<zxing::aztec::Point> p1, Ref<zxing::aztec::Point> p2) {
float d = distance(p1, p2);
float dx = (p2->getX() - p1->getX()) / d;
float dy = (p2->getY() - p1->getY()) / d;
int error = 0;
float px = float(p1->getX());
float py = float(p1->getY());
bool colorModel = image_->get(p1->getX(), p1->getY());
for (int i = 0; i < d; i++) {
px += dx;
py += dy;
if (image_->get(MathUtils::round(px), MathUtils::round(py)) != colorModel) {
error ++;
}
}
float errRatio = (float)error/d;
if (errRatio > 0.1f && errRatio < 0.9f) {
return 0;
}
return (errRatio <= 0.1) == colorModel ? 1 : -1;
}
Ref<Point> Detector::getFirstDifferent(Ref<zxing::aztec::Point> init, bool color, int dx, int dy) {
int x = init->getX() + dx;
int y = init->getY() + dy;
while (isValid(x, y) && image_->get(x, y) == color) {
x += dx;
y += dy;
}
x -= dx;
y -= dy;
while (isValid(x, y) && image_->get(x, y) == color) {
x += dx;
}
x -= dx;
while (isValid(x, y) && image_->get(x, y) == color) {
y += dy;
}
y -= dy;
return Ref<Point>(new Point(x, y));
}
bool Detector::isValid(int x, int y) {
return x >= 0 && x < (int)image_->getWidth() && y > 0 && y < (int)image_->getHeight();
}
float Detector::distance(Ref<zxing::aztec::Point> a, Ref<zxing::aztec::Point> b) {
return sqrtf((float)((a->getX() - b->getX()) * (a->getX() - b->getX()) + (a->getY() - b->getY()) * (a->getY() - b->getY())));
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/aztec/detector/Detector1.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 5,345
|
```objective-c
#ifndef __VERSION_H__
#define __VERSION_H__
/*
* Version.h
* zxing
*
* Created by Luiz Silva on 09/02/2010.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/ReaderException.h>
#include <zxing/common/BitMatrix.h>
#include <zxing/common/Counted.h>
#include <vector>
namespace zxing {
namespace datamatrix {
class ECB {
private:
int count_;
int dataCodewords_;
public:
ECB(int count, int dataCodewords);
int getCount();
int getDataCodewords();
};
class ECBlocks {
private:
int ecCodewords_;
std::vector<ECB*> ecBlocks_;
public:
ECBlocks(int ecCodewords, ECB *ecBlocks);
ECBlocks(int ecCodewords, ECB *ecBlocks1, ECB *ecBlocks2);
int getECCodewords();
std::vector<ECB*>& getECBlocks();
~ECBlocks();
};
class Version : public Counted {
private:
int versionNumber_;
int symbolSizeRows_;
int symbolSizeColumns_;
int dataRegionSizeRows_;
int dataRegionSizeColumns_;
ECBlocks* ecBlocks_;
int totalCodewords_;
Version(int versionNumber, int symbolSizeRows, int symbolSizeColumns, int dataRegionSizeRows,
int dataRegionSizeColumns, ECBlocks *ecBlocks);
public:
static std::vector<Ref<Version> > VERSIONS;
~Version();
int getVersionNumber();
int getSymbolSizeRows();
int getSymbolSizeColumns();
int getDataRegionSizeRows();
int getDataRegionSizeColumns();
int getTotalCodewords();
ECBlocks* getECBlocks();
static int buildVersions();
Ref<Version> getVersionForDimensions(int numRows, int numColumns);
private:
Version(const Version&);
Version & operator=(const Version&);
};
}
}
#endif // __VERSION_H__
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/datamatrix/Version.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 456
|
```c++
/*
* Version.cpp
* zxing
*
* Created by Luiz Silva on 09/02/2010.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/datamatrix/Version.h>
#include <limits>
#include <iostream>
namespace zxing {
namespace datamatrix {
using namespace std;
ECB::ECB(int count, int dataCodewords) :
count_(count), dataCodewords_(dataCodewords) {
}
int ECB::getCount() {
return count_;
}
int ECB::getDataCodewords() {
return dataCodewords_;
}
ECBlocks::ECBlocks(int ecCodewords, ECB *ecBlocks) :
ecCodewords_(ecCodewords), ecBlocks_(1, ecBlocks) {
}
ECBlocks::ECBlocks(int ecCodewords, ECB *ecBlocks1, ECB *ecBlocks2) :
ecCodewords_(ecCodewords), ecBlocks_(1, ecBlocks1) {
ecBlocks_.push_back(ecBlocks2);
}
int ECBlocks::getECCodewords() {
return ecCodewords_;
}
std::vector<ECB*>& ECBlocks::getECBlocks() {
return ecBlocks_;
}
ECBlocks::~ECBlocks() {
for (size_t i = 0; i < ecBlocks_.size(); i++) {
delete ecBlocks_[i];
}
}
vector<Ref<Version> > Version::VERSIONS;
static int N_VERSIONS = Version::buildVersions();
Version::Version(int versionNumber, int symbolSizeRows, int symbolSizeColumns, int dataRegionSizeRows,
int dataRegionSizeColumns, ECBlocks* ecBlocks) : versionNumber_(versionNumber),
symbolSizeRows_(symbolSizeRows), symbolSizeColumns_(symbolSizeColumns),
dataRegionSizeRows_(dataRegionSizeRows), dataRegionSizeColumns_(dataRegionSizeColumns),
ecBlocks_(ecBlocks), totalCodewords_(0) {
// Calculate the total number of codewords
int total = 0;
int ecCodewords = ecBlocks_->getECCodewords();
vector<ECB*> &ecbArray = ecBlocks_->getECBlocks();
for (unsigned int i = 0; i < ecbArray.size(); i++) {
ECB *ecBlock = ecbArray[i];
total += ecBlock->getCount() * (ecBlock->getDataCodewords() + ecCodewords);
}
totalCodewords_ = total;
}
Version::~Version() {
delete ecBlocks_;
}
int Version::getVersionNumber() {
return versionNumber_;
}
int Version::getSymbolSizeRows() {
return symbolSizeRows_;
}
int Version::getSymbolSizeColumns() {
return symbolSizeColumns_;
}
int Version::getDataRegionSizeRows() {
return dataRegionSizeRows_;
}
int Version::getDataRegionSizeColumns() {
return dataRegionSizeColumns_;
}
int Version::getTotalCodewords() {
return totalCodewords_;
}
ECBlocks* Version::getECBlocks() {
return ecBlocks_;
}
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");
}
// TODO(bbrown): This is doing a linear search through the array of versions.
// If we interleave the rectangular versions with the square versions we could
// do a binary search.
for (int i = 0; i < N_VERSIONS; ++i){
Ref<Version> version(VERSIONS[i]);
if (version->getSymbolSizeRows() == numRows && version->getSymbolSizeColumns() == numColumns) {
return version;
}
}
throw ReaderException("Error version not found");
}
/**
* See ISO 16022:2006 5.5.1 Table 7
*/
int Version::buildVersions() {
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 VERSIONS.size();
}
}
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/datamatrix/Version1.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 2,221
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
* DecodedBitStreamParser.cpp
* zxing
*
* Created by Luiz Silva on 09/02/2010.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/FormatException.h>
#include <zxing/datamatrix/decoder/DecodedBitStreamParser.h>
#include <iostream>
#include <zxing/common/DecoderResult.h>
namespace zxing {
namespace datamatrix {
using namespace std;
const char DecodedBitStreamParser::C40_BASIC_SET_CHARS[] = {
'*', '*', '*', ' ', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
};
const char DecodedBitStreamParser::C40_SHIFT2_SET_CHARS[] = {
'!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.',
'/', ':', ';', '<', '=', '>', '?', '@', '[', '\\', ']', '^', '_'
};
const char DecodedBitStreamParser::TEXT_BASIC_SET_CHARS[] = {
'*', '*', '*', ' ', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
};
const char DecodedBitStreamParser::TEXT_SHIFT3_SET_CHARS[] = {
'\'', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '{', '|', '}', '~', (char) 127
};
Ref<DecoderResult> DecodedBitStreamParser::decode(ArrayRef<char> bytes) {
Ref<BitSource> bits(new BitSource(bytes));
ostringstream result;
ostringstream resultTrailer;
vector<char> byteSegments;
int mode = ASCII_ENCODE;
do {
if (mode == ASCII_ENCODE) {
mode = decodeAsciiSegment(bits, result, resultTrailer);
} else {
switch (mode) {
case C40_ENCODE:
decodeC40Segment(bits, result);
break;
case TEXT_ENCODE:
decodeTextSegment(bits, result);
break;
case ANSIX12_ENCODE:
decodeAnsiX12Segment(bits, result);
break;
case EDIFACT_ENCODE:
decodeEdifactSegment(bits, result);
break;
case BASE256_ENCODE:
decodeBase256Segment(bits, result, byteSegments);
break;
default:
throw FormatException("Unsupported mode indicator");
}
mode = ASCII_ENCODE;
}
} while (mode != PAD_ENCODE && bits->available() > 0);
if (resultTrailer.str().size() > 0) {
result << resultTrailer.str();
}
ArrayRef<char> rawBytes(bytes);
Ref<String> text(new String(result.str()));
return Ref<DecoderResult>(new DecoderResult(rawBytes, text));
}
int DecodedBitStreamParser::decodeAsciiSegment(Ref<BitSource> bits, ostringstream & result,
ostringstream & resultTrailer) {
bool upperShift = false;
do {
int oneByte = bits->readBits(8);
if (oneByte == 0) {
throw FormatException("Not enough bits to decode");
} else if (oneByte <= 128) { // ASCII data (ASCII value + 1)
oneByte = upperShift ? (oneByte + 128) : oneByte;
// upperShift = false;
result << (char) (oneByte - 1);
return ASCII_ENCODE;
} else if (oneByte == 129) { // Pad
return PAD_ENCODE;
} else if (oneByte <= 229) { // 2-digit data 00-99 (Numeric Value + 130)
int value = oneByte - 130;
if (value < 10) { // padd with '0' for single digit values
result << '0';
}
result << value;
} else if (oneByte == 230) { // Latch to C40 encodation
return C40_ENCODE;
} else if (oneByte == 231) { // Latch to Base 256 encodation
return BASE256_ENCODE;
} else if (oneByte == 232) { // FNC1
result << ((char) 29); // translate as ASCII 29
} else if (oneByte == 233 || oneByte == 234) {
// Structured Append, Reader Programming
// Ignore these symbols for now
// throw FormatException.getInstance();
} else if (oneByte == 235) { // Upper Shift (shift to Extended ASCII)
upperShift = true;
} else if (oneByte == 236) { // 05 Macro
result << ("[)>RS05GS");
resultTrailer << ("RSEOT");
} else if (oneByte == 237) { // 06 Macro
result << ("[)>RS06GS");
resultTrailer << ("RSEOT");
} else if (oneByte == 238) { // Latch to ANSI X12 encodation
return ANSIX12_ENCODE;
} else if (oneByte == 239) { // Latch to Text encodation
return TEXT_ENCODE;
} else if (oneByte == 240) { // Latch to EDIFACT encodation
return EDIFACT_ENCODE;
} else if (oneByte == 241) { // ECI Character
// TODO(bbrown): I think we need to support ECI
// throw FormatException.getInstance();
// Ignore this symbol for now
} else if (oneByte >= 242) { // Not to be used in ASCII encodation
// ... but work around encoders that end with 254, latch back to ASCII
if (oneByte != 254 || bits->available() != 0) {
throw FormatException("Not to be used in ASCII encodation");
}
}
} while (bits->available() > 0);
return ASCII_ENCODE;
}
void DecodedBitStreamParser::decodeC40Segment(Ref<BitSource> bits, ostringstream & result) {
// Three C40 values are encoded in a 16-bit value as
// (1600 * C1) + (40 * C2) + C3 + 1
// TODO(bbrown): The Upper Shift with C40 doesn't work in the 4 value scenario all the time
bool upperShift = false;
int cValues[3];
int shift = 0;
do {
// If there is only one byte left then it will be encoded as ASCII
if (bits->available() == 8) {
return;
}
int firstByte = bits->readBits(8);
if (firstByte == 254) { // Unlatch codeword
return;
}
parseTwoBytes(firstByte, bits->readBits(8), cValues);
for (int i = 0; i < 3; i++) {
int cValue = cValues[i];
switch (shift) {
case 0:
if (cValue < 3) {
shift = cValue + 1;
} else {
if (upperShift) {
result << (char) (C40_BASIC_SET_CHARS[cValue] + 128);
upperShift = false;
} else {
result << C40_BASIC_SET_CHARS[cValue];
}
}
break;
case 1:
if (upperShift) {
result << (char) (cValue + 128);
upperShift = false;
} else {
result << (char) cValue;
}
shift = 0;
break;
case 2:
if (cValue < 27) {
if (upperShift) {
result << (char) (C40_SHIFT2_SET_CHARS[cValue] + 128);
upperShift = false;
} else {
result << C40_SHIFT2_SET_CHARS[cValue];
}
} else if (cValue == 27) { // FNC1
result << ((char) 29); // translate as ASCII 29
} else if (cValue == 30) { // Upper Shift
upperShift = true;
} else {
throw FormatException("decodeC40Segment: Upper Shift");
}
shift = 0;
break;
case 3:
if (upperShift) {
result << (char) (cValue + 224);
upperShift = false;
} else {
result << (char) (cValue + 96);
}
shift = 0;
break;
default:
throw FormatException("decodeC40Segment: no case");
}
}
} while (bits->available() > 0);
}
void DecodedBitStreamParser::decodeTextSegment(Ref<BitSource> bits, ostringstream & result) {
// Three Text values are encoded in a 16-bit value as
// (1600 * C1) + (40 * C2) + C3 + 1
// TODO(bbrown): The Upper Shift with Text doesn't work in the 4 value scenario all the time
bool upperShift = false;
int cValues[3];
int shift = 0;
do {
// If there is only one byte left then it will be encoded as ASCII
if (bits->available() == 8) {
return;
}
int firstByte = bits->readBits(8);
if (firstByte == 254) { // Unlatch codeword
return;
}
parseTwoBytes(firstByte, bits->readBits(8), cValues);
for (int i = 0; i < 3; i++) {
int cValue = cValues[i];
switch (shift) {
case 0:
if (cValue < 3) {
shift = cValue + 1;
} else {
if (upperShift) {
result << (char) (TEXT_BASIC_SET_CHARS[cValue] + 128);
upperShift = false;
} else {
result << (TEXT_BASIC_SET_CHARS[cValue]);
}
}
break;
case 1:
if (upperShift) {
result << (char) (cValue + 128);
upperShift = false;
} else {
result << (char) (cValue);
}
shift = 0;
break;
case 2:
// Shift 2 for Text is the same encoding as C40
if (cValue < 27) {
if (upperShift) {
result << (char) (C40_SHIFT2_SET_CHARS[cValue] + 128);
upperShift = false;
} else {
result << (C40_SHIFT2_SET_CHARS[cValue]);
}
} else if (cValue == 27) { // FNC1
result << ((char) 29); // translate as ASCII 29
} else if (cValue == 30) { // Upper Shift
upperShift = true;
} else {
throw FormatException("decodeTextSegment: Upper Shift");
}
shift = 0;
break;
case 3:
if (upperShift) {
result << (char) (TEXT_SHIFT3_SET_CHARS[cValue] + 128);
upperShift = false;
} else {
result << (TEXT_SHIFT3_SET_CHARS[cValue]);
}
shift = 0;
break;
default:
throw FormatException("decodeTextSegment: no case");
}
}
} while (bits->available() > 0);
}
void DecodedBitStreamParser::decodeAnsiX12Segment(Ref<BitSource> bits, ostringstream & result) {
// Three ANSI X12 values are encoded in a 16-bit value as
// (1600 * C1) + (40 * C2) + C3 + 1
int cValues[3];
do {
// If there is only one byte left then it will be encoded as ASCII
if (bits->available() == 8) {
return;
}
int firstByte = bits->readBits(8);
if (firstByte == 254) { // Unlatch codeword
return;
}
parseTwoBytes(firstByte, bits->readBits(8), cValues);
for (int i = 0; i < 3; i++) {
int cValue = cValues[i];
if (cValue == 0) { // X12 segment terminator <CR>
result << '\r';
} else if (cValue == 1) { // X12 segment separator *
result << '*';
} else if (cValue == 2) { // X12 sub-element separator >
result << '>';
} else if (cValue == 3) { // space
result << ' ';
} else if (cValue < 14) { // 0 - 9
result << (char) (cValue + 44);
} else if (cValue < 40) { // A - Z
result << (char) (cValue + 51);
} else {
throw FormatException("decodeAnsiX12Segment: no case");
}
}
} while (bits->available() > 0);
}
void DecodedBitStreamParser::parseTwoBytes(int firstByte, int secondByte, int* result) {
int fullBitValue = (firstByte << 8) + secondByte - 1;
int temp = fullBitValue / 1600;
result[0] = temp;
fullBitValue -= temp * 1600;
temp = fullBitValue / 40;
result[1] = temp;
result[2] = fullBitValue - temp * 40;
}
void DecodedBitStreamParser::decodeEdifactSegment(Ref<BitSource> bits, ostringstream & result) {
do {
// If there is only two or less bytes left then it will be encoded as ASCII
if (bits->available() <= 16) {
return;
}
for (int i = 0; i < 4; i++) {
int edifactValue = bits->readBits(6);
// Check for the unlatch character
if (edifactValue == 0x1f) { // 011111
// Read rest of byte, which should be 0, and stop
int bitsLeft = 8 - bits->getBitOffset();
if (bitsLeft != 8) {
bits->readBits(bitsLeft);
}
return;
}
if ((edifactValue & 0x20) == 0) { // no 1 in the leading (6th) bit
edifactValue |= 0x40; // Add a leading 01 to the 6 bit binary value
}
result << (char)(edifactValue);
}
} while (bits->available() > 0);
}
void DecodedBitStreamParser::decodeBase256Segment(Ref<BitSource> bits, ostringstream& result, vector<char> byteSegments) {
// Figure out how long the Base 256 Segment is.
int codewordPosition = 1 + bits->getByteOffset(); // position is 1-indexed
int d1 = unrandomize255State(bits->readBits(8), codewordPosition++);
int count;
if (d1 == 0) { // Read the remainder of the symbol
count = bits->available() / 8;
} else if (d1 < 250) {
count = d1;
} else {
count = 250 * (d1 - 249) + unrandomize255State(bits->readBits(8), codewordPosition++);
}
// We're seeing NegativeArraySizeException errors from users.
if (count < 0) {
throw FormatException("NegativeArraySizeException");
}
for (int i = 0; i < count; i++) {
// Have seen this particular error in the wild, such as at
// path_to_url
if (bits->available() < 8) {
throw FormatException("byteSegments");
}
char byte = unrandomize255State(bits->readBits(8), codewordPosition++);
byteSegments.push_back(byte);
result << byte;
}
}
}
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/datamatrix/decoder/DecodedBitStreamParser1.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 3,897
|
```objective-c
#ifndef __DATA_BLOCK_DM_H__
#define __DATA_BLOCK_DM_H__
/*
* DataBlock.h
* zxing
*
* Created by Luiz Silva on 09/02/2010.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <vector>
#include <zxing/common/Counted.h>
#include <zxing/common/Array.h>
#include <zxing/datamatrix/Version.h>
namespace zxing {
namespace datamatrix {
class DataBlock : public Counted {
private:
int numDataCodewords_;
ArrayRef<char> codewords_;
DataBlock(int numDataCodewords, ArrayRef<char> codewords);
public:
static std::vector<Ref<DataBlock> > getDataBlocks(ArrayRef<char> rawCodewords, Version *version);
int getNumDataCodewords();
ArrayRef<char> getCodewords();
};
}
}
#endif // __DATA_BLOCK_DM_H__
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/datamatrix/decoder/DataBlock.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 229
|
```c++
/*
* BitMatrixParser.cpp
* zxing
*
* Created by Luiz Silva on 09/02/2010.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/datamatrix/decoder/BitMatrixParser.h>
#include <zxing/common/IllegalArgumentException.h>
#include <iostream>
namespace zxing {
namespace datamatrix {
int BitMatrixParser::copyBit(size_t x, size_t y, int versionBits) {
return bitMatrix_->get(x, y) ? (versionBits << 1) | 0x1 : versionBits << 1;
}
BitMatrixParser::BitMatrixParser(Ref<BitMatrix> bitMatrix) : bitMatrix_(NULL),
parsedVersion_(NULL),
readBitMatrix_(NULL) {
size_t dimension = bitMatrix->getHeight();
if (dimension < 8 || dimension > 144 || (dimension & 0x01) != 0)
throw ReaderException("Dimension must be even, > 8 < 144");
parsedVersion_ = readVersion(bitMatrix);
bitMatrix_ = extractDataRegion(bitMatrix);
readBitMatrix_ = new BitMatrix(bitMatrix_->getWidth(), bitMatrix_->getHeight());
}
Ref<Version> BitMatrixParser::readVersion(Ref<BitMatrix> bitMatrix) {
if (parsedVersion_ != 0) {
return parsedVersion_;
}
int numRows = bitMatrix->getHeight();
int numColumns = bitMatrix->getWidth();
Ref<Version> version = parsedVersion_->getVersionForDimensions(numRows, numColumns);
if (version != 0) {
return version;
}
throw ReaderException("Couldn't decode version");
}
ArrayRef<char> BitMatrixParser::readCodewords() {
ArrayRef<char> result(parsedVersion_->getTotalCodewords());
int resultOffset = 0;
int row = 4;
int column = 0;
int numRows = bitMatrix_->getHeight();
int numColumns = bitMatrix_->getWidth();
bool corner1Read = false;
bool corner2Read = false;
bool corner3Read = false;
bool corner4Read = false;
// Read all of the codewords
do {
// Check the four corner cases
if ((row == numRows) && (column == 0) && !corner1Read) {
result[resultOffset++] = (char) readCorner1(numRows, numColumns);
row -= 2;
column +=2;
corner1Read = true;
} else if ((row == numRows-2) && (column == 0) && ((numColumns & 0x03) != 0) && !corner2Read) {
result[resultOffset++] = (char) readCorner2(numRows, numColumns);
row -= 2;
column +=2;
corner2Read = true;
} else if ((row == numRows+4) && (column == 2) && ((numColumns & 0x07) == 0) && !corner3Read) {
result[resultOffset++] = (char) readCorner3(numRows, numColumns);
row -= 2;
column +=2;
corner3Read = true;
} else if ((row == numRows-2) && (column == 0) && ((numColumns & 0x07) == 4) && !corner4Read) {
result[resultOffset++] = (char) readCorner4(numRows, numColumns);
row -= 2;
column +=2;
corner4Read = true;
} else {
// Sweep upward diagonally to the right
do {
if ((row < numRows) && (column >= 0) && !readBitMatrix_->get(column, row)) {
result[resultOffset++] = (char) readUtah(row, column, numRows, numColumns);
}
row -= 2;
column +=2;
} while ((row >= 0) && (column < numColumns));
row += 1;
column +=3;
// Sweep downward diagonally to the left
do {
if ((row >= 0) && (column < numColumns) && !readBitMatrix_->get(column, row)) {
result[resultOffset++] = (char) readUtah(row, column, numRows, numColumns);
}
row += 2;
column -=2;
} while ((row < numRows) && (column >= 0));
row += 3;
column +=1;
}
} while ((row < numRows) || (column < numColumns));
if (resultOffset != parsedVersion_->getTotalCodewords()) {
throw ReaderException("Did not read all codewords");
}
return result;
}
bool BitMatrixParser::readModule(int row, int column, int numRows, int numColumns) {
// Adjust the row and column indices based on boundary wrapping
if (row < 0) {
row += numRows;
column += 4 - ((numRows + 4) & 0x07);
}
if (column < 0) {
column += numColumns;
row += 4 - ((numColumns + 4) & 0x07);
}
readBitMatrix_->set(column, row);
return bitMatrix_->get(column, row);
}
int BitMatrixParser::readUtah(int row, int column, int numRows, int numColumns) {
int currentByte = 0;
if (readModule(row - 2, column - 2, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(row - 2, column - 1, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(row - 1, column - 2, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(row - 1, column - 1, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(row - 1, column, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(row, column - 2, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(row, column - 1, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(row, column, numRows, numColumns)) {
currentByte |= 1;
}
return currentByte;
}
int BitMatrixParser::readCorner1(int numRows, int numColumns) {
int currentByte = 0;
if (readModule(numRows - 1, 0, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(numRows - 1, 1, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(numRows - 1, 2, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(0, numColumns - 2, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(0, numColumns - 1, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(1, numColumns - 1, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(2, numColumns - 1, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(3, numColumns - 1, numRows, numColumns)) {
currentByte |= 1;
}
return currentByte;
}
int BitMatrixParser::readCorner2(int numRows, int numColumns) {
int currentByte = 0;
if (readModule(numRows - 3, 0, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(numRows - 2, 0, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(numRows - 1, 0, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(0, numColumns - 4, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(0, numColumns - 3, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(0, numColumns - 2, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(0, numColumns - 1, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(1, numColumns - 1, numRows, numColumns)) {
currentByte |= 1;
}
return currentByte;
}
int BitMatrixParser::readCorner3(int numRows, int numColumns) {
int currentByte = 0;
if (readModule(numRows - 1, 0, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(numRows - 1, numColumns - 1, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(0, numColumns - 3, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(0, numColumns - 2, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(0, numColumns - 1, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(1, numColumns - 3, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(1, numColumns - 2, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(1, numColumns - 1, numRows, numColumns)) {
currentByte |= 1;
}
return currentByte;
}
int BitMatrixParser::readCorner4(int numRows, int numColumns) {
int currentByte = 0;
if (readModule(numRows - 3, 0, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(numRows - 2, 0, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(numRows - 1, 0, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(0, numColumns - 2, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(0, numColumns - 1, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(1, numColumns - 1, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(2, numColumns - 1, numRows, numColumns)) {
currentByte |= 1;
}
currentByte <<= 1;
if (readModule(3, numColumns - 1, numRows, numColumns)) {
currentByte |= 1;
}
return currentByte;
}
Ref<BitMatrix> BitMatrixParser::extractDataRegion(Ref<BitMatrix> bitMatrix) {
int symbolSizeRows = parsedVersion_->getSymbolSizeRows();
int symbolSizeColumns = parsedVersion_->getSymbolSizeColumns();
if ((int)bitMatrix->getHeight() != symbolSizeRows) {
throw IllegalArgumentException("Dimension of bitMatrix must match the version size");
}
int dataRegionSizeRows = parsedVersion_->getDataRegionSizeRows();
int dataRegionSizeColumns = parsedVersion_->getDataRegionSizeColumns();
int numDataRegionsRow = symbolSizeRows / dataRegionSizeRows;
int numDataRegionsColumn = symbolSizeColumns / dataRegionSizeColumns;
int sizeDataRegionRow = numDataRegionsRow * dataRegionSizeRows;
int sizeDataRegionColumn = numDataRegionsColumn * dataRegionSizeColumns;
Ref<BitMatrix> bitMatrixWithoutAlignment(new BitMatrix(sizeDataRegionColumn, sizeDataRegionRow));
for (int dataRegionRow = 0; dataRegionRow < numDataRegionsRow; ++dataRegionRow) {
int dataRegionRowOffset = dataRegionRow * dataRegionSizeRows;
for (int dataRegionColumn = 0; dataRegionColumn < numDataRegionsColumn; ++dataRegionColumn) {
int dataRegionColumnOffset = dataRegionColumn * dataRegionSizeColumns;
for (int i = 0; i < dataRegionSizeRows; ++i) {
int readRowOffset = dataRegionRow * (dataRegionSizeRows + 2) + 1 + i;
int writeRowOffset = dataRegionRowOffset + i;
for (int j = 0; j < dataRegionSizeColumns; ++j) {
int readColumnOffset = dataRegionColumn * (dataRegionSizeColumns + 2) + 1 + j;
if (bitMatrix->get(readColumnOffset, readRowOffset)) {
int writeColumnOffset = dataRegionColumnOffset + j;
bitMatrixWithoutAlignment->set(writeColumnOffset, writeRowOffset);
}
}
}
}
}
return bitMatrixWithoutAlignment;
}
}
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/datamatrix/decoder/BitMatrixParser1.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 3,192
|
```objective-c
#ifndef __BIT_MATRIX_PARSER_DM_H__
#define __BIT_MATRIX_PARSER_DM_H__
/*
* BitMatrixParser.h
* zxing
*
* Created by Luiz Silva on 09/02/2010.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/ReaderException.h>
#include <zxing/common/BitMatrix.h>
#include <zxing/common/Counted.h>
#include <zxing/common/Array.h>
#include <zxing/datamatrix/Version.h>
namespace zxing {
namespace datamatrix {
class BitMatrixParser : public Counted {
private:
Ref<BitMatrix> bitMatrix_;
Ref<Version> parsedVersion_;
Ref<BitMatrix> readBitMatrix_;
int copyBit(size_t x, size_t y, int versionBits);
public:
BitMatrixParser(Ref<BitMatrix> bitMatrix);
Ref<Version> readVersion(Ref<BitMatrix> bitMatrix);
ArrayRef<char> readCodewords();
bool readModule(int row, int column, int numRows, int numColumns);
private:
int readUtah(int row, int column, int numRows, int numColumns);
int readCorner1(int numRows, int numColumns);
int readCorner2(int numRows, int numColumns);
int readCorner3(int numRows, int numColumns);
int readCorner4(int numRows, int numColumns);
Ref<BitMatrix> extractDataRegion(Ref<BitMatrix> bitMatrix);
};
}
}
#endif // __BIT_MATRIX_PARSER_DM_H__
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/datamatrix/decoder/BitMatrixParser.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 353
|
```objective-c
#ifndef __DECODER_DM_H__
#define __DECODER_DM_H__
/*
* Decoder.h
* zxing
*
* Created by Luiz Silva on 09/02/2010.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#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 datamatrix {
class Decoder {
private:
ReedSolomonDecoder rsDecoder_;
void correctErrors(ArrayRef<char> bytes, int numDataCodewords);
public:
Decoder();
Ref<DecoderResult> decode(Ref<BitMatrix> bits);
};
}
}
#endif // __DECODER_DM_H__
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/datamatrix/decoder/Decoder.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 210
|
```objective-c
#ifndef __DECODED_BIT_STREAM_PARSER_DM_H__
#define __DECODED_BIT_STREAM_PARSER_DM_H__
/*
* DecodedBitStreamParser.h
* zxing
*
* Created by Luiz Silva on 09/02/2010.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <string>
#include <sstream>
#include <zxing/common/Array.h>
#include <zxing/common/BitSource.h>
#include <zxing/common/Counted.h>
#include <zxing/common/DecoderResult.h>
namespace zxing {
namespace datamatrix {
class DecodedBitStreamParser {
private:
static const int PAD_ENCODE = 0; // Not really an encoding
static const int ASCII_ENCODE = 1;
static const int C40_ENCODE = 2;
static const int TEXT_ENCODE = 3;
static const int ANSIX12_ENCODE = 4;
static const int EDIFACT_ENCODE = 5;
static const int BASE256_ENCODE = 6;
/**
* See ISO 16022:2006, Annex C Table C.1
* The C40 Basic Character Set (*'s used for placeholders for the shift values)
*/
static const char C40_BASIC_SET_CHARS[];
static const char C40_SHIFT2_SET_CHARS[];
/**
* See ISO 16022:2006, Annex C Table C.2
* The Text Basic Character Set (*'s used for placeholders for the shift values)
*/
static const char TEXT_BASIC_SET_CHARS[];
static const char TEXT_SHIFT3_SET_CHARS[];
/**
* See ISO 16022:2006, 5.2.3 and Annex C, Table C.2
*/
int decodeAsciiSegment(Ref<BitSource> bits, std::ostringstream &result, std::ostringstream &resultTrailer);
/**
* See ISO 16022:2006, 5.2.5 and Annex C, Table C.1
*/
void decodeC40Segment(Ref<BitSource> bits, std::ostringstream &result);
/**
* See ISO 16022:2006, 5.2.6 and Annex C, Table C.2
*/
void decodeTextSegment(Ref<BitSource> bits, std::ostringstream &result);
/**
* See ISO 16022:2006, 5.2.7
*/
void decodeAnsiX12Segment(Ref<BitSource> bits, std::ostringstream &result);
/**
* See ISO 16022:2006, 5.2.8 and Annex C Table C.3
*/
void decodeEdifactSegment(Ref<BitSource> bits, std::ostringstream &result);
/**
* See ISO 16022:2006, 5.2.9 and Annex B, B.2
*/
void decodeBase256Segment(Ref<BitSource> bits, std::ostringstream &result, std::vector<char> byteSegments);
void parseTwoBytes(int firstByte, int secondByte, int* result);
/**
* See ISO 16022:2006, Annex B, B.2
*/
char unrandomize255State(int randomizedBase256Codeword,
int base256CodewordPosition) {
int pseudoRandomNumber = ((149 * base256CodewordPosition) % 255) + 1;
int tempVariable = randomizedBase256Codeword - pseudoRandomNumber;
return (char) (tempVariable >= 0 ? tempVariable : (tempVariable + 256));
};
void append(std::ostream &ost, const char *bufIn, size_t nIn, const char *src);
public:
DecodedBitStreamParser() { };
Ref<DecoderResult> decode(ArrayRef<char> bytes);
};
}
}
#endif // __DECODED_BIT_STREAM_PARSER_DM_H__
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/datamatrix/decoder/DecodedBitStreamParser.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 868
|
```c++
/*
* DataBlock.cpp
* zxing
*
* Created by Luiz Silva on 09/02/2010.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/datamatrix/decoder/DataBlock.h>
#include <zxing/common/IllegalArgumentException.h>
namespace zxing {
namespace datamatrix {
using namespace std;
DataBlock::DataBlock(int numDataCodewords, ArrayRef<char> codewords) :
numDataCodewords_(numDataCodewords), codewords_(codewords) {
}
int DataBlock::getNumDataCodewords() {
return numDataCodewords_;
}
ArrayRef<char> DataBlock::getCodewords() {
return codewords_;
}
std::vector<Ref<DataBlock> > DataBlock::getDataBlocks(ArrayRef<char> rawCodewords, Version *version) {
// Figure out the number and size of data blocks used by this version and
// error correction level
ECBlocks* ecBlocks = version->getECBlocks();
// First count the total number of data blocks
int totalBlocks = 0;
vector<ECB*> ecBlockArray = ecBlocks->getECBlocks();
for (size_t i = 0; i < ecBlockArray.size(); i++) {
totalBlocks += ecBlockArray[i]->getCount();
}
// Now establish DataBlocks of the appropriate size and number of data codewords
std::vector<Ref<DataBlock> > result(totalBlocks);
int numResultBlocks = 0;
for (size_t j = 0; j < ecBlockArray.size(); j++) {
ECB *ecBlock = ecBlockArray[j];
for (int i = 0; i < ecBlock->getCount(); i++) {
int numDataCodewords = ecBlock->getDataCodewords();
int numBlockCodewords = ecBlocks->getECCodewords() + numDataCodewords;
ArrayRef<char> buffer(numBlockCodewords);
Ref<DataBlock> blockRef(new DataBlock(numDataCodewords, buffer));
result[numResultBlocks++] = blockRef;
}
}
// All blocks have the same amount of data, except that the last n
// (where n may be 0) have 1 more byte. Figure out where these start.
int shorterBlocksTotalCodewords = result[0]->codewords_->size();
int longerBlocksStartAt = result.size() - 1;
while (longerBlocksStartAt >= 0) {
int numCodewords = result[longerBlocksStartAt]->codewords_->size();
if (numCodewords == shorterBlocksTotalCodewords) {
break;
}
if (numCodewords != shorterBlocksTotalCodewords + 1) {
throw IllegalArgumentException("Data block sizes differ by more than 1");
}
longerBlocksStartAt--;
}
longerBlocksStartAt++;
int shorterBlocksNumDataCodewords = shorterBlocksTotalCodewords - ecBlocks->getECCodewords();
// The last elements of result may be 1 element longer;
// first fill out as many elements as all of them have
int rawCodewordsOffset = 0;
for (int i = 0; i < shorterBlocksNumDataCodewords; i++) {
for (int j = 0; j < numResultBlocks; j++) {
result[j]->codewords_[i] = rawCodewords[rawCodewordsOffset++];
}
}
// Fill out the last data block in the longer ones
for (int j = longerBlocksStartAt; j < numResultBlocks; j++) {
result[j]->codewords_[shorterBlocksNumDataCodewords] = rawCodewords[rawCodewordsOffset++];
}
// Now add in error correction blocks
int max = result[0]->codewords_->size();
for (int i = shorterBlocksNumDataCodewords; i < max; i++) {
for (int j = 0; j < numResultBlocks; j++) {
int iOffset = j < longerBlocksStartAt ? i : i + 1;
result[j]->codewords_[iOffset] = rawCodewords[rawCodewordsOffset++];
}
}
if (rawCodewordsOffset != rawCodewords->size()) {
throw IllegalArgumentException("rawCodewordsOffset != rawCodewords.length");
}
return result;
}
}
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/datamatrix/decoder/DataBlock1.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 1,020
|
```objective-c
#ifndef __CORNER_FINDER_H__
#define __CORNER_FINDER_H__
/*
* CornerPoint.h
* zxing
*
* Created by Luiz Silva on 09/02/2010.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/ResultPoint.h>
#include <cmath>
namespace zxing {
namespace datamatrix {
class CornerPoint : public ResultPoint {
private:
int counter_;
public:
CornerPoint(float posX, float posY);
int getCount() const;
void incrementCount();
bool equals(Ref<CornerPoint> other) const;
};
}
}
#endif // __CORNER_FINDER_H__
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/datamatrix/detector/CornerPoint.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 177
|
```c++
/*
* Decoder.cpp
* zxing
*
* Created by Luiz Silva on 09/02/2010.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/datamatrix/decoder/Decoder.h>
#include <zxing/datamatrix/decoder/BitMatrixParser.h>
#include <zxing/datamatrix/decoder/DataBlock.h>
#include <zxing/datamatrix/decoder/DecodedBitStreamParser.h>
#include <zxing/datamatrix/Version.h>
#include <zxing/ReaderException.h>
#include <zxing/ChecksumException.h>
#include <zxing/common/reedsolomon/ReedSolomonException.h>
using zxing::Ref;
using zxing::DecoderResult;
using zxing::datamatrix::Decoder;
// VC++
using zxing::ArrayRef;
using zxing::BitMatrix;
Decoder::Decoder() : rsDecoder_(GenericGF::DATA_MATRIX_FIELD_256) {}
void Decoder::correctErrors(ArrayRef<char> codewordBytes, int numDataCodewords) {
int numCodewords = codewordBytes->size();
ArrayRef<int> codewordInts(numCodewords);
for (int i = 0; i < numCodewords; i++) {
codewordInts[i] = codewordBytes[i] & 0xff;
}
int numECCodewords = numCodewords - numDataCodewords;
try {
rsDecoder_.decode(codewordInts, numECCodewords);
} catch (ReedSolomonException const& ignored) {
(void)ignored;
throw ChecksumException();
}
// Copy back into array of bytes -- only need to worry about the bytes that were data
// We don't care about errors in the error-correction codewords
for (int i = 0; i < numDataCodewords; i++) {
codewordBytes[i] = (char)codewordInts[i];
}
}
Ref<DecoderResult> Decoder::decode(Ref<BitMatrix> bits) {
// Construct a parser and read version, error-correction level
BitMatrixParser parser(bits);
Version *version = parser.readVersion(bits);
// Read codewords
ArrayRef<char> codewords(parser.readCodewords());
// Separate into data blocks
std::vector<Ref<DataBlock> > dataBlocks = DataBlock::getDataBlocks(codewords, version);
int dataBlocksCount = dataBlocks.size();
// Count total number of data bytes
int totalBytes = 0;
for (int i = 0; i < dataBlocksCount; i++) {
totalBytes += dataBlocks[i]->getNumDataCodewords();
}
ArrayRef<char> resultBytes(totalBytes);
// Error-correct and copy data blocks together into a stream of bytes
for (int j = 0; j < dataBlocksCount; j++) {
Ref<DataBlock> dataBlock(dataBlocks[j]);
ArrayRef<char> codewordBytes = dataBlock->getCodewords();
int numDataCodewords = dataBlock->getNumDataCodewords();
correctErrors(codewordBytes, numDataCodewords);
for (int i = 0; i < numDataCodewords; i++) {
// De-interlace data blocks.
resultBytes[i * dataBlocksCount + j] = codewordBytes[i];
}
}
// Decode the contents of that stream of bytes
DecodedBitStreamParser decodedBSParser;
return Ref<DecoderResult> (decodedBSParser.decode(resultBytes));
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/datamatrix/decoder/Decoder2.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 823
|
```c++
/*
* DetectorException.cpp
*
* Created on: Aug 26, 2011
* Author: luiz
*/
#include "DetectorException.h"
namespace zxing {
namespace datamatrix {
DetectorException::DetectorException(const char *msg) :
Exception(msg) {
}
DetectorException::~DetectorException() throw () {
// TODO Auto-generated destructor stub
}
}
} /* namespace zxing */
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/datamatrix/detector/DetectorException.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 86
|
```objective-c
/*
* DetectorException.h
*
* Created on: Aug 26, 2011
* Author: luiz
*/
#ifndef DETECTOREXCEPTION_H_
#define DETECTOREXCEPTION_H_
#include <zxing/Exception.h>
namespace zxing {
namespace datamatrix {
class DetectorException : public Exception {
public:
DetectorException(const char *msg);
virtual ~DetectorException() throw();
};
} /* namespace nexxera */
} /* namespace zxing */
#endif /* DETECTOREXCEPTION_H_ */
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/datamatrix/detector/DetectorException.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 112
|
```c++
/*
* CornerPoint.cpp
* zxing
*
* Created by Luiz Silva on 09/02/2010.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/datamatrix/detector/CornerPoint.h>
namespace zxing {
namespace datamatrix {
using namespace std;
CornerPoint::CornerPoint(float posX, float posY) :
ResultPoint(posX,posY), counter_(0) {
}
int CornerPoint::getCount() const {
return counter_;
}
void CornerPoint::incrementCount() {
counter_++;
}
bool CornerPoint::equals(Ref<CornerPoint> other) const {
return posX_ == other->getX() && posY_ == other->getY();
}
}
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/datamatrix/detector/CornerPoint.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 206
|
```objective-c
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
#ifndef __DETECTOR_H__
#define __DETECTOR_H__
/*
* Detector.h
* zxing
*
* Created by Luiz Silva on 09/02/2010.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <zxing/common/Counted.h>
#include <zxing/common/DetectorResult.h>
#include <zxing/common/BitMatrix.h>
#include <zxing/common/PerspectiveTransform.h>
#include <zxing/common/detector/WhiteRectangleDetector.h>
namespace zxing {
namespace datamatrix {
class ResultPointsAndTransitions: public Counted {
private:
Ref<ResultPoint> to_;
Ref<ResultPoint> from_;
int transitions_;
public:
ResultPointsAndTransitions();
ResultPointsAndTransitions(Ref<ResultPoint> from, Ref<ResultPoint> to, int transitions);
Ref<ResultPoint> getFrom();
Ref<ResultPoint> getTo();
int getTransitions();
};
class Detector: public Counted {
private:
Ref<BitMatrix> image_;
protected:
Ref<BitMatrix> sampleGrid(Ref<BitMatrix> image, int dimensionX, int dimensionY,
Ref<PerspectiveTransform> transform);
void insertionSort(std::vector<Ref<ResultPointsAndTransitions> >& vector);
Ref<ResultPoint> correctTopRightRectangular(Ref<ResultPoint> bottomLeft,
Ref<ResultPoint> bottomRight, Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight,
int dimensionTop, int dimensionRight);
Ref<ResultPoint> correctTopRight(Ref<ResultPoint> bottomLeft, Ref<ResultPoint> bottomRight,
Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight, int dimension);
bool isValid(Ref<ResultPoint> p);
int distance(Ref<ResultPoint> a, Ref<ResultPoint> b);
Ref<ResultPointsAndTransitions> transitionsBetween(Ref<ResultPoint> from, Ref<ResultPoint> to);
int min(int a, int b) {
return a > b ? b : a;
}
/**
* Ends up being a bit faster than round(). This merely rounds its
* argument to the nearest int, where x.5 rounds up.
*/
int round(float d) {
return (int) (d + 0.5f);
}
public:
Ref<BitMatrix> getImage();
Detector(Ref<BitMatrix> image);
virtual Ref<PerspectiveTransform> createTransform(Ref<ResultPoint> topLeft,
Ref<ResultPoint> topRight, Ref<ResultPoint> bottomLeft, Ref<ResultPoint> bottomRight,
int dimensionX, int dimensionY);
Ref<DetectorResult> detect();
private:
int compare(Ref<ResultPointsAndTransitions> a, Ref<ResultPointsAndTransitions> b);
};
}
}
#endif // __DETECTOR_H__
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/datamatrix/detector/Detector.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 653
|
```c++
// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
/*
* Detector.cpp
* zxing
*
* Created by Luiz Silva on 09/02/2010.
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#include <map>
#include <zxing/ResultPoint.h>
#include <zxing/common/GridSampler.h>
#include <zxing/datamatrix/detector/Detector.h>
#include <zxing/common/detector/MathUtils.h>
#include <zxing/NotFoundException.h>
#include <sstream>
#include <cstdlib>
#include <algorithm>
using std::abs;
using zxing::Ref;
using zxing::BitMatrix;
using zxing::ResultPoint;
using zxing::DetectorResult;
using zxing::PerspectiveTransform;
using zxing::NotFoundException;
using zxing::datamatrix::Detector;
using zxing::datamatrix::ResultPointsAndTransitions;
using zxing::common::detector::MathUtils;
namespace {
typedef std::map<Ref<ResultPoint>, int> PointMap;
void increment(PointMap& table, Ref<ResultPoint> const& key) {
int& value = table[key];
value += 1;
}
}
ResultPointsAndTransitions::ResultPointsAndTransitions() {
Ref<ResultPoint> ref(new ResultPoint(0, 0));
from_ = ref;
to_ = ref;
transitions_ = 0;
}
ResultPointsAndTransitions::ResultPointsAndTransitions(Ref<ResultPoint> from, Ref<ResultPoint> to,
int transitions)
: to_(to), from_(from), transitions_(transitions) {
}
Ref<ResultPoint> ResultPointsAndTransitions::getFrom() {
return from_;
}
Ref<ResultPoint> ResultPointsAndTransitions::getTo() {
return to_;
}
int ResultPointsAndTransitions::getTransitions() {
return transitions_;
}
Detector::Detector(Ref<BitMatrix> image)
: image_(image) {
}
Ref<BitMatrix> Detector::getImage() {
return image_;
}
Ref<DetectorResult> Detector::detect() {
Ref<WhiteRectangleDetector> rectangleDetector_(new WhiteRectangleDetector(image_));
std::vector<Ref<ResultPoint> > ResultPoints = rectangleDetector_->detect();
Ref<ResultPoint> pointA = ResultPoints[0];
Ref<ResultPoint> pointB = ResultPoints[1];
Ref<ResultPoint> pointC = ResultPoints[2];
Ref<ResultPoint> pointD = ResultPoints[3];
// Point A and D are across the diagonal from one another,
// as are B and C. Figure out which are the solid black lines
// by counting transitions
std::vector<Ref<ResultPointsAndTransitions> > transitions(4);
transitions[0].reset(transitionsBetween(pointA, pointB));
transitions[1].reset(transitionsBetween(pointA, pointC));
transitions[2].reset(transitionsBetween(pointB, pointD));
transitions[3].reset(transitionsBetween(pointC, pointD));
insertionSort(transitions);
// Sort by number of transitions. First two will be the two solid sides; last two
// will be the two alternating black/white sides
Ref<ResultPointsAndTransitions> lSideOne(transitions[0]);
Ref<ResultPointsAndTransitions> lSideTwo(transitions[1]);
// Figure out which point is their intersection by tallying up the number of times we see the
// endpoints in the four endpoints. One will show up twice.
typedef std::map<Ref<ResultPoint>, int> PointMap;
PointMap pointCount;
increment(pointCount, lSideOne->getFrom());
increment(pointCount, lSideOne->getTo());
increment(pointCount, lSideTwo->getFrom());
increment(pointCount, lSideTwo->getTo());
// Figure out which point is their intersection by tallying up the number of times we see the
// endpoints in the four endpoints. One will show up twice.
Ref<ResultPoint> maybeTopLeft;
Ref<ResultPoint> bottomLeft;
Ref<ResultPoint> maybeBottomRight;
for (PointMap::const_iterator entry = pointCount.begin(), end = pointCount.end(); entry != end; ++entry) {
Ref<ResultPoint> const& point = entry->first;
int value = entry->second;
if (value == 2) {
bottomLeft = point; // this is definitely the bottom left, then -- end of two L sides
} else {
// Otherwise it's either top left or bottom right -- just assign the two arbitrarily now
if (maybeTopLeft == 0) {
maybeTopLeft = point;
} else {
maybeBottomRight = point;
}
}
}
if (maybeTopLeft == 0 || bottomLeft == 0 || maybeBottomRight == 0) {
throw NotFoundException();
}
// Bottom left is correct but top left and bottom right might be switched
std::vector<Ref<ResultPoint> > corners(3);
corners[0].reset(maybeTopLeft);
corners[1].reset(bottomLeft);
corners[2].reset(maybeBottomRight);
// Use the dot product trick to sort them out
ResultPoint::orderBestPatterns(corners);
// Now we know which is which:
Ref<ResultPoint> bottomRight(corners[0]);
bottomLeft = corners[1];
Ref<ResultPoint> topLeft(corners[2]);
// Which point didn't we find in relation to the "L" sides? that's the top right corner
Ref<ResultPoint> topRight;
if (!(pointA->equals(bottomRight) || pointA->equals(bottomLeft) || pointA->equals(topLeft))) {
topRight = pointA;
} else if (!(pointB->equals(bottomRight) || pointB->equals(bottomLeft)
|| pointB->equals(topLeft))) {
topRight = pointB;
} else if (!(pointC->equals(bottomRight) || pointC->equals(bottomLeft)
|| pointC->equals(topLeft))) {
topRight = pointC;
} else {
topRight = pointD;
}
// Next determine the dimension by tracing along the top or right side and counting black/white
// transitions. Since we start inside a black module, we should see a number of transitions
// equal to 1 less than the code dimension. Well, actually 2 less, because we are going to
// end on a black module:
// The top right point is actually the corner of a module, which is one of the two black modules
// adjacent to the white module at the top right. Tracing to that corner from either the top left
// or bottom right should work here.
int dimensionTop = transitionsBetween(topLeft, topRight)->getTransitions();
int dimensionRight = transitionsBetween(bottomRight, topRight)->getTransitions();
//dimensionTop++;
if ((dimensionTop & 0x01) == 1) {
// it can't be odd, so, round... up?
dimensionTop++;
}
dimensionTop += 2;
//dimensionRight++;
if ((dimensionRight & 0x01) == 1) {
// it can't be odd, so, round... up?
dimensionRight++;
}
dimensionRight += 2;
Ref<BitMatrix> bits;
Ref<PerspectiveTransform> transform;
Ref<ResultPoint> correctedTopRight;
// Rectanguar symbols are 6x16, 6x28, 10x24, 10x32, 14x32, or 14x44. If one dimension is more
// than twice the other, it's certainly rectangular, but to cut a bit more slack we accept it as
// rectangular if the bigger side is at least 7/4 times the other:
if (4 * dimensionTop >= 7 * dimensionRight || 4 * dimensionRight >= 7 * dimensionTop) {
// The matrix is rectangular
correctedTopRight = correctTopRightRectangular(bottomLeft, bottomRight, topLeft, topRight,
dimensionTop, dimensionRight);
if (correctedTopRight == NULL) {
correctedTopRight = topRight;
}
dimensionTop = transitionsBetween(topLeft, correctedTopRight)->getTransitions();
dimensionRight = transitionsBetween(bottomRight, correctedTopRight)->getTransitions();
if ((dimensionTop & 0x01) == 1) {
// it can't be odd, so, round... up?
dimensionTop++;
}
if ((dimensionRight & 0x01) == 1) {
// it can't be odd, so, round... up?
dimensionRight++;
}
transform = createTransform(topLeft, correctedTopRight, bottomLeft, bottomRight, dimensionTop,
dimensionRight);
bits = sampleGrid(image_, dimensionTop, dimensionRight, transform);
} else {
// The matrix is square
int dimension = min(dimensionRight, dimensionTop);
// correct top right point to match the white module
correctedTopRight = correctTopRight(bottomLeft, bottomRight, topLeft, topRight, dimension);
if (correctedTopRight == NULL) {
correctedTopRight = topRight;
}
// Redetermine the dimension using the corrected top right point
int dimensionCorrected = std::max(transitionsBetween(topLeft, correctedTopRight)->getTransitions(),
transitionsBetween(bottomRight, correctedTopRight)->getTransitions());
dimensionCorrected++;
if ((dimensionCorrected & 0x01) == 1) {
dimensionCorrected++;
}
transform = createTransform(topLeft, correctedTopRight, bottomLeft, bottomRight,
dimensionCorrected, dimensionCorrected);
bits = sampleGrid(image_, dimensionCorrected, dimensionCorrected, transform);
}
ArrayRef< Ref<ResultPoint> > points (new Array< Ref<ResultPoint> >(4));
points[0].reset(topLeft);
points[1].reset(bottomLeft);
points[2].reset(correctedTopRight);
points[3].reset(bottomRight);
Ref<DetectorResult> detectorResult(new DetectorResult(bits, points));
return detectorResult;
}
/**
* Calculates the position of the white top right module using the output of the rectangle detector
* for a rectangular matrix
*/
Ref<ResultPoint> Detector::correctTopRightRectangular(Ref<ResultPoint> bottomLeft,
Ref<ResultPoint> bottomRight, Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight,
int dimensionTop, int dimensionRight) {
float corr = distance(bottomLeft, bottomRight) / (float) dimensionTop;
int norm = distance(topLeft, topRight);
float cos = (topRight->getX() - topLeft->getX()) / norm;
float sin = (topRight->getY() - topLeft->getY()) / norm;
Ref<ResultPoint> c1(
new ResultPoint(topRight->getX() + corr * cos, topRight->getY() + corr * sin));
corr = distance(bottomLeft, topLeft) / (float) dimensionRight;
norm = distance(bottomRight, topRight);
cos = (topRight->getX() - bottomRight->getX()) / norm;
sin = (topRight->getY() - bottomRight->getY()) / norm;
Ref<ResultPoint> c2(
new ResultPoint(topRight->getX() + corr * cos, topRight->getY() + corr * sin));
if (!isValid(c1)) {
if (isValid(c2)) {
return c2;
}
return Ref<ResultPoint>(NULL);
}
if (!isValid(c2)) {
return c1;
}
int l1 = abs(dimensionTop - transitionsBetween(topLeft, c1)->getTransitions())
+ abs(dimensionRight - transitionsBetween(bottomRight, c1)->getTransitions());
int l2 = abs(dimensionTop - transitionsBetween(topLeft, c2)->getTransitions())
+ abs(dimensionRight - transitionsBetween(bottomRight, c2)->getTransitions());
return l1 <= l2 ? c1 : c2;
}
/**
* Calculates the position of the white top right module using the output of the rectangle detector
* for a square matrix
*/
Ref<ResultPoint> Detector::correctTopRight(Ref<ResultPoint> bottomLeft,
Ref<ResultPoint> bottomRight, Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight,
int dimension) {
float corr = distance(bottomLeft, bottomRight) / (float) dimension;
int norm = distance(topLeft, topRight);
float cos = (topRight->getX() - topLeft->getX()) / norm;
float sin = (topRight->getY() - topLeft->getY()) / norm;
Ref<ResultPoint> c1(
new ResultPoint(topRight->getX() + corr * cos, topRight->getY() + corr * sin));
corr = distance(bottomLeft, topLeft) / (float) dimension;
norm = distance(bottomRight, topRight);
cos = (topRight->getX() - bottomRight->getX()) / norm;
sin = (topRight->getY() - bottomRight->getY()) / norm;
Ref<ResultPoint> c2(
new ResultPoint(topRight->getX() + corr * cos, topRight->getY() + corr * sin));
if (!isValid(c1)) {
if (isValid(c2)) {
return c2;
}
return Ref<ResultPoint>(NULL);
}
if (!isValid(c2)) {
return c1;
}
int l1 = abs(
transitionsBetween(topLeft, c1)->getTransitions()
- transitionsBetween(bottomRight, c1)->getTransitions());
int l2 = abs(
transitionsBetween(topLeft, c2)->getTransitions()
- transitionsBetween(bottomRight, c2)->getTransitions());
return l1 <= l2 ? c1 : c2;
}
bool Detector::isValid(Ref<ResultPoint> p) {
return p->getX() >= 0 && p->getX() < image_->getWidth() && p->getY() > 0
&& p->getY() < image_->getHeight();
}
int Detector::distance(Ref<ResultPoint> a, Ref<ResultPoint> b) {
return MathUtils::round(ResultPoint::distance(a, b));
}
Ref<ResultPointsAndTransitions> Detector::transitionsBetween(Ref<ResultPoint> from,
Ref<ResultPoint> to) {
// See QR Code Detector, sizeOfBlackWhiteBlackRun()
int fromX = (int) from->getX();
int fromY = (int) from->getY();
int toX = (int) to->getX();
int toY = (int) to->getY();
bool steep = abs(toY - fromY) > abs(toX - fromX);
if (steep) {
int temp = fromX;
fromX = fromY;
fromY = temp;
temp = toX;
toX = toY;
toY = temp;
}
int dx = abs(toX - fromX);
int dy = abs(toY - fromY);
int error = -dx / 2;
int ystep = fromY < toY ? 1 : -1;
int xstep = fromX < toX ? 1 : -1;
int transitions = 0;
bool inBlack = image_->get(steep ? fromY : fromX, steep ? fromX : fromY);
for (int x = fromX, y = fromY; x != toX; x += xstep) {
bool isBlack = image_->get(steep ? y : x, steep ? x : y);
if (isBlack != inBlack) {
transitions++;
inBlack = isBlack;
}
error += dy;
if (error > 0) {
if (y == toY) {
break;
}
y += ystep;
error -= dx;
}
}
Ref<ResultPointsAndTransitions> result(new ResultPointsAndTransitions(from, to, transitions));
return result;
}
Ref<PerspectiveTransform> Detector::createTransform(Ref<ResultPoint> topLeft,
Ref<ResultPoint> topRight, Ref<ResultPoint> bottomLeft, Ref<ResultPoint> bottomRight,
int dimensionX, int dimensionY) {
Ref<PerspectiveTransform> transform(
PerspectiveTransform::quadrilateralToQuadrilateral(
0.5f,
0.5f,
dimensionX - 0.5f,
0.5f,
dimensionX - 0.5f,
dimensionY - 0.5f,
0.5f,
dimensionY - 0.5f,
topLeft->getX(),
topLeft->getY(),
topRight->getX(),
topRight->getY(),
bottomRight->getX(),
bottomRight->getY(),
bottomLeft->getX(),
bottomLeft->getY()));
return transform;
}
Ref<BitMatrix> Detector::sampleGrid(Ref<BitMatrix> image, int dimensionX, int dimensionY,
Ref<PerspectiveTransform> transform) {
GridSampler &sampler = GridSampler::getInstance();
return sampler.sampleGrid(image, dimensionX, dimensionY, transform);
}
void Detector::insertionSort(std::vector<Ref<ResultPointsAndTransitions> > &vector) {
int max = vector.size();
bool swapped = true;
Ref<ResultPointsAndTransitions> value;
Ref<ResultPointsAndTransitions> valueB;
do {
swapped = false;
for (int i = 1; i < max; i++) {
value = vector[i - 1];
if (compare(value, (valueB = vector[i])) > 0){
swapped = true;
vector[i - 1].reset(valueB);
vector[i].reset(value);
}
}
} while (swapped);
}
int Detector::compare(Ref<ResultPointsAndTransitions> a, Ref<ResultPointsAndTransitions> b) {
return a->getTransitions() - b->getTransitions();
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/zxing/datamatrix/detector/Detector2.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 3,949
|
```objective-c
#ifndef _LIBICONV_H
#define _LIBICONV_H
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef void* iconv_t;
iconv_t iconv_open(const char *tocode, const char *fromcode);
int iconv_close(iconv_t cd);
size_t iconv(iconv_t cd, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);
#ifdef __cplusplus
}
#endif
#endif//_LIBICONV_H
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/win32/zxing/iconv.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 112
|
```objective-c
// ISO C9x compliant stdint.h for Microsoft Visual Studio
// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
//
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. The name of the author may be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////////
#ifndef _MSC_VER // [
#error "Use this header only with Microsoft Visual C++ compilers!"
#endif // _MSC_VER ]
#ifndef _MSC_STDINT_H_ // [
#define _MSC_STDINT_H_
#if _MSC_VER > 1000
#pragma once
#endif
#include <limits.h>
// For Visual Studio 6 in C++ mode and for many Visual Studio versions when
// compiling for ARM we should wrap <wchar.h> include with 'extern "C++" {}'
// or compiler give many errors like this:
// error C2733: second C linkage of overloaded function 'wmemchr' not allowed
#ifdef __cplusplus
extern "C" {
#endif
# include <wchar.h>
#ifdef __cplusplus
}
#endif
// Define _W64 macros to mark types changing their size, like intptr_t.
#ifndef _W64
# if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
# define _W64 __w64
# else
# define _W64
# endif
#endif
// 7.18.1 Integer types
// 7.18.1.1 Exact-width integer types
// Visual Studio 6 and Embedded Visual C++ 4 doesn't
// realize that, e.g. char has the same size as __int8
// so we give up on __intX for them.
#if (_MSC_VER < 1300)
typedef signed char int8_t;
typedef signed short int16_t;
typedef signed int int32_t;
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
#else
typedef signed __int8 int8_t;
typedef signed __int16 int16_t;
typedef signed __int32 int32_t;
typedef unsigned __int8 uint8_t;
typedef unsigned __int16 uint16_t;
typedef unsigned __int32 uint32_t;
#endif
typedef signed __int64 int64_t;
typedef unsigned __int64 uint64_t;
// 7.18.1.2 Minimum-width integer types
typedef int8_t int_least8_t;
typedef int16_t int_least16_t;
typedef int32_t int_least32_t;
typedef int64_t int_least64_t;
typedef uint8_t uint_least8_t;
typedef uint16_t uint_least16_t;
typedef uint32_t uint_least32_t;
typedef uint64_t uint_least64_t;
// 7.18.1.3 Fastest minimum-width integer types
typedef int8_t int_fast8_t;
typedef int16_t int_fast16_t;
typedef int32_t int_fast32_t;
typedef int64_t int_fast64_t;
typedef uint8_t uint_fast8_t;
typedef uint16_t uint_fast16_t;
typedef uint32_t uint_fast32_t;
typedef uint64_t uint_fast64_t;
// 7.18.1.4 Integer types capable of holding object pointers
#ifdef _WIN64 // [
typedef signed __int64 intptr_t;
typedef unsigned __int64 uintptr_t;
#else // _WIN64 ][
typedef _W64 signed int intptr_t;
typedef _W64 unsigned int uintptr_t;
#endif // _WIN64 ]
// 7.18.1.5 Greatest-width integer types
typedef int64_t intmax_t;
typedef uint64_t uintmax_t;
// 7.18.2 Limits of specified-width integer types
#define __STDC_LIMIT_MACROS
#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [ See footnote 220 at page 257 and footnote 221 at page 259
// 7.18.2.1 Limits of exact-width integer types
#define INT8_MIN ((int8_t)_I8_MIN)
#define INT8_MAX _I8_MAX
#define INT16_MIN ((int16_t)_I16_MIN)
#define INT16_MAX _I16_MAX
#define INT32_MIN ((int32_t)_I32_MIN)
#define INT32_MAX _I32_MAX
#define INT64_MIN ((int64_t)_I64_MIN)
#define INT64_MAX _I64_MAX
#define UINT8_MAX _UI8_MAX
#define UINT16_MAX _UI16_MAX
#define UINT32_MAX _UI32_MAX
#define UINT64_MAX _UI64_MAX
// 7.18.2.2 Limits of minimum-width integer types
#define INT_LEAST8_MIN INT8_MIN
#define INT_LEAST8_MAX INT8_MAX
#define INT_LEAST16_MIN INT16_MIN
#define INT_LEAST16_MAX INT16_MAX
#define INT_LEAST32_MIN INT32_MIN
#define INT_LEAST32_MAX INT32_MAX
#define INT_LEAST64_MIN INT64_MIN
#define INT_LEAST64_MAX INT64_MAX
#define UINT_LEAST8_MAX UINT8_MAX
#define UINT_LEAST16_MAX UINT16_MAX
#define UINT_LEAST32_MAX UINT32_MAX
#define UINT_LEAST64_MAX UINT64_MAX
// 7.18.2.3 Limits of fastest minimum-width integer types
#define INT_FAST8_MIN INT8_MIN
#define INT_FAST8_MAX INT8_MAX
#define INT_FAST16_MIN INT16_MIN
#define INT_FAST16_MAX INT16_MAX
#define INT_FAST32_MIN INT32_MIN
#define INT_FAST32_MAX INT32_MAX
#define INT_FAST64_MIN INT64_MIN
#define INT_FAST64_MAX INT64_MAX
#define UINT_FAST8_MAX UINT8_MAX
#define UINT_FAST16_MAX UINT16_MAX
#define UINT_FAST32_MAX UINT32_MAX
#define UINT_FAST64_MAX UINT64_MAX
// 7.18.2.4 Limits of integer types capable of holding object pointers
#ifdef _WIN64 // [
# define INTPTR_MIN INT64_MIN
# define INTPTR_MAX INT64_MAX
# define UINTPTR_MAX UINT64_MAX
#else // _WIN64 ][
# define INTPTR_MIN INT32_MIN
# define INTPTR_MAX INT32_MAX
# define UINTPTR_MAX UINT32_MAX
#endif // _WIN64 ]
// 7.18.2.5 Limits of greatest-width integer types
#define INTMAX_MIN INT64_MIN
#define INTMAX_MAX INT64_MAX
#define UINTMAX_MAX UINT64_MAX
// 7.18.3 Limits of other integer types
#ifdef _WIN64 // [
# define PTRDIFF_MIN _I64_MIN
# define PTRDIFF_MAX _I64_MAX
#else // _WIN64 ][
# define PTRDIFF_MIN _I32_MIN
# define PTRDIFF_MAX _I32_MAX
#endif // _WIN64 ]
#define SIG_ATOMIC_MIN INT_MIN
#define SIG_ATOMIC_MAX INT_MAX
#ifndef SIZE_MAX // [
# ifdef _WIN64 // [
# define SIZE_MAX _UI64_MAX
# else // _WIN64 ][
# define SIZE_MAX _UI32_MAX
# endif // _WIN64 ]
#endif // SIZE_MAX ]
// WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h>
#ifndef WCHAR_MIN // [
# define WCHAR_MIN 0
#endif // WCHAR_MIN ]
#ifndef WCHAR_MAX // [
# define WCHAR_MAX _UI16_MAX
#endif // WCHAR_MAX ]
#define WINT_MIN 0
#define WINT_MAX _UI16_MAX
#endif // __STDC_LIMIT_MACROS ]
// 7.18.4 Limits of other integer types
#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [ See footnote 224 at page 260
// 7.18.4.1 Macros for minimum-width integer constants
#define INT8_C(val) val##i8
#define INT16_C(val) val##i16
#define INT32_C(val) val##i32
#define INT64_C(val) val##i64
#define UINT8_C(val) val##ui8
#define UINT16_C(val) val##ui16
#define UINT32_C(val) val##ui32
#define UINT64_C(val) val##ui64
// 7.18.4.2 Macros for greatest-width integer constants
#define INTMAX_C INT64_C
#define UINTMAX_C UINT64_C
#endif // __STDC_CONSTANT_MACROS ]
#endif // _MSC_STDINT_H_ ]
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/win32/zxing/stdint.h
|
objective-c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 2,178
|
```hack
#ifndef BIGUNSIGNED_H
#define BIGUNSIGNED_H
#include "NumberlikeArray.hh"
/* A BigUnsigned object represents a nonnegative integer of size limited only by
* available memory. BigUnsigneds support most mathematical operators and can
* be converted to and from most primitive integer types.
*
* The number is stored as a NumberlikeArray of unsigned longs as if it were
* written in base 256^sizeof(unsigned long). The least significant block is
* first, and the length is such that the most significant block is nonzero. */
class BigUnsigned : protected NumberlikeArray<unsigned long> {
public:
// Enumeration for the result of a comparison.
enum CmpRes { less = -1, equal = 0, greater = 1 };
// BigUnsigneds are built with a Blk type of unsigned long.
typedef unsigned long Blk;
typedef NumberlikeArray<Blk>::Index Index;
using NumberlikeArray<Blk>::N;
protected:
// Creates a BigUnsigned with a capacity; for internal use.
BigUnsigned(int, Index c) : NumberlikeArray<Blk>(0, c) {}
// Decreases len to eliminate any leading zero blocks.
void zapLeadingZeros() {
while (len > 0 && blk[len - 1] == 0)
len--;
}
public:
// Constructs zero.
BigUnsigned() : NumberlikeArray<Blk>() {}
// Copy constructor
BigUnsigned(const BigUnsigned &x) : NumberlikeArray<Blk>(x) {}
// Assignment operator
void operator=(const BigUnsigned &x) {
NumberlikeArray<Blk>::operator =(x);
}
// Constructor that copies from a given array of blocks.
BigUnsigned(const Blk *b, Index blen) : NumberlikeArray<Blk>(b, blen) {
// Eliminate any leading zeros we may have been passed.
zapLeadingZeros();
}
// Destructor. NumberlikeArray does the delete for us.
~BigUnsigned() {}
// Constructors from primitive integer types
BigUnsigned(unsigned long x);
BigUnsigned( long x);
BigUnsigned(unsigned int x);
BigUnsigned( int x);
BigUnsigned(unsigned short x);
BigUnsigned( short x);
protected:
// Helpers
template <class X> void initFromPrimitive (X x);
template <class X> void initFromSignedPrimitive(X x);
public:
/* Converters to primitive integer types
* The implicit conversion operators caused trouble, so these are now
* named. */
unsigned long toUnsignedLong () const;
long toLong () const;
unsigned int toUnsignedInt () const;
int toInt () const;
unsigned short toUnsignedShort() const;
short toShort () const;
protected:
// Helpers
template <class X> X convertToSignedPrimitive() const;
template <class X> X convertToPrimitive () const;
public:
// BIT/BLOCK ACCESSORS
// Expose these from NumberlikeArray directly.
using NumberlikeArray<Blk>::getCapacity;
using NumberlikeArray<Blk>::getLength;
/* Returns the requested block, or 0 if it is beyond the length (as if
* the number had 0s infinitely to the left). */
Blk getBlock(Index i) const { return i >= len ? 0 : blk[i]; }
/* Sets the requested block. The number grows or shrinks as necessary. */
void setBlock(Index i, Blk newBlock);
// The number is zero if and only if the canonical length is zero.
bool isZero() const { return NumberlikeArray<Blk>::isEmpty(); }
/* Returns the length of the number in bits, i.e., zero if the number
* is zero and otherwise one more than the largest value of bi for
* which getBit(bi) returns true. */
Index bitLength() const;
/* Get the state of bit bi, which has value 2^bi. Bits beyond the
* number's length are considered to be 0. */
bool getBit(Index bi) const {
return (getBlock(bi / N) & (Blk(1) << (bi % N))) != 0;
}
/* Sets the state of bit bi to newBit. The number grows or shrinks as
* necessary. */
void setBit(Index bi, bool newBit);
// COMPARISONS
// Compares this to x like Perl's <=>
CmpRes compareTo(const BigUnsigned &x) const;
// Ordinary comparison operators
bool operator ==(const BigUnsigned &x) const {
return NumberlikeArray<Blk>::operator ==(x);
}
bool operator !=(const BigUnsigned &x) const {
return NumberlikeArray<Blk>::operator !=(x);
}
bool operator < (const BigUnsigned &x) const { return compareTo(x) == less ; }
bool operator <=(const BigUnsigned &x) const { return compareTo(x) != greater; }
bool operator >=(const BigUnsigned &x) const { return compareTo(x) != less ; }
bool operator > (const BigUnsigned &x) const { return compareTo(x) == greater; }
/*
* BigUnsigned and BigInteger both provide three kinds of operators.
* Here ``big-integer'' refers to BigInteger or BigUnsigned.
*
* (1) Overloaded ``return-by-value'' operators:
* +, -, *, /, %, unary -, &, |, ^, <<, >>.
* Big-integer code using these operators looks identical to code using
* the primitive integer types. These operators take one or two
* big-integer inputs and return a big-integer result, which can then
* be assigned to a BigInteger variable or used in an expression.
* Example:
* BigInteger a(1), b = 1;
* BigInteger c = a + b;
*
* (2) Overloaded assignment operators:
* +=, -=, *=, /=, %=, flipSign, &=, |=, ^=, <<=, >>=, ++, --.
* Again, these are used on big integers just like on ints. They take
* one writable big integer that both provides an operand and receives a
* result. Most also take a second read-only operand.
* Example:
* BigInteger a(1), b(1);
* a += b;
*
* (3) Copy-less operations: `add', `subtract', etc.
* These named methods take operands as arguments and store the result
* in the receiver (*this), avoiding unnecessary copies and allocations.
* `divideWithRemainder' is special: it both takes the dividend from and
* stores the remainder into the receiver, and it takes a separate
* object in which to store the quotient. NOTE: If you are wondering
* why these don't return a value, you probably mean to use the
* overloaded return-by-value operators instead.
*
* Examples:
* BigInteger a(43), b(7), c, d;
*
* c = a + b; // Now c == 50.
* c.add(a, b); // Same effect but without the two copies.
*
* c.divideWithRemainder(b, d);
* // 50 / 7; now d == 7 (quotient) and c == 1 (remainder).
*
* // ``Aliased'' calls now do the right thing using a temporary
* // copy, but see note on `divideWithRemainder'.
* a.add(a, b);
*/
// COPY-LESS OPERATIONS
// These 8: Arguments are read-only operands, result is saved in *this.
void add(const BigUnsigned &a, const BigUnsigned &b);
void subtract(const BigUnsigned &a, const BigUnsigned &b);
void multiply(const BigUnsigned &a, const BigUnsigned &b);
void bitAnd(const BigUnsigned &a, const BigUnsigned &b);
void bitOr(const BigUnsigned &a, const BigUnsigned &b);
void bitXor(const BigUnsigned &a, const BigUnsigned &b);
/* Negative shift amounts translate to opposite-direction shifts,
* except for -2^(8*sizeof(int)-1) which is unimplemented. */
void bitShiftLeft(const BigUnsigned &a, int b);
void bitShiftRight(const BigUnsigned &a, int b);
/* `a.divideWithRemainder(b, q)' is like `q = a / b, a %= b'.
* / and % use semantics similar to Knuth's, which differ from the
* primitive integer semantics under division by zero. See the
* implementation in BigUnsigned.cc for details.
* `a.divideWithRemainder(b, a)' throws an exception: it doesn't make
* sense to write quotient and remainder into the same variable. */
void divideWithRemainder(const BigUnsigned &b, BigUnsigned &q);
/* `divide' and `modulo' are no longer offered. Use
* `divideWithRemainder' instead. */
// OVERLOADED RETURN-BY-VALUE OPERATORS
BigUnsigned operator +(const BigUnsigned &x) const;
BigUnsigned operator -(const BigUnsigned &x) const;
BigUnsigned operator *(const BigUnsigned &x) const;
BigUnsigned operator /(const BigUnsigned &x) const;
BigUnsigned operator %(const BigUnsigned &x) const;
/* OK, maybe unary minus could succeed in one case, but it really
* shouldn't be used, so it isn't provided. */
BigUnsigned operator &(const BigUnsigned &x) const;
BigUnsigned operator |(const BigUnsigned &x) const;
BigUnsigned operator ^(const BigUnsigned &x) const;
BigUnsigned operator <<(int b) const;
BigUnsigned operator >>(int b) const;
// OVERLOADED ASSIGNMENT OPERATORS
void operator +=(const BigUnsigned &x);
void operator -=(const BigUnsigned &x);
void operator *=(const BigUnsigned &x);
void operator /=(const BigUnsigned &x);
void operator %=(const BigUnsigned &x);
void operator &=(const BigUnsigned &x);
void operator |=(const BigUnsigned &x);
void operator ^=(const BigUnsigned &x);
void operator <<=(int b);
void operator >>=(int b);
/* INCREMENT/DECREMENT OPERATORS
* To discourage messy coding, these do not return *this, so prefix
* and postfix behave the same. */
void operator ++( );
void operator ++(int);
void operator --( );
void operator --(int);
// Helper function that needs access to BigUnsigned internals
friend Blk getShiftedBlock(const BigUnsigned &num, Index x,
unsigned int y);
// See BigInteger.cc.
template <class X>
friend X convertBigUnsignedToPrimitiveAccess(const BigUnsigned &a);
};
/* Implementing the return-by-value and assignment operators in terms of the
* copy-less operations. The copy-less operations are responsible for making
* any necessary temporary copies to work around aliasing. */
inline BigUnsigned BigUnsigned::operator +(const BigUnsigned &x) const {
BigUnsigned ans;
ans.add(*this, x);
return ans;
}
inline BigUnsigned BigUnsigned::operator -(const BigUnsigned &x) const {
BigUnsigned ans;
ans.subtract(*this, x);
return ans;
}
inline BigUnsigned BigUnsigned::operator *(const BigUnsigned &x) const {
BigUnsigned ans;
ans.multiply(*this, x);
return ans;
}
inline BigUnsigned BigUnsigned::operator /(const BigUnsigned &x) const {
if (x.isZero()) throw "BigUnsigned::operator /: division by zero";
BigUnsigned q, r;
r = *this;
r.divideWithRemainder(x, q);
return q;
}
inline BigUnsigned BigUnsigned::operator %(const BigUnsigned &x) const {
if (x.isZero()) throw "BigUnsigned::operator %: division by zero";
BigUnsigned q, r;
r = *this;
r.divideWithRemainder(x, q);
return r;
}
inline BigUnsigned BigUnsigned::operator &(const BigUnsigned &x) const {
BigUnsigned ans;
ans.bitAnd(*this, x);
return ans;
}
inline BigUnsigned BigUnsigned::operator |(const BigUnsigned &x) const {
BigUnsigned ans;
ans.bitOr(*this, x);
return ans;
}
inline BigUnsigned BigUnsigned::operator ^(const BigUnsigned &x) const {
BigUnsigned ans;
ans.bitXor(*this, x);
return ans;
}
inline BigUnsigned BigUnsigned::operator <<(int b) const {
BigUnsigned ans;
ans.bitShiftLeft(*this, b);
return ans;
}
inline BigUnsigned BigUnsigned::operator >>(int b) const {
BigUnsigned ans;
ans.bitShiftRight(*this, b);
return ans;
}
inline void BigUnsigned::operator +=(const BigUnsigned &x) {
add(*this, x);
}
inline void BigUnsigned::operator -=(const BigUnsigned &x) {
subtract(*this, x);
}
inline void BigUnsigned::operator *=(const BigUnsigned &x) {
multiply(*this, x);
}
inline void BigUnsigned::operator /=(const BigUnsigned &x) {
if (x.isZero()) throw "BigUnsigned::operator /=: division by zero";
/* The following technique is slightly faster than copying *this first
* when x is large. */
BigUnsigned q;
divideWithRemainder(x, q);
// *this contains the remainder, but we overwrite it with the quotient.
*this = q;
}
inline void BigUnsigned::operator %=(const BigUnsigned &x) {
if (x.isZero()) throw "BigUnsigned::operator %=: division by zero";
BigUnsigned q;
// Mods *this by x. Don't care about quotient left in q.
divideWithRemainder(x, q);
}
inline void BigUnsigned::operator &=(const BigUnsigned &x) {
bitAnd(*this, x);
}
inline void BigUnsigned::operator |=(const BigUnsigned &x) {
bitOr(*this, x);
}
inline void BigUnsigned::operator ^=(const BigUnsigned &x) {
bitXor(*this, x);
}
inline void BigUnsigned::operator <<=(int b) {
bitShiftLeft(*this, b);
}
inline void BigUnsigned::operator >>=(int b) {
bitShiftRight(*this, b);
}
/* Templates for conversions of BigUnsigned to and from primitive integers.
* BigInteger.cc needs to instantiate convertToPrimitive, and the uses in
* BigUnsigned.cc didn't do the trick; I think g++ inlined convertToPrimitive
* instead of generating linkable instantiations. So for consistency, I put
* all the templates here. */
// CONSTRUCTION FROM PRIMITIVE INTEGERS
/* Initialize this BigUnsigned from the given primitive integer. The same
* pattern works for all primitive integer types, so I put it into a template to
* reduce code duplication. (Don't worry: this is protected and we instantiate
* it only with primitive integer types.) Type X could be signed, but x is
* known to be nonnegative. */
template <class X>
void BigUnsigned::initFromPrimitive(X x) {
if (x == 0)
; // NumberlikeArray already initialized us to zero.
else {
// Create a single block. blk is NULL; no need to delete it.
cap = 1;
blk = new Blk[1];
len = 1;
blk[0] = Blk(x);
}
}
/* Ditto, but first check that x is nonnegative. I could have put the check in
* initFromPrimitive and let the compiler optimize it out for unsigned-type
* instantiations, but I wanted to avoid the warning stupidly issued by g++ for
* a condition that is constant in *any* instantiation, even if not in all. */
template <class X>
void BigUnsigned::initFromSignedPrimitive(X x) {
if (x < 0)
throw "BigUnsigned constructor: "
"Cannot construct a BigUnsigned from a negative number";
else
initFromPrimitive(x);
}
// CONVERSION TO PRIMITIVE INTEGERS
/* Template with the same idea as initFromPrimitive. This might be slightly
* slower than the previous version with the masks, but it's much shorter and
* clearer, which is the library's stated goal. */
template <class X>
X BigUnsigned::convertToPrimitive() const {
if (len == 0)
// The number is zero; return zero.
return 0;
else if (len == 1) {
// The single block might fit in an X. Try the conversion.
X x = X(blk[0]);
// Make sure the result accurately represents the block.
if (Blk(x) == blk[0])
// Successful conversion.
return x;
// Otherwise fall through.
}
throw "BigUnsigned::to<Primitive>: "
"Value is too big to fit in the requested type";
}
/* Wrap the above in an x >= 0 test to make sure we got a nonnegative result,
* not a negative one that happened to convert back into the correct nonnegative
* one. (E.g., catch incorrect conversion of 2^31 to the long -2^31.) Again,
* separated to avoid a g++ warning. */
template <class X>
X BigUnsigned::convertToSignedPrimitive() const {
X x = convertToPrimitive<X>();
if (x >= 0)
return x;
else
throw "BigUnsigned::to(Primitive): "
"Value is too big to fit in the requested type";
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/bigint/BigUnsigned.hh
|
hack
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 3,884
|
```hack
#ifndef BIGUNSIGNEDINABASE_H
#define BIGUNSIGNEDINABASE_H
#include "NumberlikeArray.hh"
#include "BigUnsigned.hh"
#include <string>
/*
* A BigUnsignedInABase object represents a nonnegative integer of size limited
* only by available memory, represented in a user-specified base that can fit
* in an `unsigned short' (most can, and this saves memory).
*
* BigUnsignedInABase is intended as an intermediary class with little
* functionality of its own. BigUnsignedInABase objects can be constructed
* from, and converted to, BigUnsigneds (requiring multiplication, mods, etc.)
* and `std::string's (by switching digit values for appropriate characters).
*
* BigUnsignedInABase is similar to BigUnsigned. Note the following:
*
* (1) They represent the number in exactly the same way, except that
* BigUnsignedInABase uses ``digits'' (or Digit) where BigUnsigned uses
* ``blocks'' (or Blk).
*
* (2) Both use the management features of NumberlikeArray. (In fact, my desire
* to add a BigUnsignedInABase class without duplicating a lot of code led me to
* introduce NumberlikeArray.)
*
* (3) The only arithmetic operation supported by BigUnsignedInABase is an
* equality test. Use BigUnsigned for arithmetic.
*/
class BigUnsignedInABase : protected NumberlikeArray<unsigned short> {
public:
// The digits of a BigUnsignedInABase are unsigned shorts.
typedef unsigned short Digit;
// That's also the type of a base.
typedef Digit Base;
protected:
// The base in which this BigUnsignedInABase is expressed
Base base;
// Creates a BigUnsignedInABase with a capacity; for internal use.
BigUnsignedInABase(int, Index c) : NumberlikeArray<Digit>(0, c) {}
// Decreases len to eliminate any leading zero digits.
void zapLeadingZeros() {
while (len > 0 && blk[len - 1] == 0)
len--;
}
public:
// Constructs zero in base 2.
BigUnsignedInABase() : NumberlikeArray<Digit>(), base(2) {}
// Copy constructor
BigUnsignedInABase(const BigUnsignedInABase &x) : NumberlikeArray<Digit>(x), base(x.base) {}
// Assignment operator
void operator =(const BigUnsignedInABase &x) {
NumberlikeArray<Digit>::operator =(x);
base = x.base;
}
// Constructor that copies from a given array of digits.
BigUnsignedInABase(const Digit *d, Index l, Base base);
// Destructor. NumberlikeArray does the delete for us.
~BigUnsignedInABase() {}
// LINKS TO BIGUNSIGNED
BigUnsignedInABase(const BigUnsigned &x, Base base);
operator BigUnsigned() const;
/* LINKS TO STRINGS
*
* These use the symbols ``0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'' to
* represent digits of 0 through 35. When parsing strings, lowercase is
* also accepted.
*
* All string representations are big-endian (big-place-value digits
* first). (Computer scientists have adopted zero-based counting; why
* can't they tolerate little-endian numbers?)
*
* No string representation has a ``base indicator'' like ``0x''.
*
* An exception is made for zero: it is converted to ``0'' and not the
* empty string.
*
* If you want different conventions, write your own routines to go
* between BigUnsignedInABase and strings. It's not hard.
*/
operator std::string() const;
BigUnsignedInABase(const std::string &s, Base base);
public:
// ACCESSORS
Base getBase() const { return base; }
// Expose these from NumberlikeArray directly.
using NumberlikeArray<Digit>::getCapacity;
using NumberlikeArray<Digit>::getLength;
/* Returns the requested digit, or 0 if it is beyond the length (as if
* the number had 0s infinitely to the left). */
Digit getDigit(Index i) const { return i >= len ? 0 : blk[i]; }
// The number is zero if and only if the canonical length is zero.
bool isZero() const { return NumberlikeArray<Digit>::isEmpty(); }
/* Equality test. For the purposes of this test, two BigUnsignedInABase
* values must have the same base to be equal. */
bool operator ==(const BigUnsignedInABase &x) const {
return base == x.base && NumberlikeArray<Digit>::operator ==(x);
}
bool operator !=(const BigUnsignedInABase &x) const { return !operator ==(x); }
};
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/bigint/BigUnsignedInABase.hh
|
hack
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 1,064
|
```c++
#include "BigIntegerUtils.hh"
#include "BigUnsignedInABase.hh"
std::string bigUnsignedToString(const BigUnsigned &x) {
return std::string(BigUnsignedInABase(x, 10));
}
std::string bigIntegerToString(const BigInteger &x) {
return (x.getSign() == BigInteger::negative)
? (std::string("-") + bigUnsignedToString(x.getMagnitude()))
: (bigUnsignedToString(x.getMagnitude()));
}
BigUnsigned stringToBigUnsigned(const std::string &s) {
return BigUnsigned(BigUnsignedInABase(s, 10));
}
BigInteger stringToBigInteger(const std::string &s) {
// Recognize a sign followed by a BigUnsigned.
return (s[0] == '-') ? BigInteger(stringToBigUnsigned(s.substr(1, s.length() - 1)), BigInteger::negative)
: (s[0] == '+') ? BigInteger(stringToBigUnsigned(s.substr(1, s.length() - 1)))
: BigInteger(stringToBigUnsigned(s));
}
std::ostream &operator <<(std::ostream &os, const BigUnsigned &x) {
BigUnsignedInABase::Base base;
long osFlags = os.flags();
if (osFlags & os.dec)
base = 10;
else if (osFlags & os.hex) {
base = 16;
if (osFlags & os.showbase)
os << "0x";
} else if (osFlags & os.oct) {
base = 8;
if (osFlags & os.showbase)
os << '0';
} else
throw "std::ostream << BigUnsigned: Could not determine the desired base from output-stream flags";
std::string s = std::string(BigUnsignedInABase(x, base));
os << s;
return os;
}
std::ostream &operator <<(std::ostream &os, const BigInteger &x) {
if (x.getSign() == BigInteger::negative)
os << '-';
os << x.getMagnitude();
return os;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/bigint/BigIntegerUtils.cc
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 434
|
```hack
// This header file includes all of the library header files.
#include "NumberlikeArray.hh"
#include "BigUnsigned.hh"
#include "BigInteger.hh"
#include "BigIntegerAlgorithms.hh"
#include "BigUnsignedInABase.hh"
#include "BigIntegerUtils.hh"
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/bigint/BigIntegerLibrary.hh
|
hack
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 53
|
```hack
#ifndef BIGINTEGER_H
#define BIGINTEGER_H
#include "BigUnsigned.hh"
/* A BigInteger object represents a signed integer of size limited only by
* available memory. BigUnsigneds support most mathematical operators and can
* be converted to and from most primitive integer types.
*
* A BigInteger is just an aggregate of a BigUnsigned and a sign. (It is no
* longer derived from BigUnsigned because that led to harmful implicit
* conversions.) */
class BigInteger {
public:
typedef BigUnsigned::Blk Blk;
typedef BigUnsigned::Index Index;
typedef BigUnsigned::CmpRes CmpRes;
static const CmpRes
less = BigUnsigned::less ,
equal = BigUnsigned::equal ,
greater = BigUnsigned::greater;
// Enumeration for the sign of a BigInteger.
enum Sign { negative = -1, zero = 0, positive = 1 };
protected:
Sign sign;
BigUnsigned mag;
public:
// Constructs zero.
BigInteger() : sign(zero), mag() {}
// Copy constructor
BigInteger(const BigInteger &x) : sign(x.sign), mag(x.mag) {};
// Assignment operator
void operator=(const BigInteger &x);
// Constructor that copies from a given array of blocks with a sign.
BigInteger(const Blk *b, Index blen, Sign s);
// Nonnegative constructor that copies from a given array of blocks.
BigInteger(const Blk *b, Index blen) : mag(b, blen) {
sign = mag.isZero() ? zero : positive;
}
// Constructor from a BigUnsigned and a sign
BigInteger(const BigUnsigned &x, Sign s);
// Nonnegative constructor from a BigUnsigned
BigInteger(const BigUnsigned &x) : mag(x) {
sign = mag.isZero() ? zero : positive;
}
// Constructors from primitive integer types
BigInteger(unsigned long x);
BigInteger( long x);
BigInteger(unsigned int x);
BigInteger( int x);
BigInteger(unsigned short x);
BigInteger( short x);
/* Converters to primitive integer types
* The implicit conversion operators caused trouble, so these are now
* named. */
unsigned long toUnsignedLong () const;
long toLong () const;
unsigned int toUnsignedInt () const;
int toInt () const;
unsigned short toUnsignedShort() const;
short toShort () const;
protected:
// Helper
template <class X> X convertToUnsignedPrimitive() const;
template <class X, class UX> X convertToSignedPrimitive() const;
public:
// ACCESSORS
Sign getSign() const { return sign; }
/* The client can't do any harm by holding a read-only reference to the
* magnitude. */
const BigUnsigned &getMagnitude() const { return mag; }
// Some accessors that go through to the magnitude
Index getLength() const { return mag.getLength(); }
Index getCapacity() const { return mag.getCapacity(); }
Blk getBlock(Index i) const { return mag.getBlock(i); }
bool isZero() const { return sign == zero; } // A bit special
// COMPARISONS
// Compares this to x like Perl's <=>
CmpRes compareTo(const BigInteger &x) const;
// Ordinary comparison operators
bool operator ==(const BigInteger &x) const {
return sign == x.sign && mag == x.mag;
}
bool operator !=(const BigInteger &x) const { return !operator ==(x); };
bool operator < (const BigInteger &x) const { return compareTo(x) == less ; }
bool operator <=(const BigInteger &x) const { return compareTo(x) != greater; }
bool operator >=(const BigInteger &x) const { return compareTo(x) != less ; }
bool operator > (const BigInteger &x) const { return compareTo(x) == greater; }
// OPERATORS -- See the discussion in BigUnsigned.hh.
void add (const BigInteger &a, const BigInteger &b);
void subtract(const BigInteger &a, const BigInteger &b);
void multiply(const BigInteger &a, const BigInteger &b);
/* See the comment on BigUnsigned::divideWithRemainder. Semantics
* differ from those of primitive integers when negatives and/or zeros
* are involved. */
void divideWithRemainder(const BigInteger &b, BigInteger &q);
void negate(const BigInteger &a);
/* Bitwise operators are not provided for BigIntegers. Use
* getMagnitude to get the magnitude and operate on that instead. */
BigInteger operator +(const BigInteger &x) const;
BigInteger operator -(const BigInteger &x) const;
BigInteger operator *(const BigInteger &x) const;
BigInteger operator /(const BigInteger &x) const;
BigInteger operator %(const BigInteger &x) const;
BigInteger operator -() const;
void operator +=(const BigInteger &x);
void operator -=(const BigInteger &x);
void operator *=(const BigInteger &x);
void operator /=(const BigInteger &x);
void operator %=(const BigInteger &x);
void flipSign();
// INCREMENT/DECREMENT OPERATORS
void operator ++( );
void operator ++(int);
void operator --( );
void operator --(int);
};
// NORMAL OPERATORS
/* These create an object to hold the result and invoke
* the appropriate put-here operation on it, passing
* this and x. The new object is then returned. */
inline BigInteger BigInteger::operator +(const BigInteger &x) const {
BigInteger ans;
ans.add(*this, x);
return ans;
}
inline BigInteger BigInteger::operator -(const BigInteger &x) const {
BigInteger ans;
ans.subtract(*this, x);
return ans;
}
inline BigInteger BigInteger::operator *(const BigInteger &x) const {
BigInteger ans;
ans.multiply(*this, x);
return ans;
}
inline BigInteger BigInteger::operator /(const BigInteger &x) const {
if (x.isZero()) throw "BigInteger::operator /: division by zero";
BigInteger q, r;
r = *this;
r.divideWithRemainder(x, q);
return q;
}
inline BigInteger BigInteger::operator %(const BigInteger &x) const {
if (x.isZero()) throw "BigInteger::operator %: division by zero";
BigInteger q, r;
r = *this;
r.divideWithRemainder(x, q);
return r;
}
inline BigInteger BigInteger::operator -() const {
BigInteger ans;
ans.negate(*this);
return ans;
}
/*
* ASSIGNMENT OPERATORS
*
* Now the responsibility for making a temporary copy if necessary
* belongs to the put-here operations. See Assignment Operators in
* BigUnsigned.hh.
*/
inline void BigInteger::operator +=(const BigInteger &x) {
add(*this, x);
}
inline void BigInteger::operator -=(const BigInteger &x) {
subtract(*this, x);
}
inline void BigInteger::operator *=(const BigInteger &x) {
multiply(*this, x);
}
inline void BigInteger::operator /=(const BigInteger &x) {
if (x.isZero()) throw "BigInteger::operator /=: division by zero";
/* The following technique is slightly faster than copying *this first
* when x is large. */
BigInteger q;
divideWithRemainder(x, q);
// *this contains the remainder, but we overwrite it with the quotient.
*this = q;
}
inline void BigInteger::operator %=(const BigInteger &x) {
if (x.isZero()) throw "BigInteger::operator %=: division by zero";
BigInteger q;
// Mods *this by x. Don't care about quotient left in q.
divideWithRemainder(x, q);
}
// This one is trivial
inline void BigInteger::flipSign() {
sign = Sign(-sign);
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/bigint/BigInteger.hh
|
hack
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 1,665
|
```hack
#ifndef BIGINTEGERUTILS_H
#define BIGINTEGERUTILS_H
#include "BigInteger.hh"
#include <string>
#include <iostream>
/* This file provides:
* - Convenient std::string <-> BigUnsigned/BigInteger conversion routines
* - std::ostream << operators for BigUnsigned/BigInteger */
// std::string conversion routines. Base 10 only.
std::string bigUnsignedToString(const BigUnsigned &x);
std::string bigIntegerToString(const BigInteger &x);
BigUnsigned stringToBigUnsigned(const std::string &s);
BigInteger stringToBigInteger(const std::string &s);
// Creates a BigInteger from data such as `char's; read below for details.
template <class T>
BigInteger dataToBigInteger(const T* data, BigInteger::Index length, BigInteger::Sign sign);
// Outputs x to os, obeying the flags `dec', `hex', `bin', and `showbase'.
std::ostream &operator <<(std::ostream &os, const BigUnsigned &x);
// Outputs x to os, obeying the flags `dec', `hex', `bin', and `showbase'.
// My somewhat arbitrary policy: a negative sign comes before a base indicator (like -0xFF).
std::ostream &operator <<(std::ostream &os, const BigInteger &x);
// BEGIN TEMPLATE DEFINITIONS.
/*
* Converts binary data to a BigInteger.
* Pass an array `data', its length, and the desired sign.
*
* Elements of `data' may be of any type `T' that has the following
* two properties (this includes almost all integral types):
*
* (1) `sizeof(T)' correctly gives the amount of binary data in one
* value of `T' and is a factor of `sizeof(Blk)'.
*
* (2) When a value of `T' is casted to a `Blk', the low bytes of
* the result contain the desired binary data.
*/
template <class T>
BigInteger dataToBigInteger(const T* data, BigInteger::Index length, BigInteger::Sign sign) {
// really ceiling(numBytes / sizeof(BigInteger::Blk))
unsigned int pieceSizeInBits = 8 * sizeof(T);
unsigned int piecesPerBlock = sizeof(BigInteger::Blk) / sizeof(T);
unsigned int numBlocks = (length + piecesPerBlock - 1) / piecesPerBlock;
// Allocate our block array
BigInteger::Blk *blocks = new BigInteger::Blk[numBlocks];
BigInteger::Index blockNum, pieceNum, pieceNumHere;
// Convert
for (blockNum = 0, pieceNum = 0; blockNum < numBlocks; blockNum++) {
BigInteger::Blk curBlock = 0;
for (pieceNumHere = 0; pieceNumHere < piecesPerBlock && pieceNum < length;
pieceNumHere++, pieceNum++)
curBlock |= (BigInteger::Blk(data[pieceNum]) << (pieceSizeInBits * pieceNumHere));
blocks[blockNum] = curBlock;
}
// Create the BigInteger.
BigInteger x(blocks, numBlocks, sign);
delete [] blocks;
return x;
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/bigint/BigIntegerUtils.hh
|
hack
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 659
|
```c
/*
* iconv implementation using Win32 API to convert.
*
* This file is placed in the public domain.
*/
/* for WC_NO_BEST_FIT_CHARS */
#ifndef WINVER
# define WINVER 0x0500
#endif
#define STRICT
#include <windows.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
/* WORKAROUND: */
#ifndef UNDER_CE
#define GetProcAddressA GetProcAddress
#endif
#if 0
# define MAKE_EXE
# define MAKE_DLL
# define USE_LIBICONV_DLL
#endif
#if !defined(DEFAULT_LIBICONV_DLL)
# define DEFAULT_LIBICONV_DLL ""
#endif
#define MB_CHAR_MAX 16
#define UNICODE_MODE_BOM_DONE 1
#define UNICODE_MODE_SWAPPED 2
#define FLAG_USE_BOM 1
#define FLAG_TRANSLIT 2 /* //TRANSLIT */
#define FLAG_IGNORE 4 /* //IGNORE */
typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef void* iconv_t;
iconv_t iconv_open(const char *tocode, const char *fromcode);
int iconv_close(iconv_t cd);
size_t iconv(iconv_t cd, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);
/* libiconv interface for vim */
#if defined(MAKE_DLL)
int
iconvctl (iconv_t cd, int request, void* argument)
{
/* not supported */
return 0;
}
#endif
typedef struct compat_t compat_t;
typedef struct csconv_t csconv_t;
typedef struct rec_iconv_t rec_iconv_t;
typedef iconv_t (*f_iconv_open)(const char *tocode, const char *fromcode);
typedef int (*f_iconv_close)(iconv_t cd);
typedef size_t (*f_iconv)(iconv_t cd, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);
typedef int* (*f_errno)(void);
typedef int (*f_mbtowc)(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
typedef int (*f_wctomb)(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
typedef int (*f_mblen)(csconv_t *cv, const uchar *buf, int bufsize);
typedef int (*f_flush)(csconv_t *cv, uchar *buf, int bufsize);
#define COMPAT_IN 1
#define COMPAT_OUT 2
/* unicode mapping for compatibility with other conversion table. */
struct compat_t {
uint in;
uint out;
uint flag;
};
struct csconv_t {
int codepage;
int flags;
f_mbtowc mbtowc;
f_wctomb wctomb;
f_mblen mblen;
f_flush flush;
DWORD mode;
compat_t *compat;
};
struct rec_iconv_t {
iconv_t cd;
f_iconv_close iconv_close;
f_iconv iconv;
f_errno _errno;
csconv_t from;
csconv_t to;
#if defined(USE_LIBICONV_DLL)
HMODULE hlibiconv;
#endif
};
static int win_iconv_open(rec_iconv_t *cd, const char *tocode, const char *fromcode);
static int win_iconv_close(iconv_t cd);
static size_t win_iconv(iconv_t cd, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);
static int load_mlang();
static int make_csconv(const char *name, csconv_t *cv);
static int name_to_codepage(const char *name);
static uint utf16_to_ucs4(const ushort *wbuf);
static void ucs4_to_utf16(uint wc, ushort *wbuf, int *wbufsize);
static int mbtowc_flags(int codepage);
static int must_use_null_useddefaultchar(int codepage);
static char *strrstr(const char *str, const char *token);
static char *xstrndup(const char *s, size_t n);
static int seterror(int err);
#if defined(USE_LIBICONV_DLL)
static int libiconv_iconv_open(rec_iconv_t *cd, const char *tocode, const char *fromcode);
static PVOID MyImageDirectoryEntryToData(LPVOID Base, BOOLEAN MappedAsImage, USHORT DirectoryEntry, PULONG Size);
static HMODULE find_imported_module_by_funcname(HMODULE hModule, const char *funcname);
static HMODULE hwiniconv;
#endif
static int sbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize);
static int dbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize);
static int mbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize);
static int utf8_mblen(csconv_t *cv, const uchar *buf, int bufsize);
static int eucjp_mblen(csconv_t *cv, const uchar *buf, int bufsize);
static int kernel_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
static int kernel_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
static int mlang_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
static int mlang_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
static int utf16_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
static int utf16_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
static int utf32_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
static int utf32_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
static int iso2022jp_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize);
static int iso2022jp_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize);
static int iso2022jp_flush(csconv_t *cv, uchar *buf, int bufsize);
static struct {
int codepage;
const char *name;
} codepage_alias[] = {
{65001, "CP65001"},
{65001, "UTF8"},
{65001, "UTF-8"},
{1200, "CP1200"},
{1200, "UTF16LE"},
{1200, "UTF-16LE"},
{1200, "UCS2LE"},
{1200, "UCS-2LE"},
{1201, "CP1201"},
{1201, "UTF16BE"},
{1201, "UTF-16BE"},
{1201, "UCS2BE"},
{1201, "UCS-2BE"},
{1201, "unicodeFFFE"},
{12000, "CP12000"},
{12000, "UTF32LE"},
{12000, "UTF-32LE"},
{12000, "UCS4LE"},
{12000, "UCS-4LE"},
{12001, "CP12001"},
{12001, "UTF32BE"},
{12001, "UTF-32BE"},
{12001, "UCS4BE"},
{12001, "UCS-4BE"},
#ifndef GLIB_COMPILATION
/*
* Default is big endian.
* See rfc2781 4.3 Interpreting text labelled as UTF-16.
*/
{1201, "UTF16"},
{1201, "UTF-16"},
{1201, "UCS2"},
{1201, "UCS-2"},
{12001, "UTF32"},
{12001, "UTF-32"},
{12001, "UCS-4"},
{12001, "UCS4"},
#else
/* Default is little endian, because the platform is */
{1200, "UTF16"},
{1200, "UTF-16"},
{1200, "UCS2"},
{1200, "UCS-2"},
{12000, "UTF32"},
{12000, "UTF-32"},
{12000, "UCS4"},
{12000, "UCS-4"},
#endif
/* copy from libiconv `iconv -l` */
/* !IsValidCodePage(367) */
{20127, "ANSI_X3.4-1968"},
{20127, "ANSI_X3.4-1986"},
{20127, "ASCII"},
{20127, "CP367"},
{20127, "IBM367"},
{20127, "ISO-IR-6"},
{20127, "ISO646-US"},
{20127, "ISO_646.IRV:1991"},
{20127, "US"},
{20127, "US-ASCII"},
{20127, "CSASCII"},
/* !IsValidCodePage(819) */
{1252, "CP819"},
{1252, "IBM819"},
{28591, "ISO-8859-1"},
{28591, "ISO-IR-100"},
{28591, "ISO8859-1"},
{28591, "ISO_8859-1"},
{28591, "ISO_8859-1:1987"},
{28591, "L1"},
{28591, "LATIN1"},
{28591, "CSISOLATIN1"},
{1250, "CP1250"},
{1250, "MS-EE"},
{1250, "WINDOWS-1250"},
{1251, "CP1251"},
{1251, "MS-CYRL"},
{1251, "WINDOWS-1251"},
{1252, "CP1252"},
{1252, "MS-ANSI"},
{1252, "WINDOWS-1252"},
{1253, "CP1253"},
{1253, "MS-GREEK"},
{1253, "WINDOWS-1253"},
{1254, "CP1254"},
{1254, "MS-TURK"},
{1254, "WINDOWS-1254"},
{1255, "CP1255"},
{1255, "MS-HEBR"},
{1255, "WINDOWS-1255"},
{1256, "CP1256"},
{1256, "MS-ARAB"},
{1256, "WINDOWS-1256"},
{1257, "CP1257"},
{1257, "WINBALTRIM"},
{1257, "WINDOWS-1257"},
{1258, "CP1258"},
{1258, "WINDOWS-1258"},
{850, "850"},
{850, "CP850"},
{850, "IBM850"},
{850, "CSPC850MULTILINGUAL"},
/* !IsValidCodePage(862) */
{862, "862"},
{862, "CP862"},
{862, "IBM862"},
{862, "CSPC862LATINHEBREW"},
{866, "866"},
{866, "CP866"},
{866, "IBM866"},
{866, "CSIBM866"},
/* !IsValidCodePage(154) */
{154, "CP154"},
{154, "CYRILLIC-ASIAN"},
{154, "PT154"},
{154, "PTCP154"},
{154, "CSPTCP154"},
/* !IsValidCodePage(1133) */
{1133, "CP1133"},
{1133, "IBM-CP1133"},
{874, "CP874"},
{874, "WINDOWS-874"},
/* !IsValidCodePage(51932) */
{51932, "CP51932"},
{51932, "MS51932"},
{51932, "WINDOWS-51932"},
{51932, "EUC-JP"},
{932, "CP932"},
{932, "MS932"},
{932, "SHIFFT_JIS"},
{932, "SHIFFT_JIS-MS"},
{932, "SJIS"},
{932, "SJIS-MS"},
{932, "SJIS-OPEN"},
{932, "SJIS-WIN"},
{932, "WINDOWS-31J"},
{932, "WINDOWS-932"},
{932, "CSWINDOWS31J"},
{50221, "CP50221"},
{50221, "ISO-2022-JP"},
{50221, "ISO-2022-JP-MS"},
{50221, "ISO2022-JP"},
{50221, "ISO2022-JP-MS"},
{50221, "MS50221"},
{50221, "WINDOWS-50221"},
{936, "CP936"},
{936, "GBK"},
{936, "MS936"},
{936, "WINDOWS-936"},
{950, "CP950"},
{950, "BIG5"},
{950, "BIG5HKSCS"},
{950, "BIG5-HKSCS"},
{949, "CP949"},
{949, "UHC"},
{949, "EUC-KR"},
{1361, "CP1361"},
{1361, "JOHAB"},
{437, "437"},
{437, "CP437"},
{437, "IBM437"},
{437, "CSPC8CODEPAGE437"},
{737, "CP737"},
{775, "CP775"},
{775, "IBM775"},
{775, "CSPC775BALTIC"},
{852, "852"},
{852, "CP852"},
{852, "IBM852"},
{852, "CSPCP852"},
/* !IsValidCodePage(853) */
{853, "CP853"},
{855, "855"},
{855, "CP855"},
{855, "IBM855"},
{855, "CSIBM855"},
{857, "857"},
{857, "CP857"},
{857, "IBM857"},
{857, "CSIBM857"},
/* !IsValidCodePage(858) */
{858, "CP858"},
{860, "860"},
{860, "CP860"},
{860, "IBM860"},
{860, "CSIBM860"},
{861, "861"},
{861, "CP-IS"},
{861, "CP861"},
{861, "IBM861"},
{861, "CSIBM861"},
{863, "863"},
{863, "CP863"},
{863, "IBM863"},
{863, "CSIBM863"},
{864, "CP864"},
{864, "IBM864"},
{864, "CSIBM864"},
{865, "865"},
{865, "CP865"},
{865, "IBM865"},
{865, "CSIBM865"},
{869, "869"},
{869, "CP-GR"},
{869, "CP869"},
{869, "IBM869"},
{869, "CSIBM869"},
/* !IsValidCodePage(1152) */
{1125, "CP1125"},
/*
* Code Page Identifiers
* path_to_url
*/
{37, "IBM037"}, /* IBM EBCDIC US-Canada */
{437, "IBM437"}, /* OEM United States */
{500, "IBM500"}, /* IBM EBCDIC International */
{708, "ASMO-708"}, /* Arabic (ASMO 708) */
/* 709 Arabic (ASMO-449+, BCON V4) */
/* 710 Arabic - Transparent Arabic */
{720, "DOS-720"}, /* Arabic (Transparent ASMO); Arabic (DOS) */
{737, "ibm737"}, /* OEM Greek (formerly 437G); Greek (DOS) */
{775, "ibm775"}, /* OEM Baltic; Baltic (DOS) */
{850, "ibm850"}, /* OEM Multilingual Latin 1; Western European (DOS) */
{852, "ibm852"}, /* OEM Latin 2; Central European (DOS) */
{855, "IBM855"}, /* OEM Cyrillic (primarily Russian) */
{857, "ibm857"}, /* OEM Turkish; Turkish (DOS) */
{858, "IBM00858"}, /* OEM Multilingual Latin 1 + Euro symbol */
{860, "IBM860"}, /* OEM Portuguese; Portuguese (DOS) */
{861, "ibm861"}, /* OEM Icelandic; Icelandic (DOS) */
{862, "DOS-862"}, /* OEM Hebrew; Hebrew (DOS) */
{863, "IBM863"}, /* OEM French Canadian; French Canadian (DOS) */
{864, "IBM864"}, /* OEM Arabic; Arabic (864) */
{865, "IBM865"}, /* OEM Nordic; Nordic (DOS) */
{866, "cp866"}, /* OEM Russian; Cyrillic (DOS) */
{869, "ibm869"}, /* OEM Modern Greek; Greek, Modern (DOS) */
{870, "IBM870"}, /* IBM EBCDIC Multilingual/ROECE (Latin 2); IBM EBCDIC Multilingual Latin 2 */
{874, "windows-874"}, /* ANSI/OEM Thai (same as 28605, ISO 8859-15); Thai (Windows) */
{875, "cp875"}, /* IBM EBCDIC Greek Modern */
{932, "shift_jis"}, /* ANSI/OEM Japanese; Japanese (Shift-JIS) */
{932, "shift-jis"}, /* alternative name for it */
{936, "gb2312"}, /* ANSI/OEM Simplified Chinese (PRC, Singapore); Chinese Simplified (GB2312) */
{949, "ks_c_5601-1987"}, /* ANSI/OEM Korean (Unified Hangul Code) */
{950, "big5"}, /* ANSI/OEM Traditional Chinese (Taiwan; Hong Kong SAR, PRC); Chinese Traditional (Big5) */
{950, "big5hkscs"}, /* ANSI/OEM Traditional Chinese (Hong Kong SAR); Chinese Traditional (Big5-HKSCS) */
{950, "big5-hkscs"}, /* alternative name for it */
{1026, "IBM1026"}, /* IBM EBCDIC Turkish (Latin 5) */
{1047, "IBM01047"}, /* IBM EBCDIC Latin 1/Open System */
{1140, "IBM01140"}, /* IBM EBCDIC US-Canada (037 + Euro symbol); IBM EBCDIC (US-Canada-Euro) */
{1141, "IBM01141"}, /* IBM EBCDIC Germany (20273 + Euro symbol); IBM EBCDIC (Germany-Euro) */
{1142, "IBM01142"}, /* IBM EBCDIC Denmark-Norway (20277 + Euro symbol); IBM EBCDIC (Denmark-Norway-Euro) */
{1143, "IBM01143"}, /* IBM EBCDIC Finland-Sweden (20278 + Euro symbol); IBM EBCDIC (Finland-Sweden-Euro) */
{1144, "IBM01144"}, /* IBM EBCDIC Italy (20280 + Euro symbol); IBM EBCDIC (Italy-Euro) */
{1145, "IBM01145"}, /* IBM EBCDIC Latin America-Spain (20284 + Euro symbol); IBM EBCDIC (Spain-Euro) */
{1146, "IBM01146"}, /* IBM EBCDIC United Kingdom (20285 + Euro symbol); IBM EBCDIC (UK-Euro) */
{1147, "IBM01147"}, /* IBM EBCDIC France (20297 + Euro symbol); IBM EBCDIC (France-Euro) */
{1148, "IBM01148"}, /* IBM EBCDIC International (500 + Euro symbol); IBM EBCDIC (International-Euro) */
{1149, "IBM01149"}, /* IBM EBCDIC Icelandic (20871 + Euro symbol); IBM EBCDIC (Icelandic-Euro) */
{1250, "windows-1250"}, /* ANSI Central European; Central European (Windows) */
{1251, "windows-1251"}, /* ANSI Cyrillic; Cyrillic (Windows) */
{1252, "windows-1252"}, /* ANSI Latin 1; Western European (Windows) */
{1253, "windows-1253"}, /* ANSI Greek; Greek (Windows) */
{1254, "windows-1254"}, /* ANSI Turkish; Turkish (Windows) */
{1255, "windows-1255"}, /* ANSI Hebrew; Hebrew (Windows) */
{1256, "windows-1256"}, /* ANSI Arabic; Arabic (Windows) */
{1257, "windows-1257"}, /* ANSI Baltic; Baltic (Windows) */
{1258, "windows-1258"}, /* ANSI/OEM Vietnamese; Vietnamese (Windows) */
{1361, "Johab"}, /* Korean (Johab) */
{10000, "macintosh"}, /* MAC Roman; Western European (Mac) */
{10001, "x-mac-japanese"}, /* Japanese (Mac) */
{10002, "x-mac-chinesetrad"}, /* MAC Traditional Chinese (Big5); Chinese Traditional (Mac) */
{10003, "x-mac-korean"}, /* Korean (Mac) */
{10004, "x-mac-arabic"}, /* Arabic (Mac) */
{10005, "x-mac-hebrew"}, /* Hebrew (Mac) */
{10006, "x-mac-greek"}, /* Greek (Mac) */
{10007, "x-mac-cyrillic"}, /* Cyrillic (Mac) */
{10008, "x-mac-chinesesimp"}, /* MAC Simplified Chinese (GB 2312); Chinese Simplified (Mac) */
{10010, "x-mac-romanian"}, /* Romanian (Mac) */
{10017, "x-mac-ukrainian"}, /* Ukrainian (Mac) */
{10021, "x-mac-thai"}, /* Thai (Mac) */
{10029, "x-mac-ce"}, /* MAC Latin 2; Central European (Mac) */
{10079, "x-mac-icelandic"}, /* Icelandic (Mac) */
{10081, "x-mac-turkish"}, /* Turkish (Mac) */
{10082, "x-mac-croatian"}, /* Croatian (Mac) */
{20000, "x-Chinese_CNS"}, /* CNS Taiwan; Chinese Traditional (CNS) */
{20001, "x-cp20001"}, /* TCA Taiwan */
{20002, "x_Chinese-Eten"}, /* Eten Taiwan; Chinese Traditional (Eten) */
{20003, "x-cp20003"}, /* IBM5550 Taiwan */
{20004, "x-cp20004"}, /* TeleText Taiwan */
{20005, "x-cp20005"}, /* Wang Taiwan */
{20105, "x-IA5"}, /* IA5 (IRV International Alphabet No. 5, 7-bit); Western European (IA5) */
{20106, "x-IA5-German"}, /* IA5 German (7-bit) */
{20107, "x-IA5-Swedish"}, /* IA5 Swedish (7-bit) */
{20108, "x-IA5-Norwegian"}, /* IA5 Norwegian (7-bit) */
{20127, "us-ascii"}, /* US-ASCII (7-bit) */
{20261, "x-cp20261"}, /* T.61 */
{20269, "x-cp20269"}, /* ISO 6937 Non-Spacing Accent */
{20273, "IBM273"}, /* IBM EBCDIC Germany */
{20277, "IBM277"}, /* IBM EBCDIC Denmark-Norway */
{20278, "IBM278"}, /* IBM EBCDIC Finland-Sweden */
{20280, "IBM280"}, /* IBM EBCDIC Italy */
{20284, "IBM284"}, /* IBM EBCDIC Latin America-Spain */
{20285, "IBM285"}, /* IBM EBCDIC United Kingdom */
{20290, "IBM290"}, /* IBM EBCDIC Japanese Katakana Extended */
{20297, "IBM297"}, /* IBM EBCDIC France */
{20420, "IBM420"}, /* IBM EBCDIC Arabic */
{20423, "IBM423"}, /* IBM EBCDIC Greek */
{20424, "IBM424"}, /* IBM EBCDIC Hebrew */
{20833, "x-EBCDIC-KoreanExtended"}, /* IBM EBCDIC Korean Extended */
{20838, "IBM-Thai"}, /* IBM EBCDIC Thai */
{20866, "koi8-r"}, /* Russian (KOI8-R); Cyrillic (KOI8-R) */
{20871, "IBM871"}, /* IBM EBCDIC Icelandic */
{20880, "IBM880"}, /* IBM EBCDIC Cyrillic Russian */
{20905, "IBM905"}, /* IBM EBCDIC Turkish */
{20924, "IBM00924"}, /* IBM EBCDIC Latin 1/Open System (1047 + Euro symbol) */
{20932, "EUC-JP"}, /* Japanese (JIS 0208-1990 and 0121-1990) */
{20936, "x-cp20936"}, /* Simplified Chinese (GB2312); Chinese Simplified (GB2312-80) */
{20949, "x-cp20949"}, /* Korean Wansung */
{21025, "cp1025"}, /* IBM EBCDIC Cyrillic Serbian-Bulgarian */
/* 21027 (deprecated) */
{21866, "koi8-u"}, /* Ukrainian (KOI8-U); Cyrillic (KOI8-U) */
{28591, "iso-8859-1"}, /* ISO 8859-1 Latin 1; Western European (ISO) */
{28591, "iso8859-1"}, /* ISO 8859-1 Latin 1; Western European (ISO) */
{28592, "iso-8859-2"}, /* ISO 8859-2 Central European; Central European (ISO) */
{28592, "iso8859-2"}, /* ISO 8859-2 Central European; Central European (ISO) */
{28593, "iso-8859-3"}, /* ISO 8859-3 Latin 3 */
{28593, "iso8859-3"}, /* ISO 8859-3 Latin 3 */
{28594, "iso-8859-4"}, /* ISO 8859-4 Baltic */
{28594, "iso8859-4"}, /* ISO 8859-4 Baltic */
{28595, "iso-8859-5"}, /* ISO 8859-5 Cyrillic */
{28595, "iso8859-5"}, /* ISO 8859-5 Cyrillic */
{28596, "iso-8859-6"}, /* ISO 8859-6 Arabic */
{28596, "iso8859-6"}, /* ISO 8859-6 Arabic */
{28597, "iso-8859-7"}, /* ISO 8859-7 Greek */
{28597, "iso8859-7"}, /* ISO 8859-7 Greek */
{28598, "iso-8859-8"}, /* ISO 8859-8 Hebrew; Hebrew (ISO-Visual) */
{28598, "iso8859-8"}, /* ISO 8859-8 Hebrew; Hebrew (ISO-Visual) */
{28599, "iso-8859-9"}, /* ISO 8859-9 Turkish */
{28599, "iso8859-9"}, /* ISO 8859-9 Turkish */
{28603, "iso-8859-13"}, /* ISO 8859-13 Estonian */
{28603, "iso8859-13"}, /* ISO 8859-13 Estonian */
{28605, "iso-8859-15"}, /* ISO 8859-15 Latin 9 */
{28605, "iso8859-15"}, /* ISO 8859-15 Latin 9 */
{29001, "x-Europa"}, /* Europa 3 */
{38598, "iso-8859-8-i"}, /* ISO 8859-8 Hebrew; Hebrew (ISO-Logical) */
{38598, "iso8859-8-i"}, /* ISO 8859-8 Hebrew; Hebrew (ISO-Logical) */
{50220, "iso-2022-jp"}, /* ISO 2022 Japanese with no halfwidth Katakana; Japanese (JIS) */
{50221, "csISO2022JP"}, /* ISO 2022 Japanese with halfwidth Katakana; Japanese (JIS-Allow 1 byte Kana) */
{50222, "iso-2022-jp"}, /* ISO 2022 Japanese JIS X 0201-1989; Japanese (JIS-Allow 1 byte Kana - SO/SI) */
{50225, "iso-2022-kr"}, /* ISO 2022 Korean */
{50225, "iso2022-kr"}, /* ISO 2022 Korean */
{50227, "x-cp50227"}, /* ISO 2022 Simplified Chinese; Chinese Simplified (ISO 2022) */
/* 50229 ISO 2022 Traditional Chinese */
/* 50930 EBCDIC Japanese (Katakana) Extended */
/* 50931 EBCDIC US-Canada and Japanese */
/* 50933 EBCDIC Korean Extended and Korean */
/* 50935 EBCDIC Simplified Chinese Extended and Simplified Chinese */
/* 50936 EBCDIC Simplified Chinese */
/* 50937 EBCDIC US-Canada and Traditional Chinese */
/* 50939 EBCDIC Japanese (Latin) Extended and Japanese */
{51932, "euc-jp"}, /* EUC Japanese */
{51936, "EUC-CN"}, /* EUC Simplified Chinese; Chinese Simplified (EUC) */
{51949, "euc-kr"}, /* EUC Korean */
/* 51950 EUC Traditional Chinese */
{52936, "hz-gb-2312"}, /* HZ-GB2312 Simplified Chinese; Chinese Simplified (HZ) */
{54936, "GB18030"}, /* Windows XP and later: GB18030 Simplified Chinese (4 byte); Chinese Simplified (GB18030) */
{57002, "x-iscii-de"}, /* ISCII Devanagari */
{57003, "x-iscii-be"}, /* ISCII Bengali */
{57004, "x-iscii-ta"}, /* ISCII Tamil */
{57005, "x-iscii-te"}, /* ISCII Telugu */
{57006, "x-iscii-as"}, /* ISCII Assamese */
{57007, "x-iscii-or"}, /* ISCII Oriya */
{57008, "x-iscii-ka"}, /* ISCII Kannada */
{57009, "x-iscii-ma"}, /* ISCII Malayalam */
{57010, "x-iscii-gu"}, /* ISCII Gujarati */
{57011, "x-iscii-pa"}, /* ISCII Punjabi */
{0, NULL}
};
/*
* SJIS SHIFTJIS table CP932 table
* ---- --------------------------- --------------------------------
* 5C U+00A5 YEN SIGN U+005C REVERSE SOLIDUS
* 7E U+203E OVERLINE U+007E TILDE
* 815C U+2014 EM DASH U+2015 HORIZONTAL BAR
* 815F U+005C REVERSE SOLIDUS U+FF3C FULLWIDTH REVERSE SOLIDUS
* 8160 U+301C WAVE DASH U+FF5E FULLWIDTH TILDE
* 8161 U+2016 DOUBLE VERTICAL LINE U+2225 PARALLEL TO
* 817C U+2212 MINUS SIGN U+FF0D FULLWIDTH HYPHEN-MINUS
* 8191 U+00A2 CENT SIGN U+FFE0 FULLWIDTH CENT SIGN
* 8192 U+00A3 POUND SIGN U+FFE1 FULLWIDTH POUND SIGN
* 81CA U+00AC NOT SIGN U+FFE2 FULLWIDTH NOT SIGN
*
* EUC-JP and ISO-2022-JP should be compatible with CP932.
*
* Kernel and MLang have different Unicode mapping table. Make sure
* which API is used.
*/
static compat_t cp932_compat[] = {
{0x00A5, 0x005C, COMPAT_OUT},
{0x203E, 0x007E, COMPAT_OUT},
{0x2014, 0x2015, COMPAT_OUT},
{0x301C, 0xFF5E, COMPAT_OUT},
{0x2016, 0x2225, COMPAT_OUT},
{0x2212, 0xFF0D, COMPAT_OUT},
{0x00A2, 0xFFE0, COMPAT_OUT},
{0x00A3, 0xFFE1, COMPAT_OUT},
{0x00AC, 0xFFE2, COMPAT_OUT},
{0, 0, 0}
};
static compat_t cp20932_compat[] = {
{0x00A5, 0x005C, COMPAT_OUT},
{0x203E, 0x007E, COMPAT_OUT},
{0x2014, 0x2015, COMPAT_OUT},
{0xFF5E, 0x301C, COMPAT_OUT|COMPAT_IN},
{0x2225, 0x2016, COMPAT_OUT|COMPAT_IN},
{0xFF0D, 0x2212, COMPAT_OUT|COMPAT_IN},
{0xFFE0, 0x00A2, COMPAT_OUT|COMPAT_IN},
{0xFFE1, 0x00A3, COMPAT_OUT|COMPAT_IN},
{0xFFE2, 0x00AC, COMPAT_OUT|COMPAT_IN},
{0, 0, 0}
};
static compat_t *cp51932_compat = cp932_compat;
/* cp20932_compat for kernel. cp932_compat for mlang. */
static compat_t *cp5022x_compat = cp932_compat;
typedef HRESULT (WINAPI *CONVERTINETSTRING)(
LPDWORD lpdwMode,
DWORD dwSrcEncoding,
DWORD dwDstEncoding,
LPCSTR lpSrcStr,
LPINT lpnSrcSize,
LPBYTE lpDstStr,
LPINT lpnDstSize
);
typedef HRESULT (WINAPI *CONVERTINETMULTIBYTETOUNICODE)(
LPDWORD lpdwMode,
DWORD dwSrcEncoding,
LPCSTR lpSrcStr,
LPINT lpnMultiCharCount,
LPWSTR lpDstStr,
LPINT lpnWideCharCount
);
typedef HRESULT (WINAPI *CONVERTINETUNICODETOMULTIBYTE)(
LPDWORD lpdwMode,
DWORD dwEncoding,
LPCWSTR lpSrcStr,
LPINT lpnWideCharCount,
LPSTR lpDstStr,
LPINT lpnMultiCharCount
);
typedef HRESULT (WINAPI *ISCONVERTINETSTRINGAVAILABLE)(
DWORD dwSrcEncoding,
DWORD dwDstEncoding
);
typedef HRESULT (WINAPI *LCIDTORFC1766A)(
LCID Locale,
LPSTR pszRfc1766,
int nChar
);
typedef HRESULT (WINAPI *LCIDTORFC1766W)(
LCID Locale,
LPWSTR pszRfc1766,
int nChar
);
typedef HRESULT (WINAPI *RFC1766TOLCIDA)(
LCID *pLocale,
LPSTR pszRfc1766
);
typedef HRESULT (WINAPI *RFC1766TOLCIDW)(
LCID *pLocale,
LPWSTR pszRfc1766
);
static CONVERTINETSTRING ConvertINetString;
static CONVERTINETMULTIBYTETOUNICODE ConvertINetMultiByteToUnicode;
static CONVERTINETUNICODETOMULTIBYTE ConvertINetUnicodeToMultiByte;
static ISCONVERTINETSTRINGAVAILABLE IsConvertINetStringAvailable;
static LCIDTORFC1766A LcidToRfc1766A;
static RFC1766TOLCIDA Rfc1766ToLcidA;
static int
load_mlang()
{
HMODULE h;
if (ConvertINetString != NULL)
return TRUE;
h = LoadLibrary(TEXT("mlang.dll"));
if (!h)
return FALSE;
ConvertINetString = (CONVERTINETSTRING)GetProcAddressA(h, "ConvertINetString");
ConvertINetMultiByteToUnicode = (CONVERTINETMULTIBYTETOUNICODE)GetProcAddressA(h, "ConvertINetMultiByteToUnicode");
ConvertINetUnicodeToMultiByte = (CONVERTINETUNICODETOMULTIBYTE)GetProcAddressA(h, "ConvertINetUnicodeToMultiByte");
IsConvertINetStringAvailable = (ISCONVERTINETSTRINGAVAILABLE)GetProcAddressA(h, "IsConvertINetStringAvailable");
LcidToRfc1766A = (LCIDTORFC1766A)GetProcAddressA(h, "LcidToRfc1766A");
Rfc1766ToLcidA = (RFC1766TOLCIDA)GetProcAddressA(h, "Rfc1766ToLcidA");
return TRUE;
}
iconv_t
iconv_open(const char *tocode, const char *fromcode)
{
rec_iconv_t *cd;
cd = (rec_iconv_t *)calloc(1, sizeof(rec_iconv_t));
if (cd == NULL)
return (iconv_t)(-1);
#if defined(USE_LIBICONV_DLL)
errno = 0;
if (libiconv_iconv_open(cd, tocode, fromcode))
return (iconv_t)cd;
#endif
/* reset the errno to prevent reporting wrong error code.
* 0 for unsorted error. */
errno = 0;
if (win_iconv_open(cd, tocode, fromcode))
return (iconv_t)cd;
free(cd);
return (iconv_t)(-1);
}
int
iconv_close(iconv_t _cd)
{
rec_iconv_t *cd = (rec_iconv_t *)_cd;
int r = cd->iconv_close(cd->cd);
int e = *(cd->_errno());
#if defined(USE_LIBICONV_DLL)
if (cd->hlibiconv != NULL)
FreeLibrary(cd->hlibiconv);
#endif
free(cd);
errno = e;
return r;
}
size_t
iconv(iconv_t _cd, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft)
{
rec_iconv_t *cd = (rec_iconv_t *)_cd;
size_t r = cd->iconv(cd->cd, inbuf, inbytesleft, outbuf, outbytesleft);
errno = *(cd->_errno());
return r;
}
static int
win_iconv_open(rec_iconv_t *cd, const char *tocode, const char *fromcode)
{
if (!make_csconv(fromcode, &cd->from) || !make_csconv(tocode, &cd->to))
return FALSE;
cd->iconv_close = win_iconv_close;
cd->iconv = win_iconv;
cd->_errno = _errno;
cd->cd = (iconv_t)cd;
return TRUE;
}
static int
win_iconv_close(iconv_t cd)
{
return 0;
}
static size_t
win_iconv(iconv_t _cd, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft)
{
rec_iconv_t *cd = (rec_iconv_t *)_cd;
ushort wbuf[MB_CHAR_MAX]; /* enough room for one character */
int insize;
int outsize;
int wsize;
DWORD frommode;
DWORD tomode;
uint wc;
compat_t *cp;
int i;
if (inbuf == NULL || *inbuf == NULL)
{
if (outbuf != NULL && *outbuf != NULL && cd->to.flush != NULL)
{
tomode = cd->to.mode;
outsize = cd->to.flush(&cd->to, (uchar *)*outbuf, *outbytesleft);
if (outsize == -1)
{
if ((cd->to.flags & FLAG_IGNORE) && errno != E2BIG)
{
outsize = 0;
}
else
{
cd->to.mode = tomode;
return (size_t)(-1);
}
}
*outbuf += outsize;
*outbytesleft -= outsize;
}
cd->from.mode = 0;
cd->to.mode = 0;
return 0;
}
while (*inbytesleft != 0)
{
frommode = cd->from.mode;
tomode = cd->to.mode;
wsize = MB_CHAR_MAX;
insize = cd->from.mbtowc(&cd->from, (const uchar *)*inbuf, *inbytesleft, wbuf, &wsize);
if (insize == -1)
{
if (cd->to.flags & FLAG_IGNORE)
{
cd->from.mode = frommode;
insize = 1;
wsize = 0;
}
else
{
cd->from.mode = frommode;
return (size_t)(-1);
}
}
if (wsize == 0)
{
*inbuf += insize;
*inbytesleft -= insize;
continue;
}
if (cd->from.compat != NULL)
{
wc = utf16_to_ucs4(wbuf);
cp = cd->from.compat;
for (i = 0; cp[i].in != 0; ++i)
{
if ((cp[i].flag & COMPAT_IN) && cp[i].out == wc)
{
ucs4_to_utf16(cp[i].in, wbuf, &wsize);
break;
}
}
}
if (cd->to.compat != NULL)
{
wc = utf16_to_ucs4(wbuf);
cp = cd->to.compat;
for (i = 0; cp[i].in != 0; ++i)
{
if ((cp[i].flag & COMPAT_OUT) && cp[i].in == wc)
{
ucs4_to_utf16(cp[i].out, wbuf, &wsize);
break;
}
}
}
outsize = cd->to.wctomb(&cd->to, wbuf, wsize, (uchar *)*outbuf, *outbytesleft);
if (outsize == -1)
{
if ((cd->to.flags & FLAG_IGNORE) && errno != E2BIG)
{
cd->to.mode = tomode;
outsize = 0;
}
else
{
cd->from.mode = frommode;
cd->to.mode = tomode;
return (size_t)(-1);
}
}
*inbuf += insize;
*outbuf += outsize;
*inbytesleft -= insize;
*outbytesleft -= outsize;
}
return 0;
}
static int
make_csconv(const char *_name, csconv_t *cv)
{
CPINFO cpinfo;
int use_compat = TRUE;
int flag = 0;
char *name;
char *p;
name = xstrndup(_name, strlen(_name));
if (name == NULL)
return FALSE;
/* check for option "enc_name//opt1//opt2" */
while ((p = strrstr(name, "//")) != NULL)
{
if (_stricmp(p + 2, "nocompat") == 0)
use_compat = FALSE;
else if (_stricmp(p + 2, "translit") == 0)
flag |= FLAG_TRANSLIT;
else if (_stricmp(p + 2, "ignore") == 0)
flag |= FLAG_IGNORE;
*p = 0;
}
cv->mode = 0;
cv->flags = flag;
cv->mblen = NULL;
cv->flush = NULL;
cv->compat = NULL;
cv->codepage = name_to_codepage(name);
if (cv->codepage == 1200 || cv->codepage == 1201)
{
cv->mbtowc = utf16_mbtowc;
cv->wctomb = utf16_wctomb;
if (_stricmp(name, "UTF-16") == 0 || _stricmp(name, "UTF16") == 0 ||
_stricmp(name, "UCS-2") == 0 || _stricmp(name, "UCS2") == 0)
cv->flags |= FLAG_USE_BOM;
}
else if (cv->codepage == 12000 || cv->codepage == 12001)
{
cv->mbtowc = utf32_mbtowc;
cv->wctomb = utf32_wctomb;
if (_stricmp(name, "UTF-32") == 0 || _stricmp(name, "UTF32") == 0 ||
_stricmp(name, "UCS-4") == 0 || _stricmp(name, "UCS4") == 0)
cv->flags |= FLAG_USE_BOM;
}
else if (cv->codepage == 65001)
{
cv->mbtowc = kernel_mbtowc;
cv->wctomb = kernel_wctomb;
cv->mblen = utf8_mblen;
}
else if ((cv->codepage == 50220 || cv->codepage == 50221 || cv->codepage == 50222) && load_mlang())
{
cv->mbtowc = iso2022jp_mbtowc;
cv->wctomb = iso2022jp_wctomb;
cv->flush = iso2022jp_flush;
}
else if (cv->codepage == 51932 && load_mlang())
{
cv->mbtowc = mlang_mbtowc;
cv->wctomb = mlang_wctomb;
cv->mblen = eucjp_mblen;
}
else if (IsValidCodePage(cv->codepage)
&& GetCPInfo(cv->codepage, &cpinfo) != 0)
{
cv->mbtowc = kernel_mbtowc;
cv->wctomb = kernel_wctomb;
if (cpinfo.MaxCharSize == 1)
cv->mblen = sbcs_mblen;
else if (cpinfo.MaxCharSize == 2)
cv->mblen = dbcs_mblen;
else
cv->mblen = mbcs_mblen;
}
else
{
/* not supported */
free(name);
errno = EINVAL;
return FALSE;
}
if (use_compat)
{
switch (cv->codepage)
{
case 932: cv->compat = cp932_compat; break;
case 20932: cv->compat = cp20932_compat; break;
case 51932: cv->compat = cp51932_compat; break;
case 50220: case 50221: case 50222: cv->compat = cp5022x_compat; break;
}
}
free(name);
return TRUE;
}
static int
name_to_codepage(const char *name)
{
int i;
if (*name == '\0' ||
strcmp(name, "char") == 0)
return GetACP();
else if (strcmp(name, "wchar_t") == 0)
return 1200;
else if (_strnicmp(name, "cp", 2) == 0)
return atoi(name + 2); /* CP123 */
else if ('0' <= name[0] && name[0] <= '9')
return atoi(name); /* 123 */
else if (_strnicmp(name, "xx", 2) == 0)
return atoi(name + 2); /* XX123 for debug */
for (i = 0; codepage_alias[i].name != NULL; ++i)
if (_stricmp(name, codepage_alias[i].name) == 0)
return codepage_alias[i].codepage;
return -1;
}
/*
* path_to_url
*/
static uint
utf16_to_ucs4(const ushort *wbuf)
{
uint wc = wbuf[0];
if (0xD800 <= wbuf[0] && wbuf[0] <= 0xDBFF)
wc = ((wbuf[0] & 0x3FF) << 10) + (wbuf[1] & 0x3FF) + 0x10000;
return wc;
}
static void
ucs4_to_utf16(uint wc, ushort *wbuf, int *wbufsize)
{
if (wc < 0x10000)
{
wbuf[0] = wc;
*wbufsize = 1;
}
else
{
wc -= 0x10000;
wbuf[0] = 0xD800 | ((wc >> 10) & 0x3FF);
wbuf[1] = 0xDC00 | (wc & 0x3FF);
*wbufsize = 2;
}
}
/*
* Check if codepage is one of those for which the dwFlags parameter
* to MultiByteToWideChar() must be zero. Return zero or
* MB_ERR_INVALID_CHARS. The docs in Platform SDK for for Windows
* Server 2003 R2 claims that also codepage 65001 is one of these, but
* that doesn't seem to be the case. The MSDN docs for MSVS2008 leave
* out 65001 (UTF-8), and that indeed seems to be the case on XP, it
* works fine to pass MB_ERR_INVALID_CHARS in dwFlags when converting
* from UTF-8.
*/
static int
mbtowc_flags(int codepage)
{
return (codepage == 50220 || codepage == 50221 ||
codepage == 50222 || codepage == 50225 ||
codepage == 50227 || codepage == 50229 ||
codepage == 52936 || codepage == 54936 ||
(codepage >= 57002 && codepage <= 57011) ||
codepage == 65000 || codepage == 42) ? 0 : MB_ERR_INVALID_CHARS;
}
/*
* Check if codepage is one those for which the lpUsedDefaultChar
* parameter to WideCharToMultiByte() must be NULL. The docs in
* Platform SDK for for Windows Server 2003 R2 claims that this is the
* list below, while the MSDN docs for MSVS2008 claim that it is only
* for 65000 (UTF-7) and 65001 (UTF-8). This time the earlier Platform
* SDK seems to be correct, at least for XP.
*/
static int
must_use_null_useddefaultchar(int codepage)
{
return (codepage == 65000 || codepage == 65001 ||
codepage == 50220 || codepage == 50221 ||
codepage == 50222 || codepage == 50225 ||
codepage == 50227 || codepage == 50229 ||
codepage == 52936 || codepage == 54936 ||
(codepage >= 57002 && codepage <= 57011) ||
codepage == 42);
}
static char *
strrstr(const char *str, const char *token)
{
int len = strlen(token);
const char *p = str + strlen(str);
while (str <= --p)
if (p[0] == token[0] && strncmp(p, token, len) == 0)
return (char *)p;
return NULL;
}
static char *
xstrndup(const char *s, size_t n)
{
char *p;
p = (char *)malloc(n + 1);
if (p == NULL)
return NULL;
memcpy(p, s, n);
p[n] = '\0';
return p;
}
static int
seterror(int err)
{
errno = err;
return -1;
}
#if defined(USE_LIBICONV_DLL)
static int
libiconv_iconv_open(rec_iconv_t *cd, const char *tocode, const char *fromcode)
{
HMODULE hlibiconv = NULL;
HMODULE hmsvcrt = NULL;
char *dllname;
const char *p;
const char *e;
f_iconv_open _iconv_open;
/*
* always try to load dll, so that we can switch dll in runtime.
*/
/* XXX: getenv() can't get variable set by SetEnvironmentVariable() */
p = getenv("WINICONV_LIBICONV_DLL");
if (p == NULL)
p = DEFAULT_LIBICONV_DLL;
/* parse comma separated value */
for ( ; *p != 0; p = (*e == ',') ? e + 1 : e)
{
e = strchr(p, ',');
if (p == e)
continue;
else if (e == NULL)
e = p + strlen(p);
dllname = xstrndup(p, e - p);
if (dllname == NULL)
return FALSE;
hlibiconv = LoadLibraryA(dllname);
free(dllname);
if (hlibiconv != NULL)
{
if (hlibiconv == hwiniconv)
{
FreeLibrary(hlibiconv);
hlibiconv = NULL;
continue;
}
break;
}
}
if (hlibiconv == NULL)
goto failed;
hmsvcrt = find_imported_module_by_funcname(hlibiconv, "_errno");
if (hmsvcrt == NULL)
goto failed;
_iconv_open = (f_iconv_open)GetProcAddressA(hlibiconv, "libiconv_open");
if (_iconv_open == NULL)
_iconv_open = (f_iconv_open)GetProcAddressA(hlibiconv, "iconv_open");
cd->iconv_close = (f_iconv_close)GetProcAddressA(hlibiconv, "libiconv_close");
if (cd->iconv_close == NULL)
cd->iconv_close = (f_iconv_close)GetProcAddressA(hlibiconv, "iconv_close");
cd->iconv = (f_iconv)GetProcAddressA(hlibiconv, "libiconv");
if (cd->iconv == NULL)
cd->iconv = (f_iconv)GetProcAddressA(hlibiconv, "iconv");
cd->_errno = (f_errno)GetProcAddressA(hmsvcrt, "_errno");
if (_iconv_open == NULL || cd->iconv_close == NULL
|| cd->iconv == NULL || cd->_errno == NULL)
goto failed;
cd->cd = _iconv_open(tocode, fromcode);
if (cd->cd == (iconv_t)(-1))
goto failed;
cd->hlibiconv = hlibiconv;
return TRUE;
failed:
if (hlibiconv != NULL)
FreeLibrary(hlibiconv);
/* do not free hmsvcrt which is obtained by GetModuleHandle() */
return FALSE;
}
/*
* Reference:
* path_to_url
* path_to_url~masapico/api_ImageDirectoryEntryToData.html
*
* The formal way is
* imagehlp.h or dbghelp.h
* imagehlp.lib or dbghelp.lib
* ImageDirectoryEntryToData()
*/
#define TO_DOS_HEADER(base) ((PIMAGE_DOS_HEADER)(base))
#define TO_NT_HEADERS(base) ((PIMAGE_NT_HEADERS)((LPBYTE)(base) + TO_DOS_HEADER(base)->e_lfanew))
static PVOID
MyImageDirectoryEntryToData(LPVOID Base, BOOLEAN MappedAsImage, USHORT DirectoryEntry, PULONG Size)
{
/* TODO: MappedAsImage? */
PIMAGE_DATA_DIRECTORY p;
p = TO_NT_HEADERS(Base)->OptionalHeader.DataDirectory + DirectoryEntry;
if (p->VirtualAddress == 0) {
*Size = 0;
return NULL;
}
*Size = p->Size;
return (PVOID)((LPBYTE)Base + p->VirtualAddress);
}
static HMODULE
find_imported_module_by_funcname(HMODULE hModule, const char *funcname)
{
DWORD_PTR Base;
ULONG Size;
PIMAGE_IMPORT_DESCRIPTOR Imp;
PIMAGE_THUNK_DATA Name; /* Import Name Table */
PIMAGE_IMPORT_BY_NAME ImpName;
Base = (DWORD_PTR)hModule;
Imp = (PIMAGE_IMPORT_DESCRIPTOR)MyImageDirectoryEntryToData(
(LPVOID)Base,
TRUE,
IMAGE_DIRECTORY_ENTRY_IMPORT,
&Size);
if (Imp == NULL)
return NULL;
for ( ; Imp->OriginalFirstThunk != 0; ++Imp)
{
Name = (PIMAGE_THUNK_DATA)(Base + Imp->OriginalFirstThunk);
for ( ; Name->u1.Ordinal != 0; ++Name)
{
if (!IMAGE_SNAP_BY_ORDINAL(Name->u1.Ordinal))
{
ImpName = (PIMAGE_IMPORT_BY_NAME)
(Base + (DWORD_PTR)Name->u1.AddressOfData);
if (strcmp((char *)ImpName->Name, funcname) == 0)
return GetModuleHandleA((char *)(Base + Imp->Name));
}
}
}
return NULL;
}
#endif
static int
sbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize)
{
return 1;
}
static int
dbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize)
{
int len = IsDBCSLeadByteEx(cv->codepage, buf[0]) ? 2 : 1;
if (bufsize < len)
return seterror(EINVAL);
return len;
}
static int
mbcs_mblen(csconv_t *cv, const uchar *buf, int bufsize)
{
int len = 0;
if (cv->codepage == 54936) {
if (buf[0] <= 0x7F) len = 1;
else if (buf[0] >= 0x81 && buf[0] <= 0xFE &&
bufsize >= 2 &&
((buf[1] >= 0x40 && buf[1] <= 0x7E) ||
(buf[1] >= 0x80 && buf[1] <= 0xFE))) len = 2;
else if (buf[0] >= 0x81 && buf[0] <= 0xFE &&
bufsize >= 4 &&
buf[1] >= 0x30 && buf[1] <= 0x39) len = 4;
else
return seterror(EINVAL);
return len;
}
else
return seterror(EINVAL);
}
static int
utf8_mblen(csconv_t *cv, const uchar *buf, int bufsize)
{
int len = 0;
if (buf[0] < 0x80) len = 1;
else if ((buf[0] & 0xE0) == 0xC0) len = 2;
else if ((buf[0] & 0xF0) == 0xE0) len = 3;
else if ((buf[0] & 0xF8) == 0xF0) len = 4;
else if ((buf[0] & 0xFC) == 0xF8) len = 5;
else if ((buf[0] & 0xFE) == 0xFC) len = 6;
if (len == 0)
return seterror(EILSEQ);
else if (bufsize < len)
return seterror(EINVAL);
return len;
}
static int
eucjp_mblen(csconv_t *cv, const uchar *buf, int bufsize)
{
if (buf[0] < 0x80) /* ASCII */
return 1;
else if (buf[0] == 0x8E) /* JIS X 0201 */
{
if (bufsize < 2)
return seterror(EINVAL);
else if (!(0xA1 <= buf[1] && buf[1] <= 0xDF))
return seterror(EILSEQ);
return 2;
}
else if (buf[0] == 0x8F) /* JIS X 0212 */
{
if (bufsize < 3)
return seterror(EINVAL);
else if (!(0xA1 <= buf[1] && buf[1] <= 0xFE)
|| !(0xA1 <= buf[2] && buf[2] <= 0xFE))
return seterror(EILSEQ);
return 3;
}
else /* JIS X 0208 */
{
if (bufsize < 2)
return seterror(EINVAL);
else if (!(0xA1 <= buf[0] && buf[0] <= 0xFE)
|| !(0xA1 <= buf[1] && buf[1] <= 0xFE))
return seterror(EILSEQ);
return 2;
}
}
static int
kernel_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
{
int len;
len = cv->mblen(cv, buf, bufsize);
if (len == -1)
return -1;
*wbufsize = MultiByteToWideChar(cv->codepage, mbtowc_flags (cv->codepage),
(const char *)buf, len, (wchar_t *)wbuf, *wbufsize);
if (*wbufsize == 0)
return seterror(EILSEQ);
return len;
}
static int
kernel_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
{
BOOL usedDefaultChar = 0;
BOOL *p = NULL;
int flags = 0;
int len;
if (bufsize == 0)
return seterror(E2BIG);
if (!must_use_null_useddefaultchar(cv->codepage))
{
p = &usedDefaultChar;
#ifdef WC_NO_BEST_FIT_CHARS
if (!(cv->flags & FLAG_TRANSLIT))
flags |= WC_NO_BEST_FIT_CHARS;
#endif
}
len = WideCharToMultiByte(cv->codepage, flags,
(const wchar_t *)wbuf, wbufsize, (char *)buf, bufsize, NULL, p);
if (len == 0)
{
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
return seterror(E2BIG);
return seterror(EILSEQ);
}
else if (usedDefaultChar && !(cv->flags & FLAG_TRANSLIT))
return seterror(EILSEQ);
else if (cv->mblen(cv, buf, len) != len) /* validate result */
return seterror(EILSEQ);
return len;
}
/*
* It seems that the mode (cv->mode) is fixnum.
* For example, when converting iso-2022-jp(cp50221) to unicode:
* in ascii sequence: mode=0xC42C0000
* in jisx0208 sequence: mode=0xC42C0001
* "C42C" is same for each convert session.
* It should be: ((codepage-1)<<16)|state
*/
static int
mlang_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
{
int len;
int insize;
HRESULT hr;
len = cv->mblen(cv, buf, bufsize);
if (len == -1)
return -1;
insize = len;
hr = ConvertINetMultiByteToUnicode(&cv->mode, cv->codepage,
(const char *)buf, &insize, (wchar_t *)wbuf, wbufsize);
if (hr != S_OK || insize != len)
return seterror(EILSEQ);
return len;
}
static int
mlang_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
{
char tmpbuf[MB_CHAR_MAX]; /* enough room for one character */
int tmpsize = MB_CHAR_MAX;
int insize = wbufsize;
HRESULT hr;
hr = ConvertINetUnicodeToMultiByte(&cv->mode, cv->codepage,
(const wchar_t *)wbuf, &wbufsize, tmpbuf, &tmpsize);
if (hr != S_OK || insize != wbufsize)
return seterror(EILSEQ);
else if (bufsize < tmpsize)
return seterror(E2BIG);
else if (cv->mblen(cv, (uchar *)tmpbuf, tmpsize) != tmpsize)
return seterror(EILSEQ);
memcpy(buf, tmpbuf, tmpsize);
return tmpsize;
}
static int
utf16_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
{
int codepage = cv->codepage;
/* swap endian: 1200 <-> 1201 */
if (cv->mode & UNICODE_MODE_SWAPPED)
codepage ^= 1;
if (bufsize < 2)
return seterror(EINVAL);
if (codepage == 1200) /* little endian */
wbuf[0] = (buf[1] << 8) | buf[0];
else if (codepage == 1201) /* big endian */
wbuf[0] = (buf[0] << 8) | buf[1];
if ((cv->flags & FLAG_USE_BOM) && !(cv->mode & UNICODE_MODE_BOM_DONE))
{
cv->mode |= UNICODE_MODE_BOM_DONE;
if (wbuf[0] == 0xFFFE)
{
cv->mode |= UNICODE_MODE_SWAPPED;
*wbufsize = 0;
return 2;
}
else if (wbuf[0] == 0xFEFF)
{
*wbufsize = 0;
return 2;
}
}
if (0xDC00 <= wbuf[0] && wbuf[0] <= 0xDFFF)
return seterror(EILSEQ);
if (0xD800 <= wbuf[0] && wbuf[0] <= 0xDBFF)
{
if (bufsize < 4)
return seterror(EINVAL);
if (codepage == 1200) /* little endian */
wbuf[1] = (buf[3] << 8) | buf[2];
else if (codepage == 1201) /* big endian */
wbuf[1] = (buf[2] << 8) | buf[3];
if (!(0xDC00 <= wbuf[1] && wbuf[1] <= 0xDFFF))
return seterror(EILSEQ);
*wbufsize = 2;
return 4;
}
*wbufsize = 1;
return 2;
}
static int
utf16_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
{
if ((cv->flags & FLAG_USE_BOM) && !(cv->mode & UNICODE_MODE_BOM_DONE))
{
int r;
cv->mode |= UNICODE_MODE_BOM_DONE;
if (bufsize < 2)
return seterror(E2BIG);
if (cv->codepage == 1200) /* little endian */
memcpy(buf, "\xFF\xFE", 2);
else if (cv->codepage == 1201) /* big endian */
memcpy(buf, "\xFE\xFF", 2);
r = utf16_wctomb(cv, wbuf, wbufsize, buf + 2, bufsize - 2);
if (r == -1)
return -1;
return r + 2;
}
if (bufsize < 2)
return seterror(E2BIG);
if (cv->codepage == 1200) /* little endian */
{
buf[0] = (wbuf[0] & 0x00FF);
buf[1] = (wbuf[0] & 0xFF00) >> 8;
}
else if (cv->codepage == 1201) /* big endian */
{
buf[0] = (wbuf[0] & 0xFF00) >> 8;
buf[1] = (wbuf[0] & 0x00FF);
}
if (0xD800 <= wbuf[0] && wbuf[0] <= 0xDBFF)
{
if (bufsize < 4)
return seterror(E2BIG);
if (cv->codepage == 1200) /* little endian */
{
buf[2] = (wbuf[1] & 0x00FF);
buf[3] = (wbuf[1] & 0xFF00) >> 8;
}
else if (cv->codepage == 1201) /* big endian */
{
buf[2] = (wbuf[1] & 0xFF00) >> 8;
buf[3] = (wbuf[1] & 0x00FF);
}
return 4;
}
return 2;
}
static int
utf32_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
{
int codepage = cv->codepage;
uint wc;
/* swap endian: 12000 <-> 12001 */
if (cv->mode & UNICODE_MODE_SWAPPED)
codepage ^= 1;
if (bufsize < 4)
return seterror(EINVAL);
if (codepage == 12000) /* little endian */
wc = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
else if (codepage == 12001) /* big endian */
wc = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
if ((cv->flags & FLAG_USE_BOM) && !(cv->mode & UNICODE_MODE_BOM_DONE))
{
cv->mode |= UNICODE_MODE_BOM_DONE;
if (wc == 0xFFFE0000)
{
cv->mode |= UNICODE_MODE_SWAPPED;
*wbufsize = 0;
return 4;
}
else if (wc == 0x0000FEFF)
{
*wbufsize = 0;
return 4;
}
}
if ((0xD800 <= wc && wc <= 0xDFFF) || 0x10FFFF < wc)
return seterror(EILSEQ);
ucs4_to_utf16(wc, wbuf, wbufsize);
return 4;
}
static int
utf32_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
{
uint wc;
if ((cv->flags & FLAG_USE_BOM) && !(cv->mode & UNICODE_MODE_BOM_DONE))
{
int r;
cv->mode |= UNICODE_MODE_BOM_DONE;
if (bufsize < 4)
return seterror(E2BIG);
if (cv->codepage == 12000) /* little endian */
memcpy(buf, "\xFF\xFE\x00\x00", 4);
else if (cv->codepage == 12001) /* big endian */
memcpy(buf, "\x00\x00\xFE\xFF", 4);
r = utf32_wctomb(cv, wbuf, wbufsize, buf + 4, bufsize - 4);
if (r == -1)
return -1;
return r + 4;
}
if (bufsize < 4)
return seterror(E2BIG);
wc = utf16_to_ucs4(wbuf);
if (cv->codepage == 12000) /* little endian */
{
buf[0] = wc & 0x000000FF;
buf[1] = (wc & 0x0000FF00) >> 8;
buf[2] = (wc & 0x00FF0000) >> 16;
buf[3] = (wc & 0xFF000000) >> 24;
}
else if (cv->codepage == 12001) /* big endian */
{
buf[0] = (wc & 0xFF000000) >> 24;
buf[1] = (wc & 0x00FF0000) >> 16;
buf[2] = (wc & 0x0000FF00) >> 8;
buf[3] = wc & 0x000000FF;
}
return 4;
}
/*
* 50220: ISO 2022 Japanese with no halfwidth Katakana; Japanese (JIS)
* 50221: ISO 2022 Japanese with halfwidth Katakana; Japanese (JIS-Allow
* 1 byte Kana)
* 50222: ISO 2022 Japanese JIS X 0201-1989; Japanese (JIS-Allow 1 byte
* Kana - SO/SI)
*
* MultiByteToWideChar() and WideCharToMultiByte() behave differently
* depending on Windows version. On XP, WideCharToMultiByte() doesn't
* terminate result sequence with ascii escape. But Vista does.
* Use MLang instead.
*/
#define ISO2022_MODE(cs, shift) (((cs) << 8) | (shift))
#define ISO2022_MODE_CS(mode) (((mode) >> 8) & 0xFF)
#define ISO2022_MODE_SHIFT(mode) ((mode) & 0xFF)
#define ISO2022_SI 0
#define ISO2022_SO 1
/* shift in */
static const char iso2022_SI_seq[] = "\x0F";
/* shift out */
static const char iso2022_SO_seq[] = "\x0E";
typedef struct iso2022_esc_t iso2022_esc_t;
struct iso2022_esc_t {
const char *esc;
int esc_len;
int len;
int cs;
};
#define ISO2022JP_CS_ASCII 0
#define ISO2022JP_CS_JISX0201_ROMAN 1
#define ISO2022JP_CS_JISX0201_KANA 2
#define ISO2022JP_CS_JISX0208_1978 3
#define ISO2022JP_CS_JISX0208_1983 4
#define ISO2022JP_CS_JISX0212 5
static iso2022_esc_t iso2022jp_esc[] = {
{"\x1B\x28\x42", 3, 1, ISO2022JP_CS_ASCII},
{"\x1B\x28\x4A", 3, 1, ISO2022JP_CS_JISX0201_ROMAN},
{"\x1B\x28\x49", 3, 1, ISO2022JP_CS_JISX0201_KANA},
{"\x1B\x24\x40", 3, 2, ISO2022JP_CS_JISX0208_1983}, /* unify 1978 with 1983 */
{"\x1B\x24\x42", 3, 2, ISO2022JP_CS_JISX0208_1983},
{"\x1B\x24\x28\x44", 4, 2, ISO2022JP_CS_JISX0212},
{NULL, 0, 0, 0}
};
static int
iso2022jp_mbtowc(csconv_t *cv, const uchar *buf, int bufsize, ushort *wbuf, int *wbufsize)
{
iso2022_esc_t *iesc = iso2022jp_esc;
char tmp[MB_CHAR_MAX];
int insize;
HRESULT hr;
DWORD dummy = 0;
int len;
int esc_len;
int cs;
int shift;
int i;
if (buf[0] == 0x1B)
{
for (i = 0; iesc[i].esc != NULL; ++i)
{
esc_len = iesc[i].esc_len;
if (bufsize < esc_len)
{
if (strncmp((char *)buf, iesc[i].esc, bufsize) == 0)
return seterror(EINVAL);
}
else
{
if (strncmp((char *)buf, iesc[i].esc, esc_len) == 0)
{
cv->mode = ISO2022_MODE(iesc[i].cs, ISO2022_SI);
*wbufsize = 0;
return esc_len;
}
}
}
/* not supported escape sequence */
return seterror(EILSEQ);
}
else if (buf[0] == iso2022_SO_seq[0])
{
cv->mode = ISO2022_MODE(ISO2022_MODE_CS(cv->mode), ISO2022_SO);
*wbufsize = 0;
return 1;
}
else if (buf[0] == iso2022_SI_seq[0])
{
cv->mode = ISO2022_MODE(ISO2022_MODE_CS(cv->mode), ISO2022_SI);
*wbufsize = 0;
return 1;
}
cs = ISO2022_MODE_CS(cv->mode);
shift = ISO2022_MODE_SHIFT(cv->mode);
/* reset the mode for informal sequence */
if (buf[0] < 0x20)
{
cs = ISO2022JP_CS_ASCII;
shift = ISO2022_SI;
}
len = iesc[cs].len;
if (bufsize < len)
return seterror(EINVAL);
for (i = 0; i < len; ++i)
if (!(buf[i] < 0x80))
return seterror(EILSEQ);
esc_len = iesc[cs].esc_len;
memcpy(tmp, iesc[cs].esc, esc_len);
if (shift == ISO2022_SO)
{
memcpy(tmp + esc_len, iso2022_SO_seq, 1);
esc_len += 1;
}
memcpy(tmp + esc_len, buf, len);
if ((cv->codepage == 50220 || cv->codepage == 50221
|| cv->codepage == 50222) && shift == ISO2022_SO)
{
/* XXX: shift-out cannot be used for mbtowc (both kernel and
* mlang) */
esc_len = iesc[ISO2022JP_CS_JISX0201_KANA].esc_len;
memcpy(tmp, iesc[ISO2022JP_CS_JISX0201_KANA].esc, esc_len);
memcpy(tmp + esc_len, buf, len);
}
insize = len + esc_len;
hr = ConvertINetMultiByteToUnicode(&dummy, cv->codepage,
(const char *)tmp, &insize, (wchar_t *)wbuf, wbufsize);
if (hr != S_OK || insize != len + esc_len)
return seterror(EILSEQ);
/* Check for conversion error. Assuming defaultChar is 0x3F. */
/* ascii should be converted from ascii */
if (wbuf[0] == buf[0]
&& cv->mode != ISO2022_MODE(ISO2022JP_CS_ASCII, ISO2022_SI))
return seterror(EILSEQ);
/* reset the mode for informal sequence */
if (cv->mode != ISO2022_MODE(cs, shift))
cv->mode = ISO2022_MODE(cs, shift);
return len;
}
static int
iso2022jp_wctomb(csconv_t *cv, ushort *wbuf, int wbufsize, uchar *buf, int bufsize)
{
iso2022_esc_t *iesc = iso2022jp_esc;
char tmp[MB_CHAR_MAX];
int tmpsize = MB_CHAR_MAX;
int insize = wbufsize;
HRESULT hr;
DWORD dummy = 0;
int len;
int esc_len;
int cs;
int shift;
int i;
/*
* MultiByte = [escape sequence] + character + [escape sequence]
*
* Whether trailing escape sequence is added depends on which API is
* used (kernel or MLang, and its version).
*/
hr = ConvertINetUnicodeToMultiByte(&dummy, cv->codepage,
(const wchar_t *)wbuf, &wbufsize, tmp, &tmpsize);
if (hr != S_OK || insize != wbufsize)
return seterror(EILSEQ);
else if (bufsize < tmpsize)
return seterror(E2BIG);
if (tmpsize == 1)
{
cs = ISO2022JP_CS_ASCII;
esc_len = 0;
}
else
{
for (i = 1; iesc[i].esc != NULL; ++i)
{
esc_len = iesc[i].esc_len;
if (strncmp(tmp, iesc[i].esc, esc_len) == 0)
{
cs = iesc[i].cs;
break;
}
}
if (iesc[i].esc == NULL)
/* not supported escape sequence */
return seterror(EILSEQ);
}
shift = ISO2022_SI;
if (tmp[esc_len] == iso2022_SO_seq[0])
{
shift = ISO2022_SO;
esc_len += 1;
}
len = iesc[cs].len;
/* Check for converting error. Assuming defaultChar is 0x3F. */
/* ascii should be converted from ascii */
if (cs == ISO2022JP_CS_ASCII && !(wbuf[0] < 0x80))
return seterror(EILSEQ);
else if (tmpsize < esc_len + len)
return seterror(EILSEQ);
if (cv->mode == ISO2022_MODE(cs, shift))
{
/* remove escape sequence */
if (esc_len != 0)
memmove(tmp, tmp + esc_len, len);
esc_len = 0;
}
else
{
if (cs == ISO2022JP_CS_ASCII)
{
esc_len = iesc[ISO2022JP_CS_ASCII].esc_len;
memmove(tmp + esc_len, tmp, len);
memcpy(tmp, iesc[ISO2022JP_CS_ASCII].esc, esc_len);
}
if (ISO2022_MODE_SHIFT(cv->mode) == ISO2022_SO)
{
/* shift-in before changing to other mode */
memmove(tmp + 1, tmp, len + esc_len);
memcpy(tmp, iso2022_SI_seq, 1);
esc_len += 1;
}
}
if (bufsize < len + esc_len)
return seterror(E2BIG);
memcpy(buf, tmp, len + esc_len);
cv->mode = ISO2022_MODE(cs, shift);
return len + esc_len;
}
static int
iso2022jp_flush(csconv_t *cv, uchar *buf, int bufsize)
{
iso2022_esc_t *iesc = iso2022jp_esc;
int esc_len;
if (cv->mode != ISO2022_MODE(ISO2022JP_CS_ASCII, ISO2022_SI))
{
esc_len = 0;
if (ISO2022_MODE_SHIFT(cv->mode) != ISO2022_SI)
esc_len += 1;
if (ISO2022_MODE_CS(cv->mode) != ISO2022JP_CS_ASCII)
esc_len += iesc[ISO2022JP_CS_ASCII].esc_len;
if (bufsize < esc_len)
return seterror(E2BIG);
esc_len = 0;
if (ISO2022_MODE_SHIFT(cv->mode) != ISO2022_SI)
{
memcpy(buf, iso2022_SI_seq, 1);
esc_len += 1;
}
if (ISO2022_MODE_CS(cv->mode) != ISO2022JP_CS_ASCII)
{
memcpy(buf + esc_len, iesc[ISO2022JP_CS_ASCII].esc,
iesc[ISO2022JP_CS_ASCII].esc_len);
esc_len += iesc[ISO2022JP_CS_ASCII].esc_len;
}
return esc_len;
}
return 0;
}
#if defined(MAKE_DLL) && defined(USE_LIBICONV_DLL)
BOOL WINAPI
DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)
{
switch( fdwReason )
{
case DLL_PROCESS_ATTACH:
hwiniconv = (HMODULE)hinstDLL;
break;
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
#endif
#if defined(MAKE_EXE)
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
int
main(int argc, char **argv)
{
char *fromcode = NULL;
char *tocode = NULL;
int i;
char inbuf[BUFSIZ];
char outbuf[BUFSIZ];
char *pin;
char *pout;
size_t inbytesleft;
size_t outbytesleft;
size_t rest = 0;
iconv_t cd;
size_t r;
FILE *in = stdin;
int ignore = 0;
char *p;
_setmode(_fileno(stdin), _O_BINARY);
_setmode(_fileno(stdout), _O_BINARY);
for (i = 1; i < argc; ++i)
{
if (strcmp(argv[i], "-l") == 0)
{
for (i = 0; codepage_alias[i].name != NULL; ++i)
printf("%s\n", codepage_alias[i].name);
return 0;
}
if (strcmp(argv[i], "-f") == 0)
fromcode = argv[++i];
else if (strcmp(argv[i], "-t") == 0)
tocode = argv[++i];
else if (strcmp(argv[i], "-c") == 0)
ignore = 1;
else
{
in = fopen(argv[i], "rb");
if (in == NULL)
{
fprintf(stderr, "cannot open %s\n", argv[i]);
return 1;
}
break;
}
}
if (fromcode == NULL || tocode == NULL)
{
printf("usage: %s [-c] -f from-enc -t to-enc [file]\n", argv[0]);
return 0;
}
if (ignore)
{
p = tocode;
tocode = (char *)malloc(strlen(p) + strlen("//IGNORE") + 1);
if (tocode == NULL)
{
perror("fatal error");
return 1;
}
strcpy(tocode, p);
strcat(tocode, "//IGNORE");
}
cd = iconv_open(tocode, fromcode);
if (cd == (iconv_t)(-1))
{
perror("iconv_open error");
return 1;
}
while ((inbytesleft = fread(inbuf + rest, 1, sizeof(inbuf) - rest, in)) != 0
|| rest != 0)
{
inbytesleft += rest;
pin = inbuf;
pout = outbuf;
outbytesleft = sizeof(outbuf);
r = iconv(cd, &pin, &inbytesleft, &pout, &outbytesleft);
fwrite(outbuf, 1, sizeof(outbuf) - outbytesleft, stdout);
if (r == (size_t)(-1) && errno != E2BIG && (errno != EINVAL || feof(in)))
{
perror("conversion error");
return 1;
}
memmove(inbuf, pin, inbytesleft);
rest = inbytesleft;
}
pout = outbuf;
outbytesleft = sizeof(outbuf);
r = iconv(cd, NULL, NULL, &pout, &outbytesleft);
fwrite(outbuf, 1, sizeof(outbuf) - outbytesleft, stdout);
if (r == (size_t)(-1))
{
perror("conversion error");
return 1;
}
iconv_close(cd);
return 0;
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/win32/zxing/win_iconv.c
|
c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 20,040
|
```hack
#ifndef NUMBERLIKEARRAY_H
#define NUMBERLIKEARRAY_H
// Make sure we have NULL.
#ifndef NULL
#define NULL 0
#endif
/* A NumberlikeArray<Blk> object holds a heap-allocated array of Blk with a
* length and a capacity and provides basic memory management features.
* BigUnsigned and BigUnsignedInABase both subclass it.
*
* NumberlikeArray provides no information hiding. Subclasses should use
* nonpublic inheritance and manually expose members as desired using
* declarations like this:
*
* public:
* NumberlikeArray< the-type-argument >::getLength;
*/
template <class Blk>
class NumberlikeArray {
public:
// Type for the index of a block in the array
typedef unsigned int Index;
// The number of bits in a block, defined below.
static const unsigned int N;
// The current allocated capacity of this NumberlikeArray (in blocks)
Index cap;
// The actual length of the value stored in this NumberlikeArray (in blocks)
Index len;
// Heap-allocated array of the blocks (can be NULL if len == 0)
Blk *blk;
// Constructs a ``zero'' NumberlikeArray with the given capacity.
NumberlikeArray(Index c) : cap(c), len(0) {
blk = (cap > 0) ? (new Blk[cap]) : NULL;
}
/* Constructs a zero NumberlikeArray without allocating a backing array.
* A subclass that doesn't know the needed capacity at initialization
* time can use this constructor and then overwrite blk without first
* deleting it. */
NumberlikeArray() : cap(0), len(0) {
blk = NULL;
}
// Destructor. Note that `delete NULL' is a no-op.
~NumberlikeArray() {
delete [] blk;
}
/* Ensures that the array has at least the requested capacity; may
* destroy the contents. */
void allocate(Index c);
/* Ensures that the array has at least the requested capacity; does not
* destroy the contents. */
void allocateAndCopy(Index c);
// Copy constructor
NumberlikeArray(const NumberlikeArray<Blk> &x);
// Assignment operator
void operator=(const NumberlikeArray<Blk> &x);
// Constructor that copies from a given array of blocks
NumberlikeArray(const Blk *b, Index blen);
// ACCESSORS
Index getCapacity() const { return cap; }
Index getLength() const { return len; }
Blk getBlock(Index i) const { return blk[i]; }
bool isEmpty() const { return len == 0; }
/* Equality comparison: checks if both objects have the same length and
* equal (==) array elements to that length. Subclasses may wish to
* override. */
bool operator ==(const NumberlikeArray<Blk> &x) const;
bool operator !=(const NumberlikeArray<Blk> &x) const {
return !operator ==(x);
}
};
/* BEGIN TEMPLATE DEFINITIONS. They are present here so that source files that
* include this header file can generate the necessary real definitions. */
template <class Blk>
const unsigned int NumberlikeArray<Blk>::N = 8 * sizeof(Blk);
template <class Blk>
void NumberlikeArray<Blk>::allocate(Index c) {
// If the requested capacity is more than the current capacity...
if (c > cap) {
// Delete the old number array
delete [] blk;
// Allocate the new array
cap = c;
blk = new Blk[cap];
}
}
template <class Blk>
void NumberlikeArray<Blk>::allocateAndCopy(Index c) {
// If the requested capacity is more than the current capacity...
if (c > cap) {
Blk *oldBlk = blk;
// Allocate the new number array
cap = c;
blk = new Blk[cap];
// Copy number blocks
Index i;
for (i = 0; i < len; i++)
blk[i] = oldBlk[i];
// Delete the old array
delete [] oldBlk;
}
}
template <class Blk>
NumberlikeArray<Blk>::NumberlikeArray(const NumberlikeArray<Blk> &x)
: len(x.len) {
// Create array
cap = len;
blk = new Blk[cap];
// Copy blocks
Index i;
for (i = 0; i < len; i++)
blk[i] = x.blk[i];
}
template <class Blk>
void NumberlikeArray<Blk>::operator=(const NumberlikeArray<Blk> &x) {
/* Calls like a = a have no effect; catch them before the aliasing
* causes a problem */
if (this == &x)
return;
// Copy length
len = x.len;
// Expand array if necessary
allocate(len);
// Copy number blocks
Index i;
for (i = 0; i < len; i++)
blk[i] = x.blk[i];
}
template <class Blk>
NumberlikeArray<Blk>::NumberlikeArray(const Blk *b, Index blen)
: cap(blen), len(blen) {
// Create array
blk = new Blk[cap];
// Copy blocks
Index i;
for (i = 0; i < len; i++)
blk[i] = b[i];
}
template <class Blk>
bool NumberlikeArray<Blk>::operator ==(const NumberlikeArray<Blk> &x) const {
if (len != x.len)
// Definitely unequal.
return false;
else {
// Compare corresponding blocks one by one.
Index i;
for (i = 0; i < len; i++)
if (blk[i] != x.blk[i])
return false;
// No blocks differed, so the objects are equal.
return true;
}
}
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/bigint/NumberlikeArray.hh
|
hack
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 1,342
|
```c++
#include "BigIntegerAlgorithms.hh"
BigUnsigned gcd(BigUnsigned a, BigUnsigned b) {
BigUnsigned trash;
// Neat in-place alternating technique.
for (;;) {
if (b.isZero())
return a;
a.divideWithRemainder(b, trash);
if (a.isZero())
return b;
b.divideWithRemainder(a, trash);
}
}
void extendedEuclidean(BigInteger m, BigInteger n,
BigInteger &g, BigInteger &r, BigInteger &s) {
if (&g == &r || &g == &s || &r == &s)
throw "BigInteger extendedEuclidean: Outputs are aliased";
BigInteger r1(1), s1(0), r2(0), s2(1), q;
/* Invariants:
* r1*m(orig) + s1*n(orig) == m(current)
* r2*m(orig) + s2*n(orig) == n(current) */
for (;;) {
if (n.isZero()) {
r = r1; s = s1; g = m;
return;
}
// Subtract q times the second invariant from the first invariant.
m.divideWithRemainder(n, q);
r1 -= q*r2; s1 -= q*s2;
if (m.isZero()) {
r = r2; s = s2; g = n;
return;
}
// Subtract q times the first invariant from the second invariant.
n.divideWithRemainder(m, q);
r2 -= q*r1; s2 -= q*s1;
}
}
BigUnsigned modinv(const BigInteger &x, const BigUnsigned &n) {
BigInteger g, r, s;
extendedEuclidean(x, n, g, r, s);
if (g == 1)
// r*x + s*n == 1, so r*x === 1 (mod n), so r is the answer.
return (r % n).getMagnitude(); // (r % n) will be nonnegative
else
throw "BigInteger modinv: x and n have a common factor";
}
BigUnsigned modexp(const BigInteger &base, const BigUnsigned &exponent,
const BigUnsigned &modulus) {
BigUnsigned ans = 1, base2 = (base % modulus).getMagnitude();
BigUnsigned::Index i = exponent.bitLength();
// For each bit of the exponent, most to least significant...
while (i > 0) {
i--;
// Square.
ans *= ans;
ans %= modulus;
// And multiply if the bit is a 1.
if (exponent.getBit(i)) {
ans *= base2;
ans %= modulus;
}
}
return ans;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/bigint/BigIntegerAlgorithms.cc
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 600
|
```c++
#include "BigUnsignedInABase.hh"
BigUnsignedInABase::BigUnsignedInABase(const Digit *d, Index l, Base base)
: NumberlikeArray<Digit>(d, l), base(base) {
// Check the base
if (base < 2)
throw "BigUnsignedInABase::BigUnsignedInABase(const Digit *, Index, Base): The base must be at least 2";
// Validate the digits.
for (Index i = 0; i < l; i++)
if (blk[i] >= base)
throw "BigUnsignedInABase::BigUnsignedInABase(const Digit *, Index, Base): A digit is too large for the specified base";
// Eliminate any leading zeros we may have been passed.
zapLeadingZeros();
}
namespace {
unsigned int bitLen(unsigned int x) {
unsigned int len = 0;
while (x > 0) {
x >>= 1;
len++;
}
return len;
}
unsigned int ceilingDiv(unsigned int a, unsigned int b) {
return (a + b - 1) / b;
}
}
BigUnsignedInABase::BigUnsignedInABase(const BigUnsigned &x, Base base) {
// Check the base
if (base < 2)
throw "BigUnsignedInABase(BigUnsigned, Base): The base must be at least 2";
this->base = base;
// Get an upper bound on how much space we need
int maxBitLenOfX = x.getLength() * BigUnsigned::N;
int minBitsPerDigit = bitLen(base) - 1;
int maxDigitLenOfX = ceilingDiv(maxBitLenOfX, minBitsPerDigit);
len = maxDigitLenOfX; // Another change to comply with `staying in bounds'.
allocate(len); // Get the space
BigUnsigned x2(x), buBase(base);
Index digitNum = 0;
while (!x2.isZero()) {
// Get last digit. This is like `lastDigit = x2 % buBase, x2 /= buBase'.
BigUnsigned lastDigit(x2);
lastDigit.divideWithRemainder(buBase, x2);
// Save the digit.
blk[digitNum] = lastDigit.toUnsignedShort();
// Move on. We can't run out of room: we figured it out above.
digitNum++;
}
// Save the actual length.
len = digitNum;
}
BigUnsignedInABase::operator BigUnsigned() const {
BigUnsigned ans(0), buBase(base), temp;
Index digitNum = len;
while (digitNum > 0) {
digitNum--;
temp.multiply(ans, buBase);
ans.add(temp, BigUnsigned(blk[digitNum]));
}
return ans;
}
BigUnsignedInABase::BigUnsignedInABase(const std::string &s, Base base) {
// Check the base.
if (base > 36)
throw "BigUnsignedInABase(std::string, Base): The default string conversion routines use the symbol set 0-9, A-Z and therefore support only up to base 36. You tried a conversion with a base over 36; write your own string conversion routine.";
// Save the base.
// This pattern is seldom seen in C++, but the analogous ``this.'' is common in Java.
this->base = base;
// `s.length()' is a `size_t', while `len' is a `NumberlikeArray::Index',
// also known as an `unsigned int'. Some compilers warn without this cast.
len = Index(s.length());
allocate(len);
Index digitNum, symbolNumInString;
for (digitNum = 0; digitNum < len; digitNum++) {
symbolNumInString = len - 1 - digitNum;
char theSymbol = s[symbolNumInString];
if (theSymbol >= '0' && theSymbol <= '9')
blk[digitNum] = theSymbol - '0';
else if (theSymbol >= 'A' && theSymbol <= 'Z')
blk[digitNum] = theSymbol - 'A' + 10;
else if (theSymbol >= 'a' && theSymbol <= 'z')
blk[digitNum] = theSymbol - 'a' + 10;
else
throw "BigUnsignedInABase(std::string, Base): Bad symbol in input. Only 0-9, A-Z, a-z are accepted.";
if (blk[digitNum] >= base)
throw "BigUnsignedInABase::BigUnsignedInABase(const Digit *, Index, Base): A digit is too large for the specified base";
}
zapLeadingZeros();
}
BigUnsignedInABase::operator std::string() const {
if (base > 36)
throw "BigUnsignedInABase ==> std::string: The default string conversion routines use the symbol set 0-9, A-Z and therefore support only up to base 36. You tried a conversion with a base over 36; write your own string conversion routine.";
if (len == 0)
return std::string("0");
// Some compilers don't have push_back, so use a char * buffer instead.
char *s = new char[len + 1];
s[len] = '\0';
Index digitNum, symbolNumInString;
for (symbolNumInString = 0; symbolNumInString < len; symbolNumInString++) {
digitNum = len - 1 - symbolNumInString;
Digit theDigit = blk[digitNum];
if (theDigit < 10)
s[symbolNumInString] = char('0' + theDigit);
else
s[symbolNumInString] = char('A' + theDigit - 10);
}
std::string s2(s);
delete [] s;
return s2;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/bigint/BigUnsignedInABase.cc
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 1,291
|
```c++
#include "BigUnsigned.hh"
// Memory management definitions have moved to the bottom of NumberlikeArray.hh.
// The templates used by these constructors and converters are at the bottom of
// BigUnsigned.hh.
BigUnsigned::BigUnsigned(unsigned long x) { initFromPrimitive (x); }
BigUnsigned::BigUnsigned(unsigned int x) { initFromPrimitive (x); }
BigUnsigned::BigUnsigned(unsigned short x) { initFromPrimitive (x); }
BigUnsigned::BigUnsigned( long x) { initFromSignedPrimitive(x); }
BigUnsigned::BigUnsigned( int x) { initFromSignedPrimitive(x); }
BigUnsigned::BigUnsigned( short x) { initFromSignedPrimitive(x); }
unsigned long BigUnsigned::toUnsignedLong () const { return convertToPrimitive <unsigned long >(); }
unsigned int BigUnsigned::toUnsignedInt () const { return convertToPrimitive <unsigned int >(); }
unsigned short BigUnsigned::toUnsignedShort() const { return convertToPrimitive <unsigned short>(); }
long BigUnsigned::toLong () const { return convertToSignedPrimitive< long >(); }
int BigUnsigned::toInt () const { return convertToSignedPrimitive< int >(); }
short BigUnsigned::toShort () const { return convertToSignedPrimitive< short>(); }
// BIT/BLOCK ACCESSORS
void BigUnsigned::setBlock(Index i, Blk newBlock) {
if (newBlock == 0) {
if (i < len) {
blk[i] = 0;
zapLeadingZeros();
}
// If i >= len, no effect.
} else {
if (i >= len) {
// The nonzero block extends the number.
allocateAndCopy(i+1);
// Zero any added blocks that we aren't setting.
for (Index j = len; j < i; j++)
blk[j] = 0;
len = i+1;
}
blk[i] = newBlock;
}
}
/* Evidently the compiler wants BigUnsigned:: on the return type because, at
* that point, it hasn't yet parsed the BigUnsigned:: on the name to get the
* proper scope. */
BigUnsigned::Index BigUnsigned::bitLength() const {
if (isZero())
return 0;
else {
Blk leftmostBlock = getBlock(len - 1);
Index leftmostBlockLen = 0;
while (leftmostBlock != 0) {
leftmostBlock >>= 1;
leftmostBlockLen++;
}
return leftmostBlockLen + (len - 1) * N;
}
}
void BigUnsigned::setBit(Index bi, bool newBit) {
Index blockI = bi / N;
Blk block = getBlock(blockI), mask = Blk(1) << (bi % N);
block = newBit ? (block | mask) : (block & ~mask);
setBlock(blockI, block);
}
// COMPARISON
BigUnsigned::CmpRes BigUnsigned::compareTo(const BigUnsigned &x) const {
// A bigger length implies a bigger number.
if (len < x.len)
return less;
else if (len > x.len)
return greater;
else {
// Compare blocks one by one from left to right.
Index i = len;
while (i > 0) {
i--;
if (blk[i] == x.blk[i])
continue;
else if (blk[i] > x.blk[i])
return greater;
else
return less;
}
// If no blocks differed, the numbers are equal.
return equal;
}
}
// COPY-LESS OPERATIONS
/*
* On most calls to copy-less operations, it's safe to read the inputs little by
* little and write the outputs little by little. However, if one of the
* inputs is coming from the same variable into which the output is to be
* stored (an "aliased" call), we risk overwriting the input before we read it.
* In this case, we first compute the result into a temporary BigUnsigned
* variable and then copy it into the requested output variable *this.
* Each put-here operation uses the DTRT_ALIASED macro (Do The Right Thing on
* aliased calls) to generate code for this check.
*
* I adopted this approach on 2007.02.13 (see Assignment Operators in
* BigUnsigned.hh). Before then, put-here operations rejected aliased calls
* with an exception. I think doing the right thing is better.
*
* Some of the put-here operations can probably handle aliased calls safely
* without the extra copy because (for example) they process blocks strictly
* right-to-left. At some point I might determine which ones don't need the
* copy, but my reasoning would need to be verified very carefully. For now
* I'll leave in the copy.
*/
#define DTRT_ALIASED(cond, op) \
if (cond) { \
BigUnsigned tmpThis; \
tmpThis.op; \
*this = tmpThis; \
return; \
}
void BigUnsigned::add(const BigUnsigned &a, const BigUnsigned &b) {
DTRT_ALIASED(this == &a || this == &b, add(a, b));
// If one argument is zero, copy the other.
if (a.len == 0) {
operator =(b);
return;
} else if (b.len == 0) {
operator =(a);
return;
}
// Some variables...
// Carries in and out of an addition stage
bool carryIn, carryOut;
Blk temp;
Index i;
// a2 points to the longer input, b2 points to the shorter
const BigUnsigned *a2, *b2;
if (a.len >= b.len) {
a2 = &a;
b2 = &b;
} else {
a2 = &b;
b2 = &a;
}
// Set prelimiary length and make room in this BigUnsigned
len = a2->len + 1;
allocate(len);
// For each block index that is present in both inputs...
for (i = 0, carryIn = false; i < b2->len; i++) {
// Add input blocks
temp = a2->blk[i] + b2->blk[i];
// If a rollover occurred, the result is less than either input.
// This test is used many times in the BigUnsigned code.
carryOut = (temp < a2->blk[i]);
// If a carry was input, handle it
if (carryIn) {
temp++;
carryOut |= (temp == 0);
}
blk[i] = temp; // Save the addition result
carryIn = carryOut; // Pass the carry along
}
// If there is a carry left over, increase blocks until
// one does not roll over.
for (; i < a2->len && carryIn; i++) {
temp = a2->blk[i] + 1;
carryIn = (temp == 0);
blk[i] = temp;
}
// If the carry was resolved but the larger number
// still has blocks, copy them over.
for (; i < a2->len; i++)
blk[i] = a2->blk[i];
// Set the extra block if there's still a carry, decrease length otherwise
if (carryIn)
blk[i] = 1;
else
len--;
}
void BigUnsigned::subtract(const BigUnsigned &a, const BigUnsigned &b) {
DTRT_ALIASED(this == &a || this == &b, subtract(a, b));
if (b.len == 0) {
// If b is zero, copy a.
operator =(a);
return;
} else if (a.len < b.len)
// If a is shorter than b, the result is negative.
throw "BigUnsigned::subtract: "
"Negative result in unsigned calculation";
// Some variables...
bool borrowIn, borrowOut;
Blk temp;
Index i;
// Set preliminary length and make room
len = a.len;
allocate(len);
// For each block index that is present in both inputs...
for (i = 0, borrowIn = false; i < b.len; i++) {
temp = a.blk[i] - b.blk[i];
// If a reverse rollover occurred,
// the result is greater than the block from a.
borrowOut = (temp > a.blk[i]);
// Handle an incoming borrow
if (borrowIn) {
borrowOut |= (temp == 0);
temp--;
}
blk[i] = temp; // Save the subtraction result
borrowIn = borrowOut; // Pass the borrow along
}
// If there is a borrow left over, decrease blocks until
// one does not reverse rollover.
for (; i < a.len && borrowIn; i++) {
borrowIn = (a.blk[i] == 0);
blk[i] = a.blk[i] - 1;
}
/* If there's still a borrow, the result is negative.
* Throw an exception, but zero out this object so as to leave it in a
* predictable state. */
if (borrowIn) {
len = 0;
throw "BigUnsigned::subtract: Negative result in unsigned calculation";
} else
// Copy over the rest of the blocks
for (; i < a.len; i++)
blk[i] = a.blk[i];
// Zap leading zeros
zapLeadingZeros();
}
/*
* About the multiplication and division algorithms:
*
* I searched unsucessfully for fast C++ built-in operations like the `b_0'
* and `c_0' Knuth describes in Section 4.3.1 of ``The Art of Computer
* Programming'' (replace `place' by `Blk'):
*
* ``b_0[:] multiplication of a one-place integer by another one-place
* integer, giving a two-place answer;
*
* ``c_0[:] division of a two-place integer by a one-place integer,
* provided that the quotient is a one-place integer, and yielding
* also a one-place remainder.''
*
* I also missed his note that ``[b]y adjusting the word size, if
* necessary, nearly all computers will have these three operations
* available'', so I gave up on trying to use algorithms similar to his.
* A future version of the library might include such algorithms; I
* would welcome contributions from others for this.
*
* I eventually decided to use bit-shifting algorithms. To multiply `a'
* and `b', we zero out the result. Then, for each `1' bit in `a', we
* shift `b' left the appropriate amount and add it to the result.
* Similarly, to divide `a' by `b', we shift `b' left varying amounts,
* repeatedly trying to subtract it from `a'. When we succeed, we note
* the fact by setting a bit in the quotient. While these algorithms
* have the same O(n^2) time complexity as Knuth's, the ``constant factor''
* is likely to be larger.
*
* Because I used these algorithms, which require single-block addition
* and subtraction rather than single-block multiplication and division,
* the innermost loops of all four routines are very similar. Study one
* of them and all will become clear.
*/
/*
* This is a little inline function used by both the multiplication
* routine and the division routine.
*
* `getShiftedBlock' returns the `x'th block of `num << y'.
* `y' may be anything from 0 to N - 1, and `x' may be anything from
* 0 to `num.len'.
*
* Two things contribute to this block:
*
* (1) The `N - y' low bits of `num.blk[x]', shifted `y' bits left.
*
* (2) The `y' high bits of `num.blk[x-1]', shifted `N - y' bits right.
*
* But we must be careful if `x == 0' or `x == num.len', in
* which case we should use 0 instead of (2) or (1), respectively.
*
* If `y == 0', then (2) contributes 0, as it should. However,
* in some computer environments, for a reason I cannot understand,
* `a >> b' means `a >> (b % N)'. This means `num.blk[x-1] >> (N - y)'
* will return `num.blk[x-1]' instead of the desired 0 when `y == 0';
* the test `y == 0' handles this case specially.
*/
inline BigUnsigned::Blk getShiftedBlock(const BigUnsigned &num,
BigUnsigned::Index x, unsigned int y) {
BigUnsigned::Blk part1 = (x == 0 || y == 0) ? 0 : (num.blk[x - 1] >> (BigUnsigned::N - y));
BigUnsigned::Blk part2 = (x == num.len) ? 0 : (num.blk[x] << y);
return part1 | part2;
}
void BigUnsigned::multiply(const BigUnsigned &a, const BigUnsigned &b) {
DTRT_ALIASED(this == &a || this == &b, multiply(a, b));
// If either a or b is zero, set to zero.
if (a.len == 0 || b.len == 0) {
len = 0;
return;
}
/*
* Overall method:
*
* Set this = 0.
* For each 1-bit of `a' (say the `i2'th bit of block `i'):
* Add `b << (i blocks and i2 bits)' to *this.
*/
// Variables for the calculation
Index i, j, k;
unsigned int i2;
Blk temp;
bool carryIn, carryOut;
// Set preliminary length and make room
len = a.len + b.len;
allocate(len);
// Zero out this object
for (i = 0; i < len; i++)
blk[i] = 0;
// For each block of the first number...
for (i = 0; i < a.len; i++) {
// For each 1-bit of that block...
for (i2 = 0; i2 < N; i2++) {
if ((a.blk[i] & (Blk(1) << i2)) == 0)
continue;
/*
* Add b to this, shifted left i blocks and i2 bits.
* j is the index in b, and k = i + j is the index in this.
*
* `getShiftedBlock', a short inline function defined above,
* is now used for the bit handling. It replaces the more
* complex `bHigh' code, in which each run of the loop dealt
* immediately with the low bits and saved the high bits to
* be picked up next time. The last run of the loop used to
* leave leftover high bits, which were handled separately.
* Instead, this loop runs an additional time with j == b.len.
* These changes were made on 2005.01.11.
*/
for (j = 0, k = i, carryIn = false; j <= b.len; j++, k++) {
/*
* The body of this loop is very similar to the body of the first loop
* in `add', except that this loop does a `+=' instead of a `+'.
*/
temp = blk[k] + getShiftedBlock(b, j, i2);
carryOut = (temp < blk[k]);
if (carryIn) {
temp++;
carryOut |= (temp == 0);
}
blk[k] = temp;
carryIn = carryOut;
}
// No more extra iteration to deal with `bHigh'.
// Roll-over a carry as necessary.
for (; carryIn; k++) {
blk[k]++;
carryIn = (blk[k] == 0);
}
}
}
// Zap possible leading zero
if (blk[len - 1] == 0)
len--;
}
/*
* DIVISION WITH REMAINDER
* This monstrous function mods *this by the given divisor b while storing the
* quotient in the given object q; at the end, *this contains the remainder.
* The seemingly bizarre pattern of inputs and outputs was chosen so that the
* function copies as little as possible (since it is implemented by repeated
* subtraction of multiples of b from *this).
*
* "modWithQuotient" might be a better name for this function, but I would
* rather not change the name now.
*/
void BigUnsigned::divideWithRemainder(const BigUnsigned &b, BigUnsigned &q) {
/* Defending against aliased calls is more complex than usual because we
* are writing to both *this and q.
*
* It would be silly to try to write quotient and remainder to the
* same variable. Rule that out right away. */
if (this == &q)
throw "BigUnsigned::divideWithRemainder: Cannot write quotient and remainder into the same variable";
/* Now *this and q are separate, so the only concern is that b might be
* aliased to one of them. If so, use a temporary copy of b. */
if (this == &b || &q == &b) {
BigUnsigned tmpB(b);
divideWithRemainder(tmpB, q);
return;
}
/*
* Knuth's definition of mod (which this function uses) is somewhat
* different from the C++ definition of % in case of division by 0.
*
* We let a / 0 == 0 (it doesn't matter much) and a % 0 == a, no
* exceptions thrown. This allows us to preserve both Knuth's demand
* that a mod 0 == a and the useful property that
* (a / b) * b + (a % b) == a.
*/
if (b.len == 0) {
q.len = 0;
return;
}
/*
* If *this.len < b.len, then *this < b, and we can be sure that b doesn't go into
* *this at all. The quotient is 0 and *this is already the remainder (so leave it alone).
*/
if (len < b.len) {
q.len = 0;
return;
}
// At this point we know (*this).len >= b.len > 0. (Whew!)
/*
* Overall method:
*
* For each appropriate i and i2, decreasing:
* Subtract (b << (i blocks and i2 bits)) from *this, storing the
* result in subtractBuf.
* If the subtraction succeeds with a nonnegative result:
* Turn on bit i2 of block i of the quotient q.
* Copy subtractBuf back into *this.
* Otherwise bit i2 of block i remains off, and *this is unchanged.
*
* Eventually q will contain the entire quotient, and *this will
* be left with the remainder.
*
* subtractBuf[x] corresponds to blk[x], not blk[x+i], since 2005.01.11.
* But on a single iteration, we don't touch the i lowest blocks of blk
* (and don't use those of subtractBuf) because these blocks are
* unaffected by the subtraction: we are subtracting
* (b << (i blocks and i2 bits)), which ends in at least `i' zero
* blocks. */
// Variables for the calculation
Index i, j, k;
unsigned int i2;
Blk temp;
bool borrowIn, borrowOut;
/*
* Make sure we have an extra zero block just past the value.
*
* When we attempt a subtraction, we might shift `b' so
* its first block begins a few bits left of the dividend,
* and then we'll try to compare these extra bits with
* a nonexistent block to the left of the dividend. The
* extra zero block ensures sensible behavior; we need
* an extra block in `subtractBuf' for exactly the same reason.
*/
Index origLen = len; // Save real length.
/* To avoid an out-of-bounds access in case of reallocation, allocate
* first and then increment the logical length. */
allocateAndCopy(len + 1);
len++;
blk[origLen] = 0; // Zero the added block.
// subtractBuf holds part of the result of a subtraction; see above.
Blk *subtractBuf = new Blk[len];
// Set preliminary length for quotient and make room
q.len = origLen - b.len + 1;
q.allocate(q.len);
// Zero out the quotient
for (i = 0; i < q.len; i++)
q.blk[i] = 0;
// For each possible left-shift of b in blocks...
i = q.len;
while (i > 0) {
i--;
// For each possible left-shift of b in bits...
// (Remember, N is the number of bits in a Blk.)
q.blk[i] = 0;
i2 = N;
while (i2 > 0) {
i2--;
/*
* Subtract b, shifted left i blocks and i2 bits, from *this,
* and store the answer in subtractBuf. In the for loop, `k == i + j'.
*
* Compare this to the middle section of `multiply'. They
* are in many ways analogous. See especially the discussion
* of `getShiftedBlock'.
*/
for (j = 0, k = i, borrowIn = false; j <= b.len; j++, k++) {
temp = blk[k] - getShiftedBlock(b, j, i2);
borrowOut = (temp > blk[k]);
if (borrowIn) {
borrowOut |= (temp == 0);
temp--;
}
// Since 2005.01.11, indices of `subtractBuf' directly match those of `blk', so use `k'.
subtractBuf[k] = temp;
borrowIn = borrowOut;
}
// No more extra iteration to deal with `bHigh'.
// Roll-over a borrow as necessary.
for (; k < origLen && borrowIn; k++) {
borrowIn = (blk[k] == 0);
subtractBuf[k] = blk[k] - 1;
}
/*
* If the subtraction was performed successfully (!borrowIn),
* set bit i2 in block i of the quotient.
*
* Then, copy the portion of subtractBuf filled by the subtraction
* back to *this. This portion starts with block i and ends--
* where? Not necessarily at block `i + b.len'! Well, we
* increased k every time we saved a block into subtractBuf, so
* the region of subtractBuf we copy is just [i, k).
*/
if (!borrowIn) {
q.blk[i] |= (Blk(1) << i2);
while (k > i) {
k--;
blk[k] = subtractBuf[k];
}
}
}
}
// Zap possible leading zero in quotient
if (q.blk[q.len - 1] == 0)
q.len--;
// Zap any/all leading zeros in remainder
zapLeadingZeros();
// Deallocate subtractBuf.
// (Thanks to Brad Spencer for noticing my accidental omission of this!)
delete [] subtractBuf;
}
/* BITWISE OPERATORS
* These are straightforward blockwise operations except that they differ in
* the output length and the necessity of zapLeadingZeros. */
void BigUnsigned::bitAnd(const BigUnsigned &a, const BigUnsigned &b) {
DTRT_ALIASED(this == &a || this == &b, bitAnd(a, b));
// The bitwise & can't be longer than either operand.
len = (a.len >= b.len) ? b.len : a.len;
allocate(len);
Index i;
for (i = 0; i < len; i++)
blk[i] = a.blk[i] & b.blk[i];
zapLeadingZeros();
}
void BigUnsigned::bitOr(const BigUnsigned &a, const BigUnsigned &b) {
DTRT_ALIASED(this == &a || this == &b, bitOr(a, b));
Index i;
const BigUnsigned *a2, *b2;
if (a.len >= b.len) {
a2 = &a;
b2 = &b;
} else {
a2 = &b;
b2 = &a;
}
allocate(a2->len);
for (i = 0; i < b2->len; i++)
blk[i] = a2->blk[i] | b2->blk[i];
for (; i < a2->len; i++)
blk[i] = a2->blk[i];
len = a2->len;
// Doesn't need zapLeadingZeros.
}
void BigUnsigned::bitXor(const BigUnsigned &a, const BigUnsigned &b) {
DTRT_ALIASED(this == &a || this == &b, bitXor(a, b));
Index i;
const BigUnsigned *a2, *b2;
if (a.len >= b.len) {
a2 = &a;
b2 = &b;
} else {
a2 = &b;
b2 = &a;
}
allocate(a2->len);
for (i = 0; i < b2->len; i++)
blk[i] = a2->blk[i] ^ b2->blk[i];
for (; i < a2->len; i++)
blk[i] = a2->blk[i];
len = a2->len;
zapLeadingZeros();
}
void BigUnsigned::bitShiftLeft(const BigUnsigned &a, int b) {
DTRT_ALIASED(this == &a, bitShiftLeft(a, b));
if (b < 0) {
if (b << 1 == 0)
throw "BigUnsigned::bitShiftLeft: "
"Pathological shift amount not implemented";
else {
bitShiftRight(a, -b);
return;
}
}
Index shiftBlocks = b / N;
unsigned int shiftBits = b % N;
// + 1: room for high bits nudged left into another block
len = a.len + shiftBlocks + 1;
allocate(len);
Index i, j;
for (i = 0; i < shiftBlocks; i++)
blk[i] = 0;
for (j = 0, i = shiftBlocks; j <= a.len; j++, i++)
blk[i] = getShiftedBlock(a, j, shiftBits);
// Zap possible leading zero
if (blk[len - 1] == 0)
len--;
}
void BigUnsigned::bitShiftRight(const BigUnsigned &a, int b) {
DTRT_ALIASED(this == &a, bitShiftRight(a, b));
if (b < 0) {
if (b << 1 == 0)
throw "BigUnsigned::bitShiftRight: "
"Pathological shift amount not implemented";
else {
bitShiftLeft(a, -b);
return;
}
}
// This calculation is wacky, but expressing the shift as a left bit shift
// within each block lets us use getShiftedBlock.
Index rightShiftBlocks = (b + N - 1) / N;
unsigned int leftShiftBits = N * rightShiftBlocks - b;
// Now (N * rightShiftBlocks - leftShiftBits) == b
// and 0 <= leftShiftBits < N.
if (rightShiftBlocks >= a.len + 1) {
// All of a is guaranteed to be shifted off, even considering the left
// bit shift.
len = 0;
return;
}
// Now we're allocating a positive amount.
// + 1: room for high bits nudged left into another block
len = a.len + 1 - rightShiftBlocks;
allocate(len);
Index i, j;
for (j = rightShiftBlocks, i = 0; j <= a.len; j++, i++)
blk[i] = getShiftedBlock(a, j, leftShiftBits);
// Zap possible leading zero
if (blk[len - 1] == 0)
len--;
}
// INCREMENT/DECREMENT OPERATORS
// Prefix increment
void BigUnsigned::operator ++() {
Index i;
bool carry = true;
for (i = 0; i < len && carry; i++) {
blk[i]++;
carry = (blk[i] == 0);
}
if (carry) {
// Allocate and then increase length, as in divideWithRemainder
allocateAndCopy(len + 1);
len++;
blk[i] = 1;
}
}
// Postfix increment: same as prefix
void BigUnsigned::operator ++(int) {
operator ++();
}
// Prefix decrement
void BigUnsigned::operator --() {
if (len == 0)
throw "BigUnsigned::operator --(): Cannot decrement an unsigned zero";
Index i;
bool borrow = true;
for (i = 0; borrow; i++) {
borrow = (blk[i] == 0);
blk[i]--;
}
// Zap possible leading zero (there can only be one)
if (blk[len - 1] == 0)
len--;
}
// Postfix decrement: same as prefix
void BigUnsigned::operator --(int) {
operator --();
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/bigint/BigUnsigned.cc
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 6,719
|
```hack
#ifndef BIGINTEGERALGORITHMS_H
#define BIGINTEGERALGORITHMS_H
#include "BigInteger.hh"
/* Some mathematical algorithms for big integers.
* This code is new and, as such, experimental. */
// Returns the greatest common divisor of a and b.
BigUnsigned gcd(BigUnsigned a, BigUnsigned b);
/* Extended Euclidean algorithm.
* Given m and n, finds gcd g and numbers r, s such that r*m + s*n == g. */
void extendedEuclidean(BigInteger m, BigInteger n,
BigInteger &g, BigInteger &r, BigInteger &s);
/* Returns the multiplicative inverse of x modulo n, or throws an exception if
* they have a common factor. */
BigUnsigned modinv(const BigInteger &x, const BigUnsigned &n);
// Returns (base ^ exponent) % modulus.
BigUnsigned modexp(const BigInteger &base, const BigUnsigned &exponent,
const BigUnsigned &modulus);
#endif
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/bigint/BigIntegerAlgorithms.hh
|
hack
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 197
|
```c++
#include "BigInteger.hh"
void BigInteger::operator =(const BigInteger &x) {
// Calls like a = a have no effect
if (this == &x)
return;
// Copy sign
sign = x.sign;
// Copy the rest
mag = x.mag;
}
BigInteger::BigInteger(const Blk *b, Index blen, Sign s) : mag(b, blen) {
switch (s) {
case zero:
if (!mag.isZero())
throw "BigInteger::BigInteger(const Blk *, Index, Sign): Cannot use a sign of zero with a nonzero magnitude";
sign = zero;
break;
case positive:
case negative:
// If the magnitude is zero, force the sign to zero.
sign = mag.isZero() ? zero : s;
break;
default:
/* g++ seems to be optimizing out this case on the assumption
* that the sign is a valid member of the enumeration. Oh well. */
throw "BigInteger::BigInteger(const Blk *, Index, Sign): Invalid sign";
}
}
BigInteger::BigInteger(const BigUnsigned &x, Sign s) : mag(x) {
switch (s) {
case zero:
if (!mag.isZero())
throw "BigInteger::BigInteger(const BigUnsigned &, Sign): Cannot use a sign of zero with a nonzero magnitude";
sign = zero;
break;
case positive:
case negative:
// If the magnitude is zero, force the sign to zero.
sign = mag.isZero() ? zero : s;
break;
default:
/* g++ seems to be optimizing out this case on the assumption
* that the sign is a valid member of the enumeration. Oh well. */
throw "BigInteger::BigInteger(const BigUnsigned &, Sign): Invalid sign";
}
}
/* CONSTRUCTION FROM PRIMITIVE INTEGERS
* Same idea as in BigUnsigned.cc, except that negative input results in a
* negative BigInteger instead of an exception. */
// Done longhand to let us use initialization.
BigInteger::BigInteger(unsigned long x) : mag(x) { sign = mag.isZero() ? zero : positive; }
BigInteger::BigInteger(unsigned int x) : mag(x) { sign = mag.isZero() ? zero : positive; }
BigInteger::BigInteger(unsigned short x) : mag(x) { sign = mag.isZero() ? zero : positive; }
// For signed input, determine the desired magnitude and sign separately.
namespace {
template <class X, class UX>
BigInteger::Blk magOf(X x) {
/* UX(...) cast needed to stop short(-2^15), which negates to
* itself, from sign-extending in the conversion to Blk. */
return BigInteger::Blk(x < 0 ? UX(-x) : x);
}
template <class X>
BigInteger::Sign signOf(X x) {
return (x == 0) ? BigInteger::zero
: (x > 0) ? BigInteger::positive
: BigInteger::negative;
}
}
BigInteger::BigInteger(long x) : sign(signOf(x)), mag(magOf<long , unsigned long >(x)) {}
BigInteger::BigInteger(int x) : sign(signOf(x)), mag(magOf<int , unsigned int >(x)) {}
BigInteger::BigInteger(short x) : sign(signOf(x)), mag(magOf<short, unsigned short>(x)) {}
// CONVERSION TO PRIMITIVE INTEGERS
/* Reuse BigUnsigned's conversion to an unsigned primitive integer.
* The friend is a separate function rather than
* BigInteger::convertToUnsignedPrimitive to avoid requiring BigUnsigned to
* declare BigInteger. */
template <class X>
inline X convertBigUnsignedToPrimitiveAccess(const BigUnsigned &a) {
return a.convertToPrimitive<X>();
}
template <class X>
X BigInteger::convertToUnsignedPrimitive() const {
if (sign == negative)
throw "BigInteger::to<Primitive>: "
"Cannot convert a negative integer to an unsigned type";
else
return convertBigUnsignedToPrimitiveAccess<X>(mag);
}
/* Similar to BigUnsigned::convertToPrimitive, but split into two cases for
* nonnegative and negative numbers. */
template <class X, class UX>
X BigInteger::convertToSignedPrimitive() const {
if (sign == zero)
return 0;
else if (mag.getLength() == 1) {
// The single block might fit in an X. Try the conversion.
Blk b = mag.getBlock(0);
if (sign == positive) {
X x = X(b);
if (x >= 0 && Blk(x) == b)
return x;
} else {
X x = -X(b);
/* UX(...) needed to avoid rejecting conversion of
* -2^15 to a short. */
if (x < 0 && Blk(UX(-x)) == b)
return x;
}
// Otherwise fall through.
}
throw "BigInteger::to<Primitive>: "
"Value is too big to fit in the requested type";
}
unsigned long BigInteger::toUnsignedLong () const { return convertToUnsignedPrimitive<unsigned long > (); }
unsigned int BigInteger::toUnsignedInt () const { return convertToUnsignedPrimitive<unsigned int > (); }
unsigned short BigInteger::toUnsignedShort() const { return convertToUnsignedPrimitive<unsigned short> (); }
long BigInteger::toLong () const { return convertToSignedPrimitive <long , unsigned long> (); }
int BigInteger::toInt () const { return convertToSignedPrimitive <int , unsigned int> (); }
short BigInteger::toShort () const { return convertToSignedPrimitive <short, unsigned short>(); }
// COMPARISON
BigInteger::CmpRes BigInteger::compareTo(const BigInteger &x) const {
// A greater sign implies a greater number
if (sign < x.sign)
return less;
else if (sign > x.sign)
return greater;
else switch (sign) {
// If the signs are the same...
case zero:
return equal; // Two zeros are equal
case positive:
// Compare the magnitudes
return mag.compareTo(x.mag);
case negative:
// Compare the magnitudes, but return the opposite result
return CmpRes(-mag.compareTo(x.mag));
default:
throw "BigInteger internal error";
}
}
/* COPY-LESS OPERATIONS
* These do some messing around to determine the sign of the result,
* then call one of BigUnsigned's copy-less operations. */
// See remarks about aliased calls in BigUnsigned.cc .
#define DTRT_ALIASED(cond, op) \
if (cond) { \
BigInteger tmpThis; \
tmpThis.op; \
*this = tmpThis; \
return; \
}
void BigInteger::add(const BigInteger &a, const BigInteger &b) {
DTRT_ALIASED(this == &a || this == &b, add(a, b));
// If one argument is zero, copy the other.
if (a.sign == zero)
operator =(b);
else if (b.sign == zero)
operator =(a);
// If the arguments have the same sign, take the
// common sign and add their magnitudes.
else if (a.sign == b.sign) {
sign = a.sign;
mag.add(a.mag, b.mag);
} else {
// Otherwise, their magnitudes must be compared.
switch (a.mag.compareTo(b.mag)) {
case equal:
// If their magnitudes are the same, copy zero.
mag = 0;
sign = zero;
break;
// Otherwise, take the sign of the greater, and subtract
// the lesser magnitude from the greater magnitude.
case greater:
sign = a.sign;
mag.subtract(a.mag, b.mag);
break;
case less:
sign = b.sign;
mag.subtract(b.mag, a.mag);
break;
}
}
}
void BigInteger::subtract(const BigInteger &a, const BigInteger &b) {
// Notice that this routine is identical to BigInteger::add,
// if one replaces b.sign by its opposite.
DTRT_ALIASED(this == &a || this == &b, subtract(a, b));
// If a is zero, copy b and flip its sign. If b is zero, copy a.
if (a.sign == zero) {
mag = b.mag;
// Take the negative of _b_'s, sign, not ours.
// Bug pointed out by Sam Larkin on 2005.03.30.
sign = Sign(-b.sign);
} else if (b.sign == zero)
operator =(a);
// If their signs differ, take a.sign and add the magnitudes.
else if (a.sign != b.sign) {
sign = a.sign;
mag.add(a.mag, b.mag);
} else {
// Otherwise, their magnitudes must be compared.
switch (a.mag.compareTo(b.mag)) {
// If their magnitudes are the same, copy zero.
case equal:
mag = 0;
sign = zero;
break;
// If a's magnitude is greater, take a.sign and
// subtract a from b.
case greater:
sign = a.sign;
mag.subtract(a.mag, b.mag);
break;
// If b's magnitude is greater, take the opposite
// of b.sign and subtract b from a.
case less:
sign = Sign(-b.sign);
mag.subtract(b.mag, a.mag);
break;
}
}
}
void BigInteger::multiply(const BigInteger &a, const BigInteger &b) {
DTRT_ALIASED(this == &a || this == &b, multiply(a, b));
// If one object is zero, copy zero and return.
if (a.sign == zero || b.sign == zero) {
sign = zero;
mag = 0;
return;
}
// If the signs of the arguments are the same, the result
// is positive, otherwise it is negative.
sign = (a.sign == b.sign) ? positive : negative;
// Multiply the magnitudes.
mag.multiply(a.mag, b.mag);
}
/*
* DIVISION WITH REMAINDER
* Please read the comments before the definition of
* `BigUnsigned::divideWithRemainder' in `BigUnsigned.cc' for lots of
* information you should know before reading this function.
*
* Following Knuth, I decree that x / y is to be
* 0 if y==0 and floor(real-number x / y) if y!=0.
* Then x % y shall be x - y*(integer x / y).
*
* Note that x = y * (x / y) + (x % y) always holds.
* In addition, (x % y) is from 0 to y - 1 if y > 0,
* and from -(|y| - 1) to 0 if y < 0. (x % y) = x if y = 0.
*
* Examples: (q = a / b, r = a % b)
* a b q r
* === === === ===
* 4 3 1 1
* -4 3 -2 2
* 4 -3 -2 -2
* -4 -3 1 -1
*/
void BigInteger::divideWithRemainder(const BigInteger &b, BigInteger &q) {
// Defend against aliased calls;
// same idea as in BigUnsigned::divideWithRemainder .
if (this == &q)
throw "BigInteger::divideWithRemainder: Cannot write quotient and remainder into the same variable";
if (this == &b || &q == &b) {
BigInteger tmpB(b);
divideWithRemainder(tmpB, q);
return;
}
// Division by zero gives quotient 0 and remainder *this
if (b.sign == zero) {
q.mag = 0;
q.sign = zero;
return;
}
// 0 / b gives quotient 0 and remainder 0
if (sign == zero) {
q.mag = 0;
q.sign = zero;
return;
}
// Here *this != 0, b != 0.
// Do the operands have the same sign?
if (sign == b.sign) {
// Yes: easy case. Quotient is zero or positive.
q.sign = positive;
} else {
// No: harder case. Quotient is negative.
q.sign = negative;
// Decrease the magnitude of the dividend by one.
mag--;
/*
* We tinker with the dividend before and with the
* quotient and remainder after so that the result
* comes out right. To see why it works, consider the following
* list of examples, where A is the magnitude-decreased
* a, Q and R are the results of BigUnsigned division
* with remainder on A and |b|, and q and r are the
* final results we want:
*
* a A b Q R q r
* -3 -2 3 0 2 -1 0
* -4 -3 3 1 0 -2 2
* -5 -4 3 1 1 -2 1
* -6 -5 3 1 2 -2 0
*
* It appears that we need a total of 3 corrections:
* Decrease the magnitude of a to get A. Increase the
* magnitude of Q to get q (and make it negative).
* Find r = (b - 1) - R and give it the desired sign.
*/
}
// Divide the magnitudes.
mag.divideWithRemainder(b.mag, q.mag);
if (sign != b.sign) {
// More for the harder case (as described):
// Increase the magnitude of the quotient by one.
q.mag++;
// Modify the remainder.
mag.subtract(b.mag, mag);
mag--;
}
// Sign of the remainder is always the sign of the divisor b.
sign = b.sign;
// Set signs to zero as necessary. (Thanks David Allen!)
if (mag.isZero())
sign = zero;
if (q.mag.isZero())
q.sign = zero;
// WHEW!!!
}
// Negation
void BigInteger::negate(const BigInteger &a) {
DTRT_ALIASED(this == &a, negate(a));
// Copy a's magnitude
mag = a.mag;
// Copy the opposite of a.sign
sign = Sign(-a.sign);
}
// INCREMENT/DECREMENT OPERATORS
// Prefix increment
void BigInteger::operator ++() {
if (sign == negative) {
mag--;
if (mag == 0)
sign = zero;
} else {
mag++;
sign = positive; // if not already
}
}
// Postfix increment: same as prefix
void BigInteger::operator ++(int) {
operator ++();
}
// Prefix decrement
void BigInteger::operator --() {
if (sign == positive) {
mag--;
if (mag == 0)
sign = zero;
} else {
mag++;
sign = negative;
}
}
// Postfix decrement: same as prefix
void BigInteger::operator --(int) {
operator --();
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQQRCodeReader/zxing/bigint/BigInteger.cc
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 3,381
|
```c
/*
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#include "cache.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#ifdef ZOPFLI_LONGEST_MATCH_CACHE
void ZopfliInitCache(size_t blocksize, ZopfliLongestMatchCache* lmc) {
size_t i;
lmc->length = (unsigned short*)malloc(sizeof(unsigned short) * blocksize);
lmc->dist = (unsigned short*)malloc(sizeof(unsigned short) * blocksize);
/* Rather large amount of memory. */
lmc->sublen = (unsigned char*)malloc(ZOPFLI_CACHE_LENGTH * 3 * blocksize);
if(lmc->sublen == NULL) {
fprintf(stderr,
"Error: Out of memory. Tried allocating %d bytes of memory.\n",
(int)(ZOPFLI_CACHE_LENGTH * 3 * blocksize));
exit (EXIT_FAILURE);
}
/* length > 0 and dist 0 is invalid combination, which indicates on purpose
that this cache value is not filled in yet. */
for (i = 0; i < blocksize; i++) lmc->length[i] = 1;
for (i = 0; i < blocksize; i++) lmc->dist[i] = 0;
for (i = 0; i < ZOPFLI_CACHE_LENGTH * blocksize * 3; i++) lmc->sublen[i] = 0;
}
void ZopfliCleanCache(ZopfliLongestMatchCache* lmc) {
free(lmc->length);
free(lmc->dist);
free(lmc->sublen);
}
void ZopfliSublenToCache(const unsigned short* sublen,
size_t pos, size_t length,
ZopfliLongestMatchCache* lmc) {
size_t i;
size_t j = 0;
unsigned bestlength = 0;
unsigned char* cache;
#if ZOPFLI_CACHE_LENGTH == 0
return;
#endif
cache = &lmc->sublen[ZOPFLI_CACHE_LENGTH * pos * 3];
if (length < 3) return;
for (i = 3; i <= length; i++) {
if (i == length || sublen[i] != sublen[i + 1]) {
cache[j * 3] = i - 3;
cache[j * 3 + 1] = sublen[i] % 256;
cache[j * 3 + 2] = (sublen[i] >> 8) % 256;
bestlength = i;
j++;
if (j >= ZOPFLI_CACHE_LENGTH) break;
}
}
if (j < ZOPFLI_CACHE_LENGTH) {
assert(bestlength == length);
cache[(ZOPFLI_CACHE_LENGTH - 1) * 3] = bestlength - 3;
} else {
assert(bestlength <= length);
}
assert(bestlength == ZopfliMaxCachedSublen(lmc, pos, length));
}
void ZopfliCacheToSublen(const ZopfliLongestMatchCache* lmc,
size_t pos, size_t length,
unsigned short* sublen) {
size_t i, j;
unsigned maxlength = ZopfliMaxCachedSublen(lmc, pos, length);
unsigned prevlength = 0;
unsigned char* cache;
#if ZOPFLI_CACHE_LENGTH == 0
return;
#endif
if (length < 3) return;
cache = &lmc->sublen[ZOPFLI_CACHE_LENGTH * pos * 3];
for (j = 0; j < ZOPFLI_CACHE_LENGTH; j++) {
unsigned length = cache[j * 3] + 3;
unsigned dist = cache[j * 3 + 1] + 256 * cache[j * 3 + 2];
for (i = prevlength; i <= length; i++) {
sublen[i] = dist;
}
if (length == maxlength) break;
prevlength = length + 1;
}
}
/*
Returns the length up to which could be stored in the cache.
*/
unsigned ZopfliMaxCachedSublen(const ZopfliLongestMatchCache* lmc,
size_t pos, size_t length) {
unsigned char* cache;
#if ZOPFLI_CACHE_LENGTH == 0
return 0;
#endif
cache = &lmc->sublen[ZOPFLI_CACHE_LENGTH * pos * 3];
(void)length;
if (cache[1] == 0 && cache[2] == 0) return 0; /* No sublen cached. */
return cache[(ZOPFLI_CACHE_LENGTH - 1) * 3] + 3;
}
#endif /* ZOPFLI_LONGEST_MATCH_CACHE */
```
|
/content/code_sandbox/library/JQLibrary/src/JQZopfli/zopfli/cache.c
|
c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 1,130
|
```c++
/*
This file is part of JQLibrary
Contact email: 188080501@qq.com
Alternatively, this file may be used under the terms of the GNU Lesser
Software Foundation and appearing in the file LICENSE.LGPLv21 and
LICENSE.LGPLv3 included in the packaging of this file. Please review the
requirements will be met: path_to_url and
path_to_url
*/
#include "JQZopfli.h"
// C lib import
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// C++ lib import
#include <set>
#include <vector>
// Qt lib import
#include <QFile>
#include <QTime>
#include <QDebug>
#include <QElapsedTimer>
// zopfli lib import
#include "lodepng.h"
#include "lodepng_util.h"
#include "zopflipng_lib.h"
#include "lodepng.h"
#include "lodepng_util.h"
#include "deflate.h"
using namespace JQZopfli;
ZopfliPNGOptions::ZopfliPNGOptions()
: verbose(false)
, lossy_transparent(false)
, lossy_8bit(false)
, auto_filter_strategy(true)
, use_zopfli(true)
, num_iterations(15)
, num_iterations_large(5)
, block_split_strategy(1) {
}
unsigned CustomPNGDeflate(unsigned char** out, size_t* outsize,
const unsigned char* in, size_t insize,
const LodePNGCompressSettings* settings) {
const ZopfliPNGOptions* png_options =
static_cast<const ZopfliPNGOptions*>(settings->custom_context);
unsigned char bp = 0;
ZopfliOptions options;
ZopfliInitOptions(&options);
options.verbose = png_options->verbose;
options.numiterations = insize < 200000
? png_options->num_iterations : png_options->num_iterations_large;
ZopfliDeflate(&options, 2 /* Dynamic */, 1, in, insize, &bp, out, outsize);
return 0; // OK
}
// Returns 32-bit integer value for RGBA color.
static unsigned ColorIndex(const unsigned char* color) {
return color[0] + 256u * color[1] + 65536u * color[2] + 16777216u * color[3];
}
// Counts amount of colors in the image, up to 257. If transparent_counts_as_one
// is enabled, any color with alpha channel 0 is treated as a single color with
// index 0.
void CountColors(std::set<unsigned>* unique,
const unsigned char* image, unsigned w, unsigned h,
bool transparent_counts_as_one) {
unique->clear();
for (size_t i = 0; i < w * h; i++) {
unsigned index = ColorIndex(&image[i * 4]);
if (transparent_counts_as_one && image[i * 4 + 3] == 0) index = 0;
unique->insert(index);
if (unique->size() > 256) break;
}
}
// Remove RGB information from pixels with alpha=0
void LossyOptimizeTransparent(lodepng::State* inputstate, unsigned char* image,
unsigned w, unsigned h) {
// First check if we want to preserve potential color-key background color,
// or instead use the last encountered RGB value all the time to save bytes.
bool key = true;
for (size_t i = 0; i < w * h; i++) {
if (image[i * 4 + 3] > 0 && image[i * 4 + 3] < 255) {
key = false;
break;
}
}
std::set<unsigned> count; // Color count, up to 257.
CountColors(&count, image, w, h, true);
// If true, means palette is possible so avoid using different RGB values for
// the transparent color.
bool palette = count.size() <= 256;
// Choose the color key or first initial background color.
int r = 0, g = 0, b = 0;
if (key || palette) {
for (size_t i = 0; i < w * h; i++) {
if (image[i * 4 + 3] == 0) {
// Use RGB value of first encountered transparent pixel. This can be
// used as a valid color key, or in case of palette ensures a color
// existing in the input image palette is used.
r = image[i * 4 + 0];
g = image[i * 4 + 1];
b = image[i * 4 + 2];
break;
}
}
}
for (size_t i = 0; i < w * h; i++) {
// if alpha is 0, alter the RGB value to a possibly more efficient one.
if (image[i * 4 + 3] == 0) {
image[i * 4 + 0] = r;
image[i * 4 + 1] = g;
image[i * 4 + 2] = b;
} else {
if (!key && !palette) {
// Use the last encountered RGB value if no key or palette is used: that
// way more values can be 0 thanks to the PNG filter types.
r = image[i * 4 + 0];
g = image[i * 4 + 1];
b = image[i * 4 + 2];
}
}
}
// If there are now less colors, update palette of input image to match this.
if (palette && inputstate->info_png.color.palettesize > 0) {
CountColors(&count, image, w, h, false);
if (count.size() < inputstate->info_png.color.palettesize) {
std::vector<unsigned char> palette_out;
unsigned char* palette_in = inputstate->info_png.color.palette;
for (size_t i = 0; i < inputstate->info_png.color.palettesize; i++) {
if (count.count(ColorIndex(&palette_in[i * 4])) != 0) {
palette_out.push_back(palette_in[i * 4 + 0]);
palette_out.push_back(palette_in[i * 4 + 1]);
palette_out.push_back(palette_in[i * 4 + 2]);
palette_out.push_back(palette_in[i * 4 + 3]);
}
}
inputstate->info_png.color.palettesize = palette_out.size() / 4;
for (size_t i = 0; i < palette_out.size(); i++) {
palette_in[i] = palette_out[i];
}
}
}
}
// Tries to optimize given a single PNG filter strategy.
// Returns 0 if ok, other value for error
unsigned TryOptimize(
const std::vector<unsigned char>& image, unsigned w, unsigned h,
const lodepng::State& inputstate, bool bit16, bool keep_colortype,
const std::vector<unsigned char>& origfile,
ZopfliPNGFilterStrategy filterstrategy,
bool use_zopfli, int windowsize, const ZopfliPNGOptions* png_options,
std::vector<unsigned char>* out) {
unsigned error = 0;
lodepng::State state;
state.encoder.zlibsettings.windowsize = windowsize;
if (use_zopfli && png_options->use_zopfli) {
state.encoder.zlibsettings.custom_deflate = CustomPNGDeflate;
state.encoder.zlibsettings.custom_context = png_options;
}
if (keep_colortype) {
state.encoder.auto_convert = 0;
lodepng_color_mode_copy(&state.info_png.color, &inputstate.info_png.color);
}
if (inputstate.info_png.color.colortype == LCT_PALETTE) {
// Make it preserve the original palette order
lodepng_color_mode_copy(&state.info_raw, &inputstate.info_png.color);
state.info_raw.colortype = LCT_RGBA;
state.info_raw.bitdepth = 8;
}
if (bit16) {
state.info_raw.bitdepth = 16;
}
state.encoder.filter_palette_zero = 0;
std::vector<unsigned char> filters;
switch (filterstrategy) {
case kStrategyZero:
state.encoder.filter_strategy = LFS_ZERO;
break;
case kStrategyMinSum:
state.encoder.filter_strategy = LFS_MINSUM;
break;
case kStrategyEntropy:
state.encoder.filter_strategy = LFS_ENTROPY;
break;
case kStrategyBruteForce:
state.encoder.filter_strategy = LFS_BRUTE_FORCE;
break;
case kStrategyOne:
case kStrategyTwo:
case kStrategyThree:
case kStrategyFour:
// Set the filters of all scanlines to that number.
filters.resize(h, filterstrategy);
state.encoder.filter_strategy = LFS_PREDEFINED;
state.encoder.predefined_filters = &filters[0];
break;
case kStrategyPredefined:
lodepng::getFilterTypes(filters, origfile);
if (filters.size() != h) return 1; // Error getting filters
state.encoder.filter_strategy = LFS_PREDEFINED;
state.encoder.predefined_filters = &filters[0];
break;
default:
break;
}
state.encoder.add_id = false;
state.encoder.text_compression = 1;
error = lodepng::encode(*out, image, w, h, state);
// For very small output, also try without palette, it may be smaller thanks
// to no palette storage overhead.
if (!error && out->size() < 4096 && !keep_colortype) {
lodepng::State teststate;
std::vector<unsigned char> temp;
lodepng::decode(temp, w, h, teststate, *out);
if (teststate.info_png.color.colortype == LCT_PALETTE) {
LodePNGColorProfile profile;
lodepng_color_profile_init(&profile);
lodepng_get_color_profile(&profile, &image[0], w, h, &state.info_raw);
// Too small for tRNS chunk overhead.
if (w * h <= 16 && profile.key) profile.alpha = 1;
state.encoder.auto_convert = 0;
state.info_png.color.colortype = (profile.alpha ? LCT_RGBA : LCT_RGB);
state.info_png.color.bitdepth = 8;
state.info_png.color.key_defined = (profile.key && !profile.alpha);
if (state.info_png.color.key_defined) {
state.info_png.color.key_defined = 1;
state.info_png.color.key_r = (profile.key_r & 255u);
state.info_png.color.key_g = (profile.key_g & 255u);
state.info_png.color.key_b = (profile.key_b & 255u);
}
std::vector<unsigned char> out2;
error = lodepng::encode(out2, image, w, h, state);
if (out2.size() < out->size()) out->swap(out2);
}
}
if (error) {
printf("Encoding error %u: %s\n", error, lodepng_error_text(error));
return error;
}
return 0;
}
// Use fast compression to check which PNG filter strategy gives the smallest
// output. This allows to then do the slow and good compression only on that
// filter type.
unsigned AutoChooseFilterStrategy(const std::vector<unsigned char>& image,
unsigned w, unsigned h,
const lodepng::State& inputstate,
bool bit16, bool keep_colortype,
const std::vector<unsigned char>& origfile,
int numstrategies,
ZopfliPNGFilterStrategy* strategies,
bool* enable) {
std::vector<unsigned char> out;
size_t bestsize = 0;
int bestfilter = 0;
// A large window size should still be used to do the quick compression to
// try out filter strategies: which filter strategy is the best depends
// largely on the window size, the closer to the actual used window size the
// better.
int windowsize = 8192;
for (int i = 0; i < numstrategies; i++) {
out.clear();
unsigned error = TryOptimize(image, w, h, inputstate, bit16, keep_colortype,
origfile, strategies[i], false, windowsize, 0,
&out);
if (error) return error;
if (bestsize == 0 || out.size() < bestsize) {
bestsize = out.size();
bestfilter = i;
}
}
for (int i = 0; i < numstrategies; i++) {
enable[i] = (i == bestfilter);
}
return 0; /* OK */
}
void ChunksToKeep(const std::vector<unsigned char>& origpng,
const std::vector<std::string>& keepnames,
std::set<std::string>* result) {
std::vector<std::string> names[3];
std::vector<std::vector<unsigned char> > chunks[3];
lodepng::getChunks(names, chunks, origpng);
for (size_t i = 0; i < 3; i++) {
for (size_t j = 0; j < names[i].size(); j++) {
for (size_t k = 0; k < keepnames.size(); k++) {
if (keepnames[k] == names[i][j]) {
result->insert(names[i][j]);
}
}
}
}
}
// Keeps chunks with given names from the original png by literally copying them
// into the new png
void KeepChunks(const std::vector<unsigned char>& origpng,
const std::vector<std::string>& keepnames,
std::vector<unsigned char>* png) {
std::vector<std::string> names[3];
std::vector<std::vector<unsigned char> > chunks[3];
lodepng::getChunks(names, chunks, origpng);
std::vector<std::vector<unsigned char> > keepchunks[3];
// There are 3 distinct locations in a PNG file for chunks: between IHDR and
// PLTE, between PLTE and IDAT, and between IDAT and IEND. Keep each chunk at
// its corresponding location in the new PNG.
for (size_t i = 0; i < 3; i++) {
for (size_t j = 0; j < names[i].size(); j++) {
for (size_t k = 0; k < keepnames.size(); k++) {
if (keepnames[k] == names[i][j]) {
keepchunks[i].push_back(chunks[i][j]);
}
}
}
}
lodepng::insertChunks(*png, keepchunks);
}
int ZopfliPNGOptimize(const std::vector<unsigned char>& origpng,
const ZopfliPNGOptions& png_options,
bool verbose,
std::vector<unsigned char>* resultpng) {
// Use the largest possible deflate window size
int windowsize = 32768;
ZopfliPNGFilterStrategy filterstrategies[kNumFilterStrategies] = {
kStrategyZero, kStrategyOne, kStrategyTwo, kStrategyThree, kStrategyFour,
kStrategyMinSum, kStrategyEntropy, kStrategyPredefined, kStrategyBruteForce
};
bool strategy_enable[kNumFilterStrategies] = {
false, false, false, false, false, false, false, false, false
};
std::string strategy_name[kNumFilterStrategies] = {
"zero", "one", "two", "three", "four",
"minimum sum", "entropy", "predefined", "brute force"
};
for (size_t i = 0; i < png_options.filter_strategies.size(); i++) {
strategy_enable[png_options.filter_strategies[i]] = true;
}
std::vector<unsigned char> image;
unsigned w, h;
unsigned error;
lodepng::State inputstate;
error = lodepng::decode(image, w, h, inputstate, origpng);
bool keep_colortype = false;
if (!png_options.keepchunks.empty()) {
// If the user wants to keep the non-essential chunks bKGD or sBIT, the
// input color type has to be kept since the chunks format depend on it.
// This may severely hurt compression if it is not an ideal color type.
// Ideally these chunks should not be kept for web images. Handling of bKGD
// chunks could be improved by changing its color type but not done yet due
// to its additional complexity, for sBIT such improvement is usually not
// possible.
std::set<std::string> keepchunks;
ChunksToKeep(origpng, png_options.keepchunks, &keepchunks);
keep_colortype = keepchunks.count("bKGD") || keepchunks.count("sBIT");
if (keep_colortype && verbose) {
printf("Forced to keep original color type due to keeping bKGD or sBIT"
" chunk.\n");
}
}
if (error) {
if (verbose) {
if (error == 1) {
printf("Decoding error\n");
} else {
printf("Decoding error %u: %s\n", error, lodepng_error_text(error));
}
}
return error;
}
bool bit16 = false; // Using 16-bit per channel raw image
if (inputstate.info_png.color.bitdepth == 16 &&
(keep_colortype || !png_options.lossy_8bit)) {
// Decode as 16-bit
image.clear();
error = lodepng::decode(image, w, h, origpng, LCT_RGBA, 16);
bit16 = true;
}
if (!error) {
// If lossy_transparent, remove RGB information from pixels with alpha=0
if (png_options.lossy_transparent && !bit16) {
LossyOptimizeTransparent(&inputstate, &image[0], w, h);
}
if (png_options.auto_filter_strategy) {
error = AutoChooseFilterStrategy(image, w, h, inputstate, bit16,
keep_colortype, origpng,
/* Don't try brute force */
kNumFilterStrategies - 1,
filterstrategies, strategy_enable);
}
}
if (!error) {
size_t bestsize = 0;
for (int i = 0; i < kNumFilterStrategies; i++) {
if (!strategy_enable[i]) continue;
std::vector<unsigned char> temp;
error = TryOptimize(image, w, h, inputstate, bit16, keep_colortype,
origpng, filterstrategies[i], true /* use_zopfli */,
windowsize, &png_options, &temp);
if (!error) {
if (verbose) {
printf("Filter strategy %s: %d bytes\n",
strategy_name[i].c_str(), (int) temp.size());
}
if (bestsize == 0 || temp.size() < bestsize) {
bestsize = temp.size();
(*resultpng).swap(temp); // Store best result so far in the output.
}
}
}
if (!png_options.keepchunks.empty()) {
KeepChunks(origpng, png_options.keepchunks, resultpng);
}
}
return error;
}
int CZopfliPNGOptimize(const unsigned char* origpng,
const size_t origpng_size,
const CZopfliPNGOptions* png_options,
int verbose,
unsigned char** resultpng,
size_t* resultpng_size) {
ZopfliPNGOptions opts;
// Copy over to the C++-style struct
opts.lossy_transparent = !!png_options->lossy_transparent;
opts.lossy_8bit = !!png_options->lossy_8bit;
opts.auto_filter_strategy = !!png_options->auto_filter_strategy;
opts.use_zopfli = !!png_options->use_zopfli;
opts.num_iterations = png_options->num_iterations;
opts.num_iterations_large = png_options->num_iterations_large;
opts.block_split_strategy = png_options->block_split_strategy;
for (int i = 0; i < png_options->num_filter_strategies; i++) {
opts.filter_strategies.push_back(png_options->filter_strategies[i]);
}
for (int i = 0; i < png_options->num_keepchunks; i++) {
opts.keepchunks.push_back(png_options->keepchunks[i]);
}
const std::vector<unsigned char> origpng_cc(origpng, origpng + origpng_size);
std::vector<unsigned char> resultpng_cc;
int ret = ZopfliPNGOptimize(origpng_cc, opts, !!verbose, &resultpng_cc);
if (ret) {
return ret;
}
*resultpng_size = resultpng_cc.size();
*resultpng = (unsigned char*) malloc(resultpng_cc.size());
if (!(*resultpng)) {
return 12;
}
memcpy(*resultpng,
reinterpret_cast<unsigned char*>(&resultpng_cc[0]),
resultpng_cc.size());
return 0;
}
OptimizeResult JQZopfli::optimize(const QString &originalFilePath, const QString &resultFilePath)
{
QElapsedTimer timer;
timer.start();
OptimizeResult result;
if ( !QFile( originalFilePath ).exists() )
{
qDebug() << "JQZopfli::optimize: error1";
return result;
}
std::vector< unsigned char > originalPng;
std::vector< unsigned char > resultPng;
if ( lodepng::load_file( originalPng, originalFilePath.toLocal8Bit().data() ) )
{
qDebug() << "JQZopfli::optimize: error2";
return result;
}
result.originalSize = (int)originalPng.size();
ZopfliPNGOptions pngOptions;
if ( ZopfliPNGOptimize( originalPng, pngOptions, pngOptions.verbose, &resultPng ) )
{
qDebug() << "JQZopfli::optimize: error3";
return result;
}
result.optimizeSucceed = true;
result.resultSize = (int)resultPng.size();
result.compressionRatio = (double)resultPng.size() / (double)originalPng.size();
result.timeConsuming = timer.elapsed();
QFile file( resultFilePath );
if ( !file.open( QIODevice::WriteOnly ) )
{
qDebug() << "JQZopfli::optimize: error4";
return result;
}
file.write( QByteArray( (const char *)resultPng.data(), (int)resultPng.size() ) );
file.waitForBytesWritten( 30 * 1000 );
return result;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQZopfli/JQZopfli.cpp
|
c++
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 5,105
|
```c
/*
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#include "squeeze.h"
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include "blocksplitter.h"
#include "deflate.h"
#include "symbols.h"
#include "tree.h"
#include "util.h"
typedef struct SymbolStats {
/* The literal and length symbols. */
size_t litlens[ZOPFLI_NUM_LL];
/* The 32 unique dist symbols, not the 32768 possible dists. */
size_t dists[ZOPFLI_NUM_D];
/* Length of each lit/len symbol in bits. */
double ll_symbols[ZOPFLI_NUM_LL];
/* Length of each dist symbol in bits. */
double d_symbols[ZOPFLI_NUM_D];
} SymbolStats;
/* Sets everything to 0. */
static void InitStats(SymbolStats* stats) {
memset(stats->litlens, 0, ZOPFLI_NUM_LL * sizeof(stats->litlens[0]));
memset(stats->dists, 0, ZOPFLI_NUM_D * sizeof(stats->dists[0]));
memset(stats->ll_symbols, 0, ZOPFLI_NUM_LL * sizeof(stats->ll_symbols[0]));
memset(stats->d_symbols, 0, ZOPFLI_NUM_D * sizeof(stats->d_symbols[0]));
}
static void CopyStats(SymbolStats* source, SymbolStats* dest) {
memcpy(dest->litlens, source->litlens,
ZOPFLI_NUM_LL * sizeof(dest->litlens[0]));
memcpy(dest->dists, source->dists, ZOPFLI_NUM_D * sizeof(dest->dists[0]));
memcpy(dest->ll_symbols, source->ll_symbols,
ZOPFLI_NUM_LL * sizeof(dest->ll_symbols[0]));
memcpy(dest->d_symbols, source->d_symbols,
ZOPFLI_NUM_D * sizeof(dest->d_symbols[0]));
}
/* Adds the bit lengths. */
static void AddWeighedStatFreqs(const SymbolStats* stats1, double w1,
const SymbolStats* stats2, double w2,
SymbolStats* result) {
size_t i;
for (i = 0; i < ZOPFLI_NUM_LL; i++) {
result->litlens[i] =
(size_t) (stats1->litlens[i] * w1 + stats2->litlens[i] * w2);
}
for (i = 0; i < ZOPFLI_NUM_D; i++) {
result->dists[i] =
(size_t) (stats1->dists[i] * w1 + stats2->dists[i] * w2);
}
result->litlens[256] = 1; /* End symbol. */
}
typedef struct RanState {
unsigned int m_w, m_z;
} RanState;
static void InitRanState(RanState* state) {
state->m_w = 1;
state->m_z = 2;
}
/* Get random number: "Multiply-With-Carry" generator of G. Marsaglia */
static unsigned int Ran(RanState* state) {
state->m_z = 36969 * (state->m_z & 65535) + (state->m_z >> 16);
state->m_w = 18000 * (state->m_w & 65535) + (state->m_w >> 16);
return (state->m_z << 16) + state->m_w; /* 32-bit result. */
}
static void RandomizeFreqs(RanState* state, size_t* freqs, int n) {
int i;
for (i = 0; i < n; i++) {
if ((Ran(state) >> 4) % 3 == 0) freqs[i] = freqs[Ran(state) % n];
}
}
static void RandomizeStatFreqs(RanState* state, SymbolStats* stats) {
RandomizeFreqs(state, stats->litlens, ZOPFLI_NUM_LL);
RandomizeFreqs(state, stats->dists, ZOPFLI_NUM_D);
stats->litlens[256] = 1; /* End symbol. */
}
static void ClearStatFreqs(SymbolStats* stats) {
size_t i;
for (i = 0; i < ZOPFLI_NUM_LL; i++) stats->litlens[i] = 0;
for (i = 0; i < ZOPFLI_NUM_D; i++) stats->dists[i] = 0;
}
/*
Function that calculates a cost based on a model for the given LZ77 symbol.
litlen: means literal symbol if dist is 0, length otherwise.
*/
typedef double CostModelFun(unsigned litlen, unsigned dist, void* context);
/*
Cost model which should exactly match fixed tree.
type: CostModelFun
*/
static double GetCostFixed(unsigned litlen, unsigned dist, void* unused) {
(void)unused;
if (dist == 0) {
if (litlen <= 143) return 8;
else return 9;
} else {
int dbits = ZopfliGetDistExtraBits(dist);
int lbits = ZopfliGetLengthExtraBits(litlen);
int lsym = ZopfliGetLengthSymbol(litlen);
int cost = 0;
if (lsym <= 279) cost += 7;
else cost += 8;
cost += 5; /* Every dist symbol has length 5. */
return cost + dbits + lbits;
}
}
/*
Cost model based on symbol statistics.
type: CostModelFun
*/
static double GetCostStat(unsigned litlen, unsigned dist, void* context) {
SymbolStats* stats = (SymbolStats*)context;
if (dist == 0) {
return stats->ll_symbols[litlen];
} else {
int lsym = ZopfliGetLengthSymbol(litlen);
int lbits = ZopfliGetLengthExtraBits(litlen);
int dsym = ZopfliGetDistSymbol(dist);
int dbits = ZopfliGetDistExtraBits(dist);
return lbits + dbits + stats->ll_symbols[lsym] + stats->d_symbols[dsym];
}
}
/*
Finds the minimum possible cost this cost model can return for valid length and
distance symbols.
*/
static double GetCostModelMinCost(CostModelFun* costmodel, void* costcontext) {
double mincost;
int bestlength = 0; /* length that has lowest cost in the cost model */
int bestdist = 0; /* distance that has lowest cost in the cost model */
int i;
/*
Table of distances that have a different distance symbol in the deflate
specification. Each value is the first distance that has a new symbol. Only
different symbols affect the cost model so only these need to be checked.
See RFC 1951 section 3.2.5. Compressed blocks (length and distance codes).
*/
static const int dsymbols[30] = {
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513,
769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577
};
mincost = ZOPFLI_LARGE_FLOAT;
for (i = 3; i < 259; i++) {
double c = costmodel(i, 1, costcontext);
if (c < mincost) {
bestlength = i;
mincost = c;
}
}
mincost = ZOPFLI_LARGE_FLOAT;
for (i = 0; i < 30; i++) {
double c = costmodel(3, dsymbols[i], costcontext);
if (c < mincost) {
bestdist = dsymbols[i];
mincost = c;
}
}
return costmodel(bestlength, bestdist, costcontext);
}
static size_t zopfli_min(size_t a, size_t b) {
return a < b ? a : b;
}
/*
Performs the forward pass for "squeeze". Gets the most optimal length to reach
every byte from a previous byte, using cost calculations.
s: the ZopfliBlockState
in: the input data array
instart: where to start
inend: where to stop (not inclusive)
costmodel: function to calculate the cost of some lit/len/dist pair.
costcontext: abstract context for the costmodel function
length_array: output array of size (inend - instart) which will receive the best
length to reach this byte from a previous byte.
returns the cost that was, according to the costmodel, needed to get to the end.
*/
static double GetBestLengths(ZopfliBlockState *s,
const unsigned char* in,
size_t instart, size_t inend,
CostModelFun* costmodel, void* costcontext,
unsigned short* length_array,
ZopfliHash* h, float* costs) {
/* Best cost to get here so far. */
size_t blocksize = inend - instart;
size_t i = 0, k, kend;
unsigned short leng;
unsigned short dist;
unsigned short sublen[259];
size_t windowstart = instart > ZOPFLI_WINDOW_SIZE
? instart - ZOPFLI_WINDOW_SIZE : 0;
double result;
double mincost = GetCostModelMinCost(costmodel, costcontext);
double mincostaddcostj;
if (instart == inend) return 0;
ZopfliResetHash(ZOPFLI_WINDOW_SIZE, h);
ZopfliWarmupHash(in, windowstart, inend, h);
for (i = windowstart; i < instart; i++) {
ZopfliUpdateHash(in, i, inend, h);
}
for (i = 1; i < blocksize + 1; i++) costs[i] = ZOPFLI_LARGE_FLOAT;
costs[0] = 0; /* Because it's the start. */
length_array[0] = 0;
for (i = instart; i < inend; i++) {
size_t j = i - instart; /* Index in the costs array and length_array. */
ZopfliUpdateHash(in, i, inend, h);
#ifdef ZOPFLI_SHORTCUT_LONG_REPETITIONS
/* If we're in a long repetition of the same character and have more than
ZOPFLI_MAX_MATCH characters before and after our position. */
if (h->same[i & ZOPFLI_WINDOW_MASK] > ZOPFLI_MAX_MATCH * 2
&& i > instart + ZOPFLI_MAX_MATCH + 1
&& i + ZOPFLI_MAX_MATCH * 2 + 1 < inend
&& h->same[(i - ZOPFLI_MAX_MATCH) & ZOPFLI_WINDOW_MASK]
> ZOPFLI_MAX_MATCH) {
double symbolcost = costmodel(ZOPFLI_MAX_MATCH, 1, costcontext);
/* Set the length to reach each one to ZOPFLI_MAX_MATCH, and the cost to
the cost corresponding to that length. Doing this, we skip
ZOPFLI_MAX_MATCH values to avoid calling ZopfliFindLongestMatch. */
for (k = 0; k < ZOPFLI_MAX_MATCH; k++) {
costs[j + ZOPFLI_MAX_MATCH] = costs[j] + symbolcost;
length_array[j + ZOPFLI_MAX_MATCH] = ZOPFLI_MAX_MATCH;
i++;
j++;
ZopfliUpdateHash(in, i, inend, h);
}
}
#endif
ZopfliFindLongestMatch(s, h, in, i, inend, ZOPFLI_MAX_MATCH, sublen,
&dist, &leng);
/* Literal. */
if (i + 1 <= inend) {
double newCost = costmodel(in[i], 0, costcontext) + costs[j];
assert(newCost >= 0);
if (newCost < costs[j + 1]) {
costs[j + 1] = newCost;
length_array[j + 1] = 1;
}
}
/* Lengths. */
kend = zopfli_min(leng, inend-i);
mincostaddcostj = mincost + costs[j];
for (k = 3; k <= kend; k++) {
double newCost;
/* Calling the cost model is expensive, avoid this if we are already at
the minimum possible cost that it can return. */
if (costs[j + k] <= mincostaddcostj) continue;
newCost = costmodel(k, sublen[k], costcontext) + costs[j];
assert(newCost >= 0);
if (newCost < costs[j + k]) {
assert(k <= ZOPFLI_MAX_MATCH);
costs[j + k] = newCost;
length_array[j + k] = k;
}
}
}
assert(costs[blocksize] >= 0);
result = costs[blocksize];
return result;
}
/*
Calculates the optimal path of lz77 lengths to use, from the calculated
length_array. The length_array must contain the optimal length to reach that
byte. The path will be filled with the lengths to use, so its data size will be
the amount of lz77 symbols.
*/
static void TraceBackwards(size_t size, const unsigned short* length_array,
unsigned short** path, size_t* pathsize) {
size_t index = size;
if (size == 0) return;
for (;;) {
ZOPFLI_APPEND_DATA(length_array[index], path, pathsize);
assert(length_array[index] <= index);
assert(length_array[index] <= ZOPFLI_MAX_MATCH);
assert(length_array[index] != 0);
index -= length_array[index];
if (index == 0) break;
}
/* Mirror result. */
for (index = 0; index < *pathsize / 2; index++) {
unsigned short temp = (*path)[index];
(*path)[index] = (*path)[*pathsize - index - 1];
(*path)[*pathsize - index - 1] = temp;
}
}
static void FollowPath(ZopfliBlockState* s,
const unsigned char* in, size_t instart, size_t inend,
unsigned short* path, size_t pathsize,
ZopfliLZ77Store* store, ZopfliHash *h) {
size_t i, j, pos = 0;
size_t windowstart = instart > ZOPFLI_WINDOW_SIZE
? instart - ZOPFLI_WINDOW_SIZE : 0;
size_t total_length_test = 0;
if (instart == inend) return;
ZopfliResetHash(ZOPFLI_WINDOW_SIZE, h);
ZopfliWarmupHash(in, windowstart, inend, h);
for (i = windowstart; i < instart; i++) {
ZopfliUpdateHash(in, i, inend, h);
}
pos = instart;
for (i = 0; i < pathsize; i++) {
unsigned short length = path[i];
unsigned short dummy_length;
unsigned short dist;
assert(pos < inend);
ZopfliUpdateHash(in, pos, inend, h);
/* Add to output. */
if (length >= ZOPFLI_MIN_MATCH) {
/* Get the distance by recalculating longest match. The found length
should match the length from the path. */
ZopfliFindLongestMatch(s, h, in, pos, inend, length, 0,
&dist, &dummy_length);
assert(!(dummy_length != length && length > 2 && dummy_length > 2));
ZopfliVerifyLenDist(in, inend, pos, dist, length);
ZopfliStoreLitLenDist(length, dist, pos, store);
total_length_test += length;
} else {
length = 1;
ZopfliStoreLitLenDist(in[pos], 0, pos, store);
total_length_test++;
}
assert(pos + length <= inend);
for (j = 1; j < length; j++) {
ZopfliUpdateHash(in, pos + j, inend, h);
}
pos += length;
}
}
/* Calculates the entropy of the statistics */
static void CalculateStatistics(SymbolStats* stats) {
ZopfliCalculateEntropy(stats->litlens, ZOPFLI_NUM_LL, stats->ll_symbols);
ZopfliCalculateEntropy(stats->dists, ZOPFLI_NUM_D, stats->d_symbols);
}
/* Appends the symbol statistics from the store. */
static void GetStatistics(const ZopfliLZ77Store* store, SymbolStats* stats) {
size_t i;
for (i = 0; i < store->size; i++) {
if (store->dists[i] == 0) {
stats->litlens[store->litlens[i]]++;
} else {
stats->litlens[ZopfliGetLengthSymbol(store->litlens[i])]++;
stats->dists[ZopfliGetDistSymbol(store->dists[i])]++;
}
}
stats->litlens[256] = 1; /* End symbol. */
CalculateStatistics(stats);
}
/*
Does a single run for ZopfliLZ77Optimal. For good compression, repeated runs
with updated statistics should be performed.
s: the block state
in: the input data array
instart: where to start
inend: where to stop (not inclusive)
path: pointer to dynamically allocated memory to store the path
pathsize: pointer to the size of the dynamic path array
length_array: array of size (inend - instart) used to store lengths
costmodel: function to use as the cost model for this squeeze run
costcontext: abstract context for the costmodel function
store: place to output the LZ77 data
returns the cost that was, according to the costmodel, needed to get to the end.
This is not the actual cost.
*/
static double LZ77OptimalRun(ZopfliBlockState* s,
const unsigned char* in, size_t instart, size_t inend,
unsigned short** path, size_t* pathsize,
unsigned short* length_array, CostModelFun* costmodel,
void* costcontext, ZopfliLZ77Store* store,
ZopfliHash* h, float* costs) {
double cost = GetBestLengths(s, in, instart, inend, costmodel,
costcontext, length_array, h, costs);
free(*path);
*path = 0;
*pathsize = 0;
TraceBackwards(inend - instart, length_array, path, pathsize);
FollowPath(s, in, instart, inend, *path, *pathsize, store, h);
assert(cost < ZOPFLI_LARGE_FLOAT);
return cost;
}
void ZopfliLZ77Optimal(ZopfliBlockState *s,
const unsigned char* in, size_t instart, size_t inend,
int numiterations,
ZopfliLZ77Store* store) {
/* Dist to get to here with smallest cost. */
size_t blocksize = inend - instart;
unsigned short* length_array =
(unsigned short*)malloc(sizeof(unsigned short) * (blocksize + 1));
unsigned short* path = 0;
size_t pathsize = 0;
ZopfliLZ77Store currentstore;
ZopfliHash hash;
ZopfliHash* h = &hash;
SymbolStats stats, beststats, laststats;
int i;
float* costs = (float*)malloc(sizeof(float) * (blocksize + 1));
double cost;
double bestcost = ZOPFLI_LARGE_FLOAT;
double lastcost = 0;
/* Try randomizing the costs a bit once the size stabilizes. */
RanState ran_state;
int lastrandomstep = -1;
if (!costs) exit(-1); /* Allocation failed. */
if (!length_array) exit(-1); /* Allocation failed. */
InitRanState(&ran_state);
InitStats(&stats);
ZopfliInitLZ77Store(in, ¤tstore);
ZopfliAllocHash(ZOPFLI_WINDOW_SIZE, h);
/* Do regular deflate, then loop multiple shortest path runs, each time using
the statistics of the previous run. */
/* Initial run. */
ZopfliLZ77Greedy(s, in, instart, inend, ¤tstore, h);
GetStatistics(¤tstore, &stats);
/* Repeat statistics with each time the cost model from the previous stat
run. */
for (i = 0; i < numiterations; i++) {
ZopfliCleanLZ77Store(¤tstore);
ZopfliInitLZ77Store(in, ¤tstore);
LZ77OptimalRun(s, in, instart, inend, &path, &pathsize,
length_array, GetCostStat, (void*)&stats,
¤tstore, h, costs);
cost = ZopfliCalculateBlockSize(¤tstore, 0, currentstore.size, 2);
if (s->options->verbose_more || (s->options->verbose && cost < bestcost)) {
fprintf(stderr, "Iteration %d: %d bit\n", i, (int) cost);
}
if (cost < bestcost) {
/* Copy to the output store. */
ZopfliCopyLZ77Store(¤tstore, store);
CopyStats(&stats, &beststats);
bestcost = cost;
}
CopyStats(&stats, &laststats);
ClearStatFreqs(&stats);
GetStatistics(¤tstore, &stats);
if (lastrandomstep != -1) {
/* This makes it converge slower but better. Do it only once the
randomness kicks in so that if the user does few iterations, it gives a
better result sooner. */
AddWeighedStatFreqs(&stats, 1.0, &laststats, 0.5, &stats);
CalculateStatistics(&stats);
}
if (i > 5 && cost == lastcost) {
CopyStats(&beststats, &stats);
RandomizeStatFreqs(&ran_state, &stats);
CalculateStatistics(&stats);
lastrandomstep = i;
}
lastcost = cost;
}
free(length_array);
free(path);
free(costs);
ZopfliCleanLZ77Store(¤tstore);
ZopfliCleanHash(h);
}
void ZopfliLZ77OptimalFixed(ZopfliBlockState *s,
const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store)
{
/* Dist to get to here with smallest cost. */
size_t blocksize = inend - instart;
unsigned short* length_array =
(unsigned short*)malloc(sizeof(unsigned short) * (blocksize + 1));
unsigned short* path = 0;
size_t pathsize = 0;
ZopfliHash hash;
ZopfliHash* h = &hash;
float* costs = (float*)malloc(sizeof(float) * (blocksize + 1));
if (!costs) exit(-1); /* Allocation failed. */
if (!length_array) exit(-1); /* Allocation failed. */
ZopfliAllocHash(ZOPFLI_WINDOW_SIZE, h);
s->blockstart = instart;
s->blockend = inend;
/* Shortest path for fixed tree This one should give the shortest possible
result for fixed tree, no repeated runs are needed since the tree is known. */
LZ77OptimalRun(s, in, instart, inend, &path, &pathsize,
length_array, GetCostFixed, 0, store, h, costs);
free(length_array);
free(path);
free(costs);
ZopfliCleanHash(h);
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQZopfli/zopfli/squeeze.c
|
c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 5,535
|
```c
/*
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#include "zlib_container.h"
#include "util.h"
#include <stdio.h>
#include "deflate.h"
/* Calculates the adler32 checksum of the data */
static unsigned adler32(const unsigned char* data, size_t size)
{
static const unsigned sums_overflow = 5550;
unsigned s1 = 1;
unsigned s2 = 1 >> 16;
while (size > 0) {
size_t amount = size > sums_overflow ? sums_overflow : size;
size -= amount;
while (amount > 0) {
s1 += (*data++);
s2 += s1;
amount--;
}
s1 %= 65521;
s2 %= 65521;
}
return (s2 << 16) | s1;
}
void ZopfliZlibCompress(const ZopfliOptions* options,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize) {
unsigned char bitpointer = 0;
unsigned checksum = adler32(in, (unsigned)insize);
unsigned cmf = 120; /* CM 8, CINFO 7. See zlib spec.*/
unsigned flevel = 3;
unsigned fdict = 0;
unsigned cmfflg = 256 * cmf + fdict * 32 + flevel * 64;
unsigned fcheck = 31 - cmfflg % 31;
cmfflg += fcheck;
ZOPFLI_APPEND_DATA(cmfflg / 256, out, outsize);
ZOPFLI_APPEND_DATA(cmfflg % 256, out, outsize);
ZopfliDeflate(options, 2 /* dynamic block */, 1 /* final */,
in, insize, &bitpointer, out, outsize);
ZOPFLI_APPEND_DATA((checksum >> 24) % 256, out, outsize);
ZOPFLI_APPEND_DATA((checksum >> 16) % 256, out, outsize);
ZOPFLI_APPEND_DATA((checksum >> 8) % 256, out, outsize);
ZOPFLI_APPEND_DATA(checksum % 256, out, outsize);
if (options->verbose) {
fprintf(stderr,
"Original Size: %d, Zlib: %d, Compression: %f%% Removed\n",
(int)insize, (int)*outsize,
100.0 * (double)(insize - *outsize) / (double)insize);
}
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQZopfli/zopfli/zlib_container.c
|
c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 626
|
```c
/*
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#include "util.h"
#include "zopfli.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
void ZopfliInitOptions(ZopfliOptions* options) {
options->verbose = 0;
options->verbose_more = 0;
options->numiterations = 15;
options->blocksplitting = 1;
options->blocksplittinglast = 0;
options->blocksplittingmax = 15;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQZopfli/zopfli/util.c
|
c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 177
|
```c
#include "symbols.h"
int ZopfliGetDistExtraBits(int dist) {
#ifdef ZOPFLI_HAS_BUILTIN_CLZ
if (dist < 5) return 0;
return (31 ^ __builtin_clz(dist - 1)) - 1; /* log2(dist - 1) - 1 */
#else
if (dist < 5) return 0;
else if (dist < 9) return 1;
else if (dist < 17) return 2;
else if (dist < 33) return 3;
else if (dist < 65) return 4;
else if (dist < 129) return 5;
else if (dist < 257) return 6;
else if (dist < 513) return 7;
else if (dist < 1025) return 8;
else if (dist < 2049) return 9;
else if (dist < 4097) return 10;
else if (dist < 8193) return 11;
else if (dist < 16385) return 12;
else return 13;
#endif
}
/* Gets value of the extra bits for the given dist, cfr. the DEFLATE spec. */
int ZopfliGetDistExtraBitsValue(int dist) {
#ifdef ZOPFLI_HAS_BUILTIN_CLZ
if (dist < 5) {
return 0;
} else {
int l = 31 ^ __builtin_clz(dist - 1); /* log2(dist - 1) */
return (dist - (1 + (1 << l))) & ((1 << (l - 1)) - 1);
}
#else
if (dist < 5) return 0;
else if (dist < 9) return (dist - 5) & 1;
else if (dist < 17) return (dist - 9) & 3;
else if (dist < 33) return (dist - 17) & 7;
else if (dist < 65) return (dist - 33) & 15;
else if (dist < 129) return (dist - 65) & 31;
else if (dist < 257) return (dist - 129) & 63;
else if (dist < 513) return (dist - 257) & 127;
else if (dist < 1025) return (dist - 513) & 255;
else if (dist < 2049) return (dist - 1025) & 511;
else if (dist < 4097) return (dist - 2049) & 1023;
else if (dist < 8193) return (dist - 4097) & 2047;
else if (dist < 16385) return (dist - 8193) & 4095;
else return (dist - 16385) & 8191;
#endif
}
/* Gets the symbol for the given dist, cfr. the DEFLATE spec. */
int ZopfliGetDistSymbol(int dist) {
#ifdef ZOPFLI_HAS_BUILTIN_CLZ
if (dist < 5) {
return dist - 1;
} else {
int l = (31 ^ __builtin_clz(dist - 1)); /* log2(dist - 1) */
int r = ((dist - 1) >> (l - 1)) & 1;
return l * 2 + r;
}
#else
if (dist < 193) {
if (dist < 13) { /* dist 0..13. */
if (dist < 5) return dist - 1;
else if (dist < 7) return 4;
else if (dist < 9) return 5;
else return 6;
} else { /* dist 13..193. */
if (dist < 17) return 7;
else if (dist < 25) return 8;
else if (dist < 33) return 9;
else if (dist < 49) return 10;
else if (dist < 65) return 11;
else if (dist < 97) return 12;
else if (dist < 129) return 13;
else return 14;
}
} else {
if (dist < 2049) { /* dist 193..2049. */
if (dist < 257) return 15;
else if (dist < 385) return 16;
else if (dist < 513) return 17;
else if (dist < 769) return 18;
else if (dist < 1025) return 19;
else if (dist < 1537) return 20;
else return 21;
} else { /* dist 2049..32768. */
if (dist < 3073) return 22;
else if (dist < 4097) return 23;
else if (dist < 6145) return 24;
else if (dist < 8193) return 25;
else if (dist < 12289) return 26;
else if (dist < 16385) return 27;
else if (dist < 24577) return 28;
else return 29;
}
}
#endif
}
/* Gets the amount of extra bits for the given length, cfr. the DEFLATE spec. */
int ZopfliGetLengthExtraBits(int l) {
static const int table[259] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0
};
return table[l];
}
/* Gets value of the extra bits for the given length, cfr. the DEFLATE spec. */
int ZopfliGetLengthExtraBitsValue(int l) {
static const int table[259] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 3, 0,
1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5,
6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6,
7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2,
3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6,
7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 0
};
return table[l];
}
/*
Gets the symbol for the given length, cfr. the DEFLATE spec.
Returns the symbol in the range [257-285] (inclusive)
*/
int ZopfliGetLengthSymbol(int l) {
static const int table[259] = {
0, 0, 0, 257, 258, 259, 260, 261, 262, 263, 264,
265, 265, 266, 266, 267, 267, 268, 268,
269, 269, 269, 269, 270, 270, 270, 270,
271, 271, 271, 271, 272, 272, 272, 272,
273, 273, 273, 273, 273, 273, 273, 273,
274, 274, 274, 274, 274, 274, 274, 274,
275, 275, 275, 275, 275, 275, 275, 275,
276, 276, 276, 276, 276, 276, 276, 276,
277, 277, 277, 277, 277, 277, 277, 277,
277, 277, 277, 277, 277, 277, 277, 277,
278, 278, 278, 278, 278, 278, 278, 278,
278, 278, 278, 278, 278, 278, 278, 278,
279, 279, 279, 279, 279, 279, 279, 279,
279, 279, 279, 279, 279, 279, 279, 279,
280, 280, 280, 280, 280, 280, 280, 280,
280, 280, 280, 280, 280, 280, 280, 280,
281, 281, 281, 281, 281, 281, 281, 281,
281, 281, 281, 281, 281, 281, 281, 281,
281, 281, 281, 281, 281, 281, 281, 281,
281, 281, 281, 281, 281, 281, 281, 281,
282, 282, 282, 282, 282, 282, 282, 282,
282, 282, 282, 282, 282, 282, 282, 282,
282, 282, 282, 282, 282, 282, 282, 282,
282, 282, 282, 282, 282, 282, 282, 282,
283, 283, 283, 283, 283, 283, 283, 283,
283, 283, 283, 283, 283, 283, 283, 283,
283, 283, 283, 283, 283, 283, 283, 283,
283, 283, 283, 283, 283, 283, 283, 283,
284, 284, 284, 284, 284, 284, 284, 284,
284, 284, 284, 284, 284, 284, 284, 284,
284, 284, 284, 284, 284, 284, 284, 284,
284, 284, 284, 284, 284, 284, 284, 285
};
return table[l];
}
/* Gets the amount of extra bits for the given length symbol. */
int ZopfliGetLengthSymbolExtraBits(int s) {
static const int table[29] = {
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0
};
return table[s - 257];
}
/* Gets the amount of extra bits for the given distance symbol. */
int ZopfliGetDistSymbolExtraBits(int s) {
static const int table[30] = {
0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8,
9, 9, 10, 10, 11, 11, 12, 12, 13, 13
};
return table[s];
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQZopfli/zopfli/symbols.c
|
c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 4,035
|
```c
/*
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#include "gzip_container.h"
#include "util.h"
#include <stdio.h>
#include "deflate.h"
/* CRC polynomial: 0xedb88320 */
static const unsigned long crc32_table[256] = {
0u, 1996959894u, 3993919788u, 2567524794u, 124634137u, 1886057615u,
3915621685u, 2657392035u, 249268274u, 2044508324u, 3772115230u, 2547177864u,
162941995u, 2125561021u, 3887607047u, 2428444049u, 498536548u, 1789927666u,
4089016648u, 2227061214u, 450548861u, 1843258603u, 4107580753u, 2211677639u,
325883990u, 1684777152u, 4251122042u, 2321926636u, 335633487u, 1661365465u,
4195302755u, 2366115317u, 997073096u, 1281953886u, 3579855332u, 2724688242u,
1006888145u, 1258607687u, 3524101629u, 2768942443u, 901097722u, 1119000684u,
3686517206u, 2898065728u, 853044451u, 1172266101u, 3705015759u, 2882616665u,
651767980u, 1373503546u, 3369554304u, 3218104598u, 565507253u, 1454621731u,
3485111705u, 3099436303u, 671266974u, 1594198024u, 3322730930u, 2970347812u,
795835527u, 1483230225u, 3244367275u, 3060149565u, 1994146192u, 31158534u,
2563907772u, 4023717930u, 1907459465u, 112637215u, 2680153253u, 3904427059u,
2013776290u, 251722036u, 2517215374u, 3775830040u, 2137656763u, 141376813u,
2439277719u, 3865271297u, 1802195444u, 476864866u, 2238001368u, 4066508878u,
1812370925u, 453092731u, 2181625025u, 4111451223u, 1706088902u, 314042704u,
2344532202u, 4240017532u, 1658658271u, 366619977u, 2362670323u, 4224994405u,
1303535960u, 984961486u, 2747007092u, 3569037538u, 1256170817u, 1037604311u,
2765210733u, 3554079995u, 1131014506u, 879679996u, 2909243462u, 3663771856u,
1141124467u, 855842277u, 2852801631u, 3708648649u, 1342533948u, 654459306u,
3188396048u, 3373015174u, 1466479909u, 544179635u, 3110523913u, 3462522015u,
1591671054u, 702138776u, 2966460450u, 3352799412u, 1504918807u, 783551873u,
3082640443u, 3233442989u, 3988292384u, 2596254646u, 62317068u, 1957810842u,
3939845945u, 2647816111u, 81470997u, 1943803523u, 3814918930u, 2489596804u,
225274430u, 2053790376u, 3826175755u, 2466906013u, 167816743u, 2097651377u,
4027552580u, 2265490386u, 503444072u, 1762050814u, 4150417245u, 2154129355u,
426522225u, 1852507879u, 4275313526u, 2312317920u, 282753626u, 1742555852u,
4189708143u, 2394877945u, 397917763u, 1622183637u, 3604390888u, 2714866558u,
953729732u, 1340076626u, 3518719985u, 2797360999u, 1068828381u, 1219638859u,
3624741850u, 2936675148u, 906185462u, 1090812512u, 3747672003u, 2825379669u,
829329135u, 1181335161u, 3412177804u, 3160834842u, 628085408u, 1382605366u,
3423369109u, 3138078467u, 570562233u, 1426400815u, 3317316542u, 2998733608u,
733239954u, 1555261956u, 3268935591u, 3050360625u, 752459403u, 1541320221u,
2607071920u, 3965973030u, 1969922972u, 40735498u, 2617837225u, 3943577151u,
1913087877u, 83908371u, 2512341634u, 3803740692u, 2075208622u, 213261112u,
2463272603u, 3855990285u, 2094854071u, 198958881u, 2262029012u, 4057260610u,
1759359992u, 534414190u, 2176718541u, 4139329115u, 1873836001u, 414664567u,
2282248934u, 4279200368u, 1711684554u, 285281116u, 2405801727u, 4167216745u,
1634467795u, 376229701u, 2685067896u, 3608007406u, 1308918612u, 956543938u,
2808555105u, 3495958263u, 1231636301u, 1047427035u, 2932959818u, 3654703836u,
1088359270u, 936918000u, 2847714899u, 3736837829u, 1202900863u, 817233897u,
3183342108u, 3401237130u, 1404277552u, 615818150u, 3134207493u, 3453421203u,
1423857449u, 601450431u, 3009837614u, 3294710456u, 1567103746u, 711928724u,
3020668471u, 3272380065u, 1510334235u, 755167117u
};
/* Returns the CRC32 */
static unsigned long CRC(const unsigned char* data, size_t size) {
unsigned long result = 0xffffffffu;
for (; size > 0; size--) {
result = crc32_table[(result ^ *(data++)) & 0xff] ^ (result >> 8);
}
return result ^ 0xffffffffu;
}
/* Compresses the data according to the gzip specification, RFC 1952. */
void ZopfliGzipCompress(const ZopfliOptions* options,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize) {
unsigned long crcvalue = CRC(in, insize);
unsigned char bp = 0;
ZOPFLI_APPEND_DATA(31, out, outsize); /* ID1 */
ZOPFLI_APPEND_DATA(139, out, outsize); /* ID2 */
ZOPFLI_APPEND_DATA(8, out, outsize); /* CM */
ZOPFLI_APPEND_DATA(0, out, outsize); /* FLG */
/* MTIME */
ZOPFLI_APPEND_DATA(0, out, outsize);
ZOPFLI_APPEND_DATA(0, out, outsize);
ZOPFLI_APPEND_DATA(0, out, outsize);
ZOPFLI_APPEND_DATA(0, out, outsize);
ZOPFLI_APPEND_DATA(2, out, outsize); /* XFL, 2 indicates best compression. */
ZOPFLI_APPEND_DATA(3, out, outsize); /* OS follows Unix conventions. */
ZopfliDeflate(options, 2 /* Dynamic block */, 1,
in, insize, &bp, out, outsize);
/* CRC */
ZOPFLI_APPEND_DATA(crcvalue % 256, out, outsize);
ZOPFLI_APPEND_DATA((crcvalue >> 8) % 256, out, outsize);
ZOPFLI_APPEND_DATA((crcvalue >> 16) % 256, out, outsize);
ZOPFLI_APPEND_DATA((crcvalue >> 24) % 256, out, outsize);
/* ISIZE */
ZOPFLI_APPEND_DATA(insize % 256, out, outsize);
ZOPFLI_APPEND_DATA((insize >> 8) % 256, out, outsize);
ZOPFLI_APPEND_DATA((insize >> 16) % 256, out, outsize);
ZOPFLI_APPEND_DATA((insize >> 24) % 256, out, outsize);
if (options->verbose) {
fprintf(stderr,
"Original Size: %d, Gzip: %d, Compression: %f%% Removed\n",
(int)insize, (int)*outsize,
100.0 * (double)(insize - *outsize) / (double)insize);
}
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQZopfli/zopfli/gzip_container.c
|
c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 2,586
|
```c
/*
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
/*
Bounded package merge algorithm, based on the paper
"A Fast and Space-Economical Algorithm for Length-Limited Coding
Jyrki Katajainen, Alistair Moffat, Andrew Turpin".
*/
#include "katajainen.h"
#include <assert.h>
#include <stdlib.h>
#include <limits.h>
typedef struct Node Node;
/*
Nodes forming chains. Also used to represent leaves.
*/
struct Node {
size_t weight; /* Total weight (symbol count) of this chain. */
Node* tail; /* Previous node(s) of this chain, or 0 if none. */
int count; /* Leaf symbol index, or number of leaves before this chain. */
};
/*
Memory pool for nodes.
*/
typedef struct NodePool {
Node* next; /* Pointer to a free node in the pool. */
} NodePool;
/*
Initializes a chain node with the given values and marks it as in use.
*/
static void InitNode(size_t weight, int count, Node* tail, Node* node) {
node->weight = weight;
node->count = count;
node->tail = tail;
}
/*
Performs a Boundary Package-Merge step. Puts a new chain in the given list. The
new chain is, depending on the weights, a leaf or a combination of two chains
from the previous list.
lists: The lists of chains.
maxbits: Number of lists.
leaves: The leaves, one per symbol.
numsymbols: Number of leaves.
pool: the node memory pool.
index: The index of the list in which a new chain or leaf is required.
*/
static void BoundaryPM(Node* (*lists)[2], Node* leaves, int numsymbols,
NodePool* pool, int index) {
Node* newchain;
Node* oldchain;
int lastcount = lists[index][1]->count; /* Count of last chain of list. */
if (index == 0 && lastcount >= numsymbols) return;
newchain = pool->next++;
oldchain = lists[index][1];
/* These are set up before the recursive calls below, so that there is a list
pointing to the new node, to let the garbage collection know it's in use. */
lists[index][0] = oldchain;
lists[index][1] = newchain;
if (index == 0) {
/* New leaf node in list 0. */
InitNode(leaves[lastcount].weight, lastcount + 1, 0, newchain);
} else {
size_t sum = lists[index - 1][0]->weight + lists[index - 1][1]->weight;
if (lastcount < numsymbols && sum > leaves[lastcount].weight) {
/* New leaf inserted in list, so count is incremented. */
InitNode(leaves[lastcount].weight, lastcount + 1, oldchain->tail,
newchain);
} else {
InitNode(sum, lastcount, lists[index - 1][1], newchain);
/* Two lookahead chains of previous list used up, create new ones. */
BoundaryPM(lists, leaves, numsymbols, pool, index - 1);
BoundaryPM(lists, leaves, numsymbols, pool, index - 1);
}
}
}
static void BoundaryPMFinal(Node* (*lists)[2],
Node* leaves, int numsymbols, NodePool* pool, int index) {
int lastcount = lists[index][1]->count; /* Count of last chain of list. */
size_t sum = lists[index - 1][0]->weight + lists[index - 1][1]->weight;
if (lastcount < numsymbols && sum > leaves[lastcount].weight) {
Node* newchain = pool->next;
Node* oldchain = lists[index][1]->tail;
lists[index][1] = newchain;
newchain->count = lastcount + 1;
newchain->tail = oldchain;
} else {
lists[index][1]->tail = lists[index - 1][1];
}
}
/*
Initializes each list with as lookahead chains the two leaves with lowest
weights.
*/
static void InitLists(
NodePool* pool, const Node* leaves, int maxbits, Node* (*lists)[2]) {
int i;
Node* node0 = pool->next++;
Node* node1 = pool->next++;
InitNode(leaves[0].weight, 1, 0, node0);
InitNode(leaves[1].weight, 2, 0, node1);
for (i = 0; i < maxbits; i++) {
lists[i][0] = node0;
lists[i][1] = node1;
}
}
/*
Converts result of boundary package-merge to the bitlengths. The result in the
last chain of the last list contains the amount of active leaves in each list.
chain: Chain to extract the bit length from (last chain from last list).
*/
static void ExtractBitLengths(Node* chain, Node* leaves, unsigned* bitlengths) {
int counts[16] = {0};
unsigned end = 16;
unsigned ptr = 15;
unsigned value = 1;
Node* node;
int val;
for (node = chain; node; node = node->tail) {
counts[--end] = node->count;
}
val = counts[15];
while (ptr >= end) {
for (; val > counts[ptr - 1]; val--) {
bitlengths[leaves[val - 1].count] = value;
}
ptr--;
value++;
}
}
/*
Comparator for sorting the leaves. Has the function signature for qsort.
*/
static int LeafComparator(const void* a, const void* b) {
return ((const Node*)a)->weight - ((const Node*)b)->weight;
}
int ZopfliLengthLimitedCodeLengths(
const size_t* frequencies, int n, int maxbits, unsigned* bitlengths) {
NodePool pool;
int i;
int numsymbols = 0; /* Amount of symbols with frequency > 0. */
int numBoundaryPMRuns;
Node* nodes;
/* Array of lists of chains. Each list requires only two lookahead chains at
a time, so each list is a array of two Node*'s. */
Node* (*lists)[2];
/* One leaf per symbol. Only numsymbols leaves will be used. */
Node* leaves = (Node*)malloc(n * sizeof(*leaves));
/* Initialize all bitlengths at 0. */
for (i = 0; i < n; i++) {
bitlengths[i] = 0;
}
/* Count used symbols and place them in the leaves. */
for (i = 0; i < n; i++) {
if (frequencies[i]) {
leaves[numsymbols].weight = frequencies[i];
leaves[numsymbols].count = i; /* Index of symbol this leaf represents. */
numsymbols++;
}
}
/* Check special cases and error conditions. */
if ((1 << maxbits) < numsymbols) {
free(leaves);
return 1; /* Error, too few maxbits to represent symbols. */
}
if (numsymbols == 0) {
free(leaves);
return 0; /* No symbols at all. OK. */
}
if (numsymbols == 1) {
bitlengths[leaves[0].count] = 1;
free(leaves);
return 0; /* Only one symbol, give it bitlength 1, not 0. OK. */
}
if (numsymbols == 2) {
bitlengths[leaves[0].count]++;
bitlengths[leaves[1].count]++;
free(leaves);
return 0;
}
/* Sort the leaves from lightest to heaviest. Add count into the same
variable for stable sorting. */
for (i = 0; i < numsymbols; i++) {
if (leaves[i].weight >=
((size_t)1 << (sizeof(leaves[0].weight) * CHAR_BIT - 9))) {
free(leaves);
return 1; /* Error, we need 9 bits for the count. */
}
leaves[i].weight = (leaves[i].weight << 9) | leaves[i].count;
}
qsort(leaves, numsymbols, sizeof(Node), LeafComparator);
for (i = 0; i < numsymbols; i++) {
leaves[i].weight >>= 9;
}
if (numsymbols - 1 < maxbits) {
maxbits = numsymbols - 1;
}
/* Initialize node memory pool. */
nodes = (Node*)malloc(maxbits * 2 * numsymbols * sizeof(Node));
pool.next = nodes;
lists = (Node* (*)[2])malloc(maxbits * sizeof(*lists));
InitLists(&pool, leaves, maxbits, lists);
/* In the last list, 2 * numsymbols - 2 active chains need to be created. Two
are already created in the initialization. Each BoundaryPM run creates one. */
numBoundaryPMRuns = 2 * numsymbols - 4;
for (i = 0; i < numBoundaryPMRuns - 1; i++) {
BoundaryPM(lists, leaves, numsymbols, &pool, maxbits - 1);
}
BoundaryPMFinal(lists, leaves, numsymbols, &pool, maxbits - 1);
ExtractBitLengths(lists[maxbits - 1][1], leaves, bitlengths);
free(lists);
free(leaves);
free(nodes);
return 0; /* OK. */
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQZopfli/zopfli/katajainen.c
|
c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 2,210
|
```c
/*
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#include "tree.h"
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include "katajainen.h"
#include "util.h"
void ZopfliLengthsToSymbols(const unsigned* lengths, size_t n, unsigned maxbits,
unsigned* symbols) {
size_t* bl_count = (size_t*)malloc(sizeof(size_t) * (maxbits + 1));
size_t* next_code = (size_t*)malloc(sizeof(size_t) * (maxbits + 1));
unsigned bits, i;
unsigned code;
for (i = 0; i < n; i++) {
symbols[i] = 0;
}
/* 1) Count the number of codes for each code length. Let bl_count[N] be the
number of codes of length N, N >= 1. */
for (bits = 0; bits <= maxbits; bits++) {
bl_count[bits] = 0;
}
for (i = 0; i < n; i++) {
assert(lengths[i] <= maxbits);
bl_count[lengths[i]]++;
}
/* 2) Find the numerical value of the smallest code for each code length. */
code = 0;
bl_count[0] = 0;
for (bits = 1; bits <= maxbits; bits++) {
code = (code + bl_count[bits-1]) << 1;
next_code[bits] = code;
}
/* 3) Assign numerical values to all codes, using consecutive values for all
codes of the same length with the base values determined at step 2. */
for (i = 0; i < n; i++) {
unsigned len = lengths[i];
if (len != 0) {
symbols[i] = next_code[len];
next_code[len]++;
}
}
free(bl_count);
free(next_code);
}
void ZopfliCalculateEntropy(const size_t* count, size_t n, double* bitlengths) {
static const double kInvLog2 = 1.4426950408889; /* 1.0 / log(2.0) */
unsigned sum = 0;
unsigned i;
double log2sum;
for (i = 0; i < n; ++i) {
sum += count[i];
}
log2sum = (sum == 0 ? log(n) : log(sum)) * kInvLog2;
for (i = 0; i < n; ++i) {
/* When the count of the symbol is 0, but its cost is requested anyway, it
means the symbol will appear at least once anyway, so give it the cost as if
its count is 1.*/
if (count[i] == 0) bitlengths[i] = log2sum;
else bitlengths[i] = log2sum - log(count[i]) * kInvLog2;
/* Depending on compiler and architecture, the above subtraction of two
floating point numbers may give a negative result very close to zero
instead of zero (e.g. -5.973954e-17 with gcc 4.1.2 on Ubuntu 11.4). Clamp
it to zero. These floating point imprecisions do not affect the cost model
significantly so this is ok. */
if (bitlengths[i] < 0 && bitlengths[i] > -1e-5) bitlengths[i] = 0;
assert(bitlengths[i] >= 0);
}
}
void ZopfliCalculateBitLengths(const size_t* count, size_t n, int maxbits,
unsigned* bitlengths) {
int error = ZopfliLengthLimitedCodeLengths(count, n, maxbits, bitlengths);
(void) error;
assert(!error);
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQZopfli/zopfli/tree.c
|
c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 925
|
```c
/*
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#include "hash.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#define HASH_SHIFT 5
#define HASH_MASK 32767
void ZopfliAllocHash(size_t window_size, ZopfliHash* h) {
h->head = (int*)malloc(sizeof(*h->head) * 65536);
h->prev = (unsigned short*)malloc(sizeof(*h->prev) * window_size);
h->hashval = (int*)malloc(sizeof(*h->hashval) * window_size);
#ifdef ZOPFLI_HASH_SAME
h->same = (unsigned short*)malloc(sizeof(*h->same) * window_size);
#endif
#ifdef ZOPFLI_HASH_SAME_HASH
h->head2 = (int*)malloc(sizeof(*h->head2) * 65536);
h->prev2 = (unsigned short*)malloc(sizeof(*h->prev2) * window_size);
h->hashval2 = (int*)malloc(sizeof(*h->hashval2) * window_size);
#endif
}
void ZopfliResetHash(size_t window_size, ZopfliHash* h) {
size_t i;
h->val = 0;
for (i = 0; i < 65536; i++) {
h->head[i] = -1; /* -1 indicates no head so far. */
}
for (i = 0; i < window_size; i++) {
h->prev[i] = i; /* If prev[j] == j, then prev[j] is uninitialized. */
h->hashval[i] = -1;
}
#ifdef ZOPFLI_HASH_SAME
for (i = 0; i < window_size; i++) {
h->same[i] = 0;
}
#endif
#ifdef ZOPFLI_HASH_SAME_HASH
h->val2 = 0;
for (i = 0; i < 65536; i++) {
h->head2[i] = -1;
}
for (i = 0; i < window_size; i++) {
h->prev2[i] = i;
h->hashval2[i] = -1;
}
#endif
}
void ZopfliCleanHash(ZopfliHash* h) {
free(h->head);
free(h->prev);
free(h->hashval);
#ifdef ZOPFLI_HASH_SAME_HASH
free(h->head2);
free(h->prev2);
free(h->hashval2);
#endif
#ifdef ZOPFLI_HASH_SAME
free(h->same);
#endif
}
/*
Update the sliding hash value with the given byte. All calls to this function
must be made on consecutive input characters. Since the hash value exists out
of multiple input bytes, a few warmups with this function are needed initially.
*/
static void UpdateHashValue(ZopfliHash* h, unsigned char c) {
h->val = (((h->val) << HASH_SHIFT) ^ (c)) & HASH_MASK;
}
void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h) {
unsigned short hpos = pos & ZOPFLI_WINDOW_MASK;
#ifdef ZOPFLI_HASH_SAME
size_t amount = 0;
#endif
UpdateHashValue(h, pos + ZOPFLI_MIN_MATCH <= end ?
array[pos + ZOPFLI_MIN_MATCH - 1] : 0);
h->hashval[hpos] = h->val;
if (h->head[h->val] != -1 && h->hashval[h->head[h->val]] == h->val) {
h->prev[hpos] = h->head[h->val];
}
else h->prev[hpos] = hpos;
h->head[h->val] = hpos;
#ifdef ZOPFLI_HASH_SAME
/* Update "same". */
if (h->same[(pos - 1) & ZOPFLI_WINDOW_MASK] > 1) {
amount = h->same[(pos - 1) & ZOPFLI_WINDOW_MASK] - 1;
}
while (pos + amount + 1 < end &&
array[pos] == array[pos + amount + 1] && amount < (unsigned short)(-1)) {
amount++;
}
h->same[hpos] = amount;
#endif
#ifdef ZOPFLI_HASH_SAME_HASH
h->val2 = ((h->same[hpos] - ZOPFLI_MIN_MATCH) & 255) ^ h->val;
h->hashval2[hpos] = h->val2;
if (h->head2[h->val2] != -1 && h->hashval2[h->head2[h->val2]] == h->val2) {
h->prev2[hpos] = h->head2[h->val2];
}
else h->prev2[hpos] = hpos;
h->head2[h->val2] = hpos;
#endif
}
void ZopfliWarmupHash(const unsigned char* array, size_t pos, size_t end,
ZopfliHash* h) {
UpdateHashValue(h, array[pos + 0]);
if (pos + 1 < end) UpdateHashValue(h, array[pos + 1]);
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQZopfli/zopfli/hash.c
|
c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 1,250
|
```c
/*
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#include "blocksplitter.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include "deflate.h"
#include "squeeze.h"
#include "tree.h"
#include "util.h"
/*
The "f" for the FindMinimum function below.
i: the current parameter of f(i)
context: for your implementation
*/
typedef double FindMinimumFun(size_t i, void* context);
/*
Finds minimum of function f(i) where is is of type size_t, f(i) is of type
double, i is in range start-end (excluding end).
Outputs the minimum value in *smallest and returns the index of this value.
*/
static size_t FindMinimum(FindMinimumFun f, void* context,
size_t start, size_t end, double* smallest) {
if (end - start < 1024) {
double best = ZOPFLI_LARGE_FLOAT;
size_t result = start;
size_t i;
for (i = start; i < end; i++) {
double v = f(i, context);
if (v < best) {
best = v;
result = i;
}
}
*smallest = best;
return result;
} else {
/* Try to find minimum faster by recursively checking multiple points. */
#define NUM 9 /* Good value: 9. */
size_t i;
size_t p[NUM];
double vp[NUM];
size_t besti;
double best;
double lastbest = ZOPFLI_LARGE_FLOAT;
size_t pos = start;
for (;;) {
if (end - start <= NUM) break;
for (i = 0; i < NUM; i++) {
p[i] = start + (i + 1) * ((end - start) / (NUM + 1));
vp[i] = f(p[i], context);
}
besti = 0;
best = vp[0];
for (i = 1; i < NUM; i++) {
if (vp[i] < best) {
best = vp[i];
besti = i;
}
}
if (best > lastbest) break;
start = besti == 0 ? start : p[besti - 1];
end = besti == NUM - 1 ? end : p[besti + 1];
pos = p[besti];
lastbest = best;
}
*smallest = lastbest;
return pos;
#undef NUM
}
}
/*
Returns estimated cost of a block in bits. It includes the size to encode the
tree and the size to encode all literal, length and distance symbols and their
extra bits.
litlens: lz77 lit/lengths
dists: ll77 distances
lstart: start of block
lend: end of block (not inclusive)
*/
static double EstimateCost(const ZopfliLZ77Store* lz77,
size_t lstart, size_t lend) {
return ZopfliCalculateBlockSizeAutoType(lz77, lstart, lend);
}
typedef struct SplitCostContext {
const ZopfliLZ77Store* lz77;
size_t start;
size_t end;
} SplitCostContext;
/*
Gets the cost which is the sum of the cost of the left and the right section
of the data.
type: FindMinimumFun
*/
static double SplitCost(size_t i, void* context) {
SplitCostContext* c = (SplitCostContext*)context;
return EstimateCost(c->lz77, c->start, i) + EstimateCost(c->lz77, i, c->end);
}
static void AddSorted(size_t value, size_t** out, size_t* outsize) {
size_t i;
ZOPFLI_APPEND_DATA(value, out, outsize);
for (i = 0; i + 1 < *outsize; i++) {
if ((*out)[i] > value) {
size_t j;
for (j = *outsize - 1; j > i; j--) {
(*out)[j] = (*out)[j - 1];
}
(*out)[i] = value;
break;
}
}
}
/*
Prints the block split points as decimal and hex values in the terminal.
*/
static void PrintBlockSplitPoints(const ZopfliLZ77Store* lz77,
const size_t* lz77splitpoints,
size_t nlz77points) {
size_t* splitpoints = 0;
size_t npoints = 0;
size_t i;
/* The input is given as lz77 indices, but we want to see the uncompressed
index values. */
size_t pos = 0;
if (nlz77points > 0) {
for (i = 0; i < lz77->size; i++) {
size_t length = lz77->dists[i] == 0 ? 1 : lz77->litlens[i];
if (lz77splitpoints[npoints] == i) {
ZOPFLI_APPEND_DATA(pos, &splitpoints, &npoints);
if (npoints == nlz77points) break;
}
pos += length;
}
}
assert(npoints == nlz77points);
fprintf(stderr, "block split points: ");
for (i = 0; i < npoints; i++) {
fprintf(stderr, "%d ", (int)splitpoints[i]);
}
fprintf(stderr, "(hex:");
for (i = 0; i < npoints; i++) {
fprintf(stderr, " %x", (int)splitpoints[i]);
}
fprintf(stderr, ")\n");
free(splitpoints);
}
/*
Finds next block to try to split, the largest of the available ones.
The largest is chosen to make sure that if only a limited amount of blocks is
requested, their sizes are spread evenly.
lz77size: the size of the LL77 data, which is the size of the done array here.
done: array indicating which blocks starting at that position are no longer
splittable (splitting them increases rather than decreases cost).
splitpoints: the splitpoints found so far.
npoints: the amount of splitpoints found so far.
lstart: output variable, giving start of block.
lend: output variable, giving end of block.
returns 1 if a block was found, 0 if no block found (all are done).
*/
static int FindLargestSplittableBlock(
size_t lz77size, const unsigned char* done,
const size_t* splitpoints, size_t npoints,
size_t* lstart, size_t* lend) {
size_t longest = 0;
int found = 0;
size_t i;
for (i = 0; i <= npoints; i++) {
size_t start = i == 0 ? 0 : splitpoints[i - 1];
size_t end = i == npoints ? lz77size - 1 : splitpoints[i];
if (!done[start] && end - start > longest) {
*lstart = start;
*lend = end;
found = 1;
longest = end - start;
}
}
return found;
}
void ZopfliBlockSplitLZ77(const ZopfliOptions* options,
const ZopfliLZ77Store* lz77, size_t maxblocks,
size_t** splitpoints, size_t* npoints) {
size_t lstart, lend;
size_t i;
size_t llpos = 0;
size_t numblocks = 1;
unsigned char* done;
double splitcost, origcost;
if (lz77->size < 10) return; /* This code fails on tiny files. */
done = (unsigned char*)malloc(lz77->size);
if (!done) exit(-1); /* Allocation failed. */
for (i = 0; i < lz77->size; i++) done[i] = 0;
lstart = 0;
lend = lz77->size;
for (;;) {
SplitCostContext c;
if (maxblocks > 0 && numblocks >= maxblocks) {
break;
}
c.lz77 = lz77;
c.start = lstart;
c.end = lend;
assert(lstart < lend);
llpos = FindMinimum(SplitCost, &c, lstart + 1, lend, &splitcost);
assert(llpos > lstart);
assert(llpos < lend);
origcost = EstimateCost(lz77, lstart, lend);
if (splitcost > origcost || llpos == lstart + 1 || llpos == lend) {
done[lstart] = 1;
} else {
AddSorted(llpos, splitpoints, npoints);
numblocks++;
}
if (!FindLargestSplittableBlock(
lz77->size, done, *splitpoints, *npoints, &lstart, &lend)) {
break; /* No further split will probably reduce compression. */
}
if (lend - lstart < 10) {
break;
}
}
if (options->verbose) {
PrintBlockSplitPoints(lz77, *splitpoints, *npoints);
}
free(done);
}
void ZopfliBlockSplit(const ZopfliOptions* options,
const unsigned char* in, size_t instart, size_t inend,
size_t maxblocks, size_t** splitpoints, size_t* npoints) {
size_t pos = 0;
size_t i;
ZopfliBlockState s;
size_t* lz77splitpoints = 0;
size_t nlz77points = 0;
ZopfliLZ77Store store;
ZopfliHash hash;
ZopfliHash* h = &hash;
ZopfliInitLZ77Store(in, &store);
ZopfliInitBlockState(options, instart, inend, 0, &s);
ZopfliAllocHash(ZOPFLI_WINDOW_SIZE, h);
*npoints = 0;
*splitpoints = 0;
/* Unintuitively, Using a simple LZ77 method here instead of ZopfliLZ77Optimal
results in better blocks. */
ZopfliLZ77Greedy(&s, in, instart, inend, &store, h);
ZopfliBlockSplitLZ77(options,
&store, maxblocks,
&lz77splitpoints, &nlz77points);
/* Convert LZ77 positions to positions in the uncompressed input. */
pos = instart;
if (nlz77points > 0) {
for (i = 0; i < store.size; i++) {
size_t length = store.dists[i] == 0 ? 1 : store.litlens[i];
if (lz77splitpoints[*npoints] == i) {
ZOPFLI_APPEND_DATA(pos, splitpoints, npoints);
if (*npoints == nlz77points) break;
}
pos += length;
}
}
assert(*npoints == nlz77points);
free(lz77splitpoints);
ZopfliCleanBlockState(&s);
ZopfliCleanLZ77Store(&store);
ZopfliCleanHash(h);
}
void ZopfliBlockSplitSimple(const unsigned char* in,
size_t instart, size_t inend,
size_t blocksize,
size_t** splitpoints, size_t* npoints) {
size_t i = instart;
while (i < inend) {
ZOPFLI_APPEND_DATA(i, splitpoints, npoints);
i += blocksize;
}
(void)in;
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQZopfli/zopfli/blocksplitter.c
|
c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 2,669
|
```c
/*
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#include "deflate.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include "blocksplitter.h"
#include "squeeze.h"
#include "symbols.h"
#include "tree.h"
/*
bp = bitpointer, always in range [0, 7].
The outsize is number of necessary bytes to encode the bits.
Given the value of bp and the amount of bytes, the amount of bits represented
is not simply bytesize * 8 + bp because even representing one bit requires a
whole byte. It is: (bp == 0) ? (bytesize * 8) : ((bytesize - 1) * 8 + bp)
*/
static void AddBit(int bit,
unsigned char* bp, unsigned char** out, size_t* outsize) {
if (*bp == 0) ZOPFLI_APPEND_DATA(0, out, outsize);
(*out)[*outsize - 1] |= bit << *bp;
*bp = (*bp + 1) & 7;
}
static void AddBits(unsigned symbol, unsigned length,
unsigned char* bp, unsigned char** out, size_t* outsize) {
/* TODO(lode): make more efficient (add more bits at once). */
unsigned i;
for (i = 0; i < length; i++) {
unsigned bit = (symbol >> i) & 1;
if (*bp == 0) ZOPFLI_APPEND_DATA(0, out, outsize);
(*out)[*outsize - 1] |= bit << *bp;
*bp = (*bp + 1) & 7;
}
}
/*
Adds bits, like AddBits, but the order is inverted. The deflate specification
uses both orders in one standard.
*/
static void AddHuffmanBits(unsigned symbol, unsigned length,
unsigned char* bp, unsigned char** out,
size_t* outsize) {
/* TODO(lode): make more efficient (add more bits at once). */
unsigned i;
for (i = 0; i < length; i++) {
unsigned bit = (symbol >> (length - i - 1)) & 1;
if (*bp == 0) ZOPFLI_APPEND_DATA(0, out, outsize);
(*out)[*outsize - 1] |= bit << *bp;
*bp = (*bp + 1) & 7;
}
}
/*
Ensures there are at least 2 distance codes to support buggy decoders.
Zlib 1.2.1 and below have a bug where it fails if there isn't at least 1
distance code (with length > 0), even though it's valid according to the
deflate spec to have 0 distance codes. On top of that, some mobile phones
require at least two distance codes. To support these decoders too (but
potentially at the cost of a few bytes), add dummy code lengths of 1.
References to this bug can be found in the changelog of
Zlib 1.2.2 and here: path_to_url
d_lengths: the 32 lengths of the distance codes.
*/
static void PatchDistanceCodesForBuggyDecoders(unsigned* d_lengths) {
int num_dist_codes = 0; /* Amount of non-zero distance codes */
int i;
for (i = 0; i < 30 /* Ignore the two unused codes from the spec */; i++) {
if (d_lengths[i]) num_dist_codes++;
if (num_dist_codes >= 2) return; /* Two or more codes is fine. */
}
if (num_dist_codes == 0) {
d_lengths[0] = d_lengths[1] = 1;
} else if (num_dist_codes == 1) {
d_lengths[d_lengths[0] ? 1 : 0] = 1;
}
}
/*
Encodes the Huffman tree and returns how many bits its encoding takes. If out
is a null pointer, only returns the size and runs faster.
*/
static size_t EncodeTree(const unsigned* ll_lengths,
const unsigned* d_lengths,
int use_16, int use_17, int use_18,
unsigned char* bp,
unsigned char** out, size_t* outsize) {
unsigned lld_total; /* Total amount of literal, length, distance codes. */
/* Runlength encoded version of lengths of litlen and dist trees. */
unsigned* rle = 0;
unsigned* rle_bits = 0; /* Extra bits for rle values 16, 17 and 18. */
size_t rle_size = 0; /* Size of rle array. */
size_t rle_bits_size = 0; /* Should have same value as rle_size. */
unsigned hlit = 29; /* 286 - 257 */
unsigned hdist = 29; /* 32 - 1, but gzip does not like hdist > 29.*/
unsigned hclen;
unsigned hlit2;
size_t i, j;
size_t clcounts[19];
unsigned clcl[19]; /* Code length code lengths. */
unsigned clsymbols[19];
/* The order in which code length code lengths are encoded as per deflate. */
static const unsigned order[19] = {
16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
};
int size_only = !out;
size_t result_size = 0;
for(i = 0; i < 19; i++) clcounts[i] = 0;
/* Trim zeros. */
while (hlit > 0 && ll_lengths[257 + hlit - 1] == 0) hlit--;
while (hdist > 0 && d_lengths[1 + hdist - 1] == 0) hdist--;
hlit2 = hlit + 257;
lld_total = hlit2 + hdist + 1;
for (i = 0; i < lld_total; i++) {
/* This is an encoding of a huffman tree, so now the length is a symbol */
unsigned char symbol = i < hlit2 ? ll_lengths[i] : d_lengths[i - hlit2];
unsigned count = 1;
if(use_16 || (symbol == 0 && (use_17 || use_18))) {
for (j = i + 1; j < lld_total && symbol ==
(j < hlit2 ? ll_lengths[j] : d_lengths[j - hlit2]); j++) {
count++;
}
}
i += count - 1;
/* Repetitions of zeroes */
if (symbol == 0 && count >= 3) {
if (use_18) {
while (count >= 11) {
unsigned count2 = count > 138 ? 138 : count;
if (!size_only) {
ZOPFLI_APPEND_DATA(18, &rle, &rle_size);
ZOPFLI_APPEND_DATA(count2 - 11, &rle_bits, &rle_bits_size);
}
clcounts[18]++;
count -= count2;
}
}
if (use_17) {
while (count >= 3) {
unsigned count2 = count > 10 ? 10 : count;
if (!size_only) {
ZOPFLI_APPEND_DATA(17, &rle, &rle_size);
ZOPFLI_APPEND_DATA(count2 - 3, &rle_bits, &rle_bits_size);
}
clcounts[17]++;
count -= count2;
}
}
}
/* Repetitions of any symbol */
if (use_16 && count >= 4) {
count--; /* Since the first one is hardcoded. */
clcounts[symbol]++;
if (!size_only) {
ZOPFLI_APPEND_DATA(symbol, &rle, &rle_size);
ZOPFLI_APPEND_DATA(0, &rle_bits, &rle_bits_size);
}
while (count >= 3) {
unsigned count2 = count > 6 ? 6 : count;
if (!size_only) {
ZOPFLI_APPEND_DATA(16, &rle, &rle_size);
ZOPFLI_APPEND_DATA(count2 - 3, &rle_bits, &rle_bits_size);
}
clcounts[16]++;
count -= count2;
}
}
/* No or insufficient repetition */
clcounts[symbol] += count;
while (count > 0) {
if (!size_only) {
ZOPFLI_APPEND_DATA(symbol, &rle, &rle_size);
ZOPFLI_APPEND_DATA(0, &rle_bits, &rle_bits_size);
}
count--;
}
}
ZopfliCalculateBitLengths(clcounts, 19, 7, clcl);
if (!size_only) ZopfliLengthsToSymbols(clcl, 19, 7, clsymbols);
hclen = 15;
/* Trim zeros. */
while (hclen > 0 && clcounts[order[hclen + 4 - 1]] == 0) hclen--;
if (!size_only) {
AddBits(hlit, 5, bp, out, outsize);
AddBits(hdist, 5, bp, out, outsize);
AddBits(hclen, 4, bp, out, outsize);
for (i = 0; i < hclen + 4; i++) {
AddBits(clcl[order[i]], 3, bp, out, outsize);
}
for (i = 0; i < rle_size; i++) {
unsigned symbol = clsymbols[rle[i]];
AddHuffmanBits(symbol, clcl[rle[i]], bp, out, outsize);
/* Extra bits. */
if (rle[i] == 16) AddBits(rle_bits[i], 2, bp, out, outsize);
else if (rle[i] == 17) AddBits(rle_bits[i], 3, bp, out, outsize);
else if (rle[i] == 18) AddBits(rle_bits[i], 7, bp, out, outsize);
}
}
result_size += 14; /* hlit, hdist, hclen bits */
result_size += (hclen + 4) * 3; /* clcl bits */
for(i = 0; i < 19; i++) {
result_size += clcl[i] * clcounts[i];
}
/* Extra bits. */
result_size += clcounts[16] * 2;
result_size += clcounts[17] * 3;
result_size += clcounts[18] * 7;
/* Note: in case of "size_only" these are null pointers so no effect. */
free(rle);
free(rle_bits);
return result_size;
}
static void AddDynamicTree(const unsigned* ll_lengths,
const unsigned* d_lengths,
unsigned char* bp,
unsigned char** out, size_t* outsize) {
int i;
int best = 0;
size_t bestsize = 0;
for(i = 0; i < 8; i++) {
size_t size = EncodeTree(ll_lengths, d_lengths,
i & 1, i & 2, i & 4,
0, 0, 0);
if (bestsize == 0 || size < bestsize) {
bestsize = size;
best = i;
}
}
EncodeTree(ll_lengths, d_lengths,
best & 1, best & 2, best & 4,
bp, out, outsize);
}
/*
Gives the exact size of the tree, in bits, as it will be encoded in DEFLATE.
*/
static size_t CalculateTreeSize(const unsigned* ll_lengths,
const unsigned* d_lengths) {
size_t result = 0;
int i;
for(i = 0; i < 8; i++) {
size_t size = EncodeTree(ll_lengths, d_lengths,
i & 1, i & 2, i & 4,
0, 0, 0);
if (result == 0 || size < result) result = size;
}
return result;
}
/*
Adds all lit/len and dist codes from the lists as huffman symbols. Does not add
end code 256. expected_data_size is the uncompressed block size, used for
assert, but you can set it to 0 to not do the assertion.
*/
static void AddLZ77Data(const ZopfliLZ77Store* lz77,
size_t lstart, size_t lend,
size_t expected_data_size,
const unsigned* ll_symbols, const unsigned* ll_lengths,
const unsigned* d_symbols, const unsigned* d_lengths,
unsigned char* bp,
unsigned char** out, size_t* outsize) {
size_t testlength = 0;
size_t i;
for (i = lstart; i < lend; i++) {
unsigned dist = lz77->dists[i];
unsigned litlen = lz77->litlens[i];
if (dist == 0) {
assert(litlen < 256);
assert(ll_lengths[litlen] > 0);
AddHuffmanBits(ll_symbols[litlen], ll_lengths[litlen], bp, out, outsize);
testlength++;
} else {
unsigned lls = ZopfliGetLengthSymbol(litlen);
unsigned ds = ZopfliGetDistSymbol(dist);
assert(litlen >= 3 && litlen <= 288);
assert(ll_lengths[lls] > 0);
assert(d_lengths[ds] > 0);
AddHuffmanBits(ll_symbols[lls], ll_lengths[lls], bp, out, outsize);
AddBits(ZopfliGetLengthExtraBitsValue(litlen),
ZopfliGetLengthExtraBits(litlen),
bp, out, outsize);
AddHuffmanBits(d_symbols[ds], d_lengths[ds], bp, out, outsize);
AddBits(ZopfliGetDistExtraBitsValue(dist),
ZopfliGetDistExtraBits(dist),
bp, out, outsize);
testlength += litlen;
}
}
assert(expected_data_size == 0 || testlength == expected_data_size);
}
static void GetFixedTree(unsigned* ll_lengths, unsigned* d_lengths) {
size_t i;
for (i = 0; i < 144; i++) ll_lengths[i] = 8;
for (i = 144; i < 256; i++) ll_lengths[i] = 9;
for (i = 256; i < 280; i++) ll_lengths[i] = 7;
for (i = 280; i < 288; i++) ll_lengths[i] = 8;
for (i = 0; i < 32; i++) d_lengths[i] = 5;
}
/*
Same as CalculateBlockSymbolSize, but for block size smaller than histogram
size.
*/
static size_t CalculateBlockSymbolSizeSmall(const unsigned* ll_lengths,
const unsigned* d_lengths,
const ZopfliLZ77Store* lz77,
size_t lstart, size_t lend) {
size_t result = 0;
size_t i;
for (i = lstart; i < lend; i++) {
assert(i < lz77->size);
assert(lz77->litlens[i] < 259);
if (lz77->dists[i] == 0) {
result += ll_lengths[lz77->litlens[i]];
} else {
int ll_symbol = ZopfliGetLengthSymbol(lz77->litlens[i]);
int d_symbol = ZopfliGetDistSymbol(lz77->dists[i]);
result += ll_lengths[ll_symbol];
result += d_lengths[d_symbol];
result += ZopfliGetLengthSymbolExtraBits(ll_symbol);
result += ZopfliGetDistSymbolExtraBits(d_symbol);
}
}
result += ll_lengths[256]; /*end symbol*/
return result;
}
/*
Same as CalculateBlockSymbolSize, but with the histogram provided by the caller.
*/
static size_t CalculateBlockSymbolSizeGivenCounts(const size_t* ll_counts,
const size_t* d_counts,
const unsigned* ll_lengths,
const unsigned* d_lengths,
const ZopfliLZ77Store* lz77,
size_t lstart, size_t lend) {
size_t result = 0;
size_t i;
if (lstart + ZOPFLI_NUM_LL * 3 > lend) {
return CalculateBlockSymbolSizeSmall(
ll_lengths, d_lengths, lz77, lstart, lend);
} else {
for (i = 0; i < 256; i++) {
result += ll_lengths[i] * ll_counts[i];
}
for (i = 257; i < 286; i++) {
result += ll_lengths[i] * ll_counts[i];
result += ZopfliGetLengthSymbolExtraBits(i) * ll_counts[i];
}
for (i = 0; i < 30; i++) {
result += d_lengths[i] * d_counts[i];
result += ZopfliGetDistSymbolExtraBits(i) * d_counts[i];
}
result += ll_lengths[256]; /*end symbol*/
return result;
}
}
/*
Calculates size of the part after the header and tree of an LZ77 block, in bits.
*/
static size_t CalculateBlockSymbolSize(const unsigned* ll_lengths,
const unsigned* d_lengths,
const ZopfliLZ77Store* lz77,
size_t lstart, size_t lend) {
if (lstart + ZOPFLI_NUM_LL * 3 > lend) {
return CalculateBlockSymbolSizeSmall(
ll_lengths, d_lengths, lz77, lstart, lend);
} else {
size_t ll_counts[ZOPFLI_NUM_LL];
size_t d_counts[ZOPFLI_NUM_D];
ZopfliLZ77GetHistogram(lz77, lstart, lend, ll_counts, d_counts);
return CalculateBlockSymbolSizeGivenCounts(
ll_counts, d_counts, ll_lengths, d_lengths, lz77, lstart, lend);
}
}
static size_t AbsDiff(size_t x, size_t y) {
if (x > y)
return x - y;
else
return y - x;
}
/*
Changes the population counts in a way that the consequent Huffman tree
compression, especially its rle-part, will be more likely to compress this data
more efficiently. length contains the size of the histogram.
*/
void OptimizeHuffmanForRle(int length, size_t* counts) {
int i, k, stride;
size_t symbol, sum, limit;
int* good_for_rle;
/* 1) We don't want to touch the trailing zeros. We may break the
rules of the format by adding more data in the distance codes. */
for (; length >= 0; --length) {
if (length == 0) {
return;
}
if (counts[length - 1] != 0) {
/* Now counts[0..length - 1] does not have trailing zeros. */
break;
}
}
/* 2) Let's mark all population counts that already can be encoded
with an rle code.*/
good_for_rle = (int*)malloc(length * sizeof(int));
for (i = 0; i < length; ++i) good_for_rle[i] = 0;
/* Let's not spoil any of the existing good rle codes.
Mark any seq of 0's that is longer than 5 as a good_for_rle.
Mark any seq of non-0's that is longer than 7 as a good_for_rle.*/
symbol = counts[0];
stride = 0;
for (i = 0; i < length + 1; ++i) {
if (i == length || counts[i] != symbol) {
if ((symbol == 0 && stride >= 5) || (symbol != 0 && stride >= 7)) {
for (k = 0; k < stride; ++k) {
good_for_rle[i - k - 1] = 1;
}
}
stride = 1;
if (i != length) {
symbol = counts[i];
}
} else {
++stride;
}
}
/* 3) Let's replace those population counts that lead to more rle codes. */
stride = 0;
limit = counts[0];
sum = 0;
for (i = 0; i < length + 1; ++i) {
if (i == length || good_for_rle[i]
/* Heuristic for selecting the stride ranges to collapse. */
|| AbsDiff(counts[i], limit) >= 4) {
if (stride >= 4 || (stride >= 3 && sum == 0)) {
/* The stride must end, collapse what we have, if we have enough (4). */
int count = (sum + stride / 2) / stride;
if (count < 1) count = 1;
if (sum == 0) {
/* Don't make an all zeros stride to be upgraded to ones. */
count = 0;
}
for (k = 0; k < stride; ++k) {
/* We don't want to change value at counts[i],
that is already belonging to the next stride. Thus - 1. */
counts[i - k - 1] = count;
}
}
stride = 0;
sum = 0;
if (i < length - 3) {
/* All interesting strides have a count of at least 4,
at least when non-zeros. */
limit = (counts[i] + counts[i + 1] +
counts[i + 2] + counts[i + 3] + 2) / 4;
} else if (i < length) {
limit = counts[i];
} else {
limit = 0;
}
}
++stride;
if (i != length) {
sum += counts[i];
}
}
free(good_for_rle);
}
/*
Tries out OptimizeHuffmanForRle for this block, if the result is smaller,
uses it, otherwise keeps the original. Returns size of encoded tree and data in
bits, not including the 3-bit block header.
*/
static double TryOptimizeHuffmanForRle(
const ZopfliLZ77Store* lz77, size_t lstart, size_t lend,
const size_t* ll_counts, const size_t* d_counts,
unsigned* ll_lengths, unsigned* d_lengths) {
size_t ll_counts2[ZOPFLI_NUM_LL];
size_t d_counts2[ZOPFLI_NUM_D];
unsigned ll_lengths2[ZOPFLI_NUM_LL];
unsigned d_lengths2[ZOPFLI_NUM_D];
double treesize;
double datasize;
double treesize2;
double datasize2;
treesize = CalculateTreeSize(ll_lengths, d_lengths);
datasize = CalculateBlockSymbolSizeGivenCounts(ll_counts, d_counts,
ll_lengths, d_lengths, lz77, lstart, lend);
memcpy(ll_counts2, ll_counts, sizeof(ll_counts2));
memcpy(d_counts2, d_counts, sizeof(d_counts2));
OptimizeHuffmanForRle(ZOPFLI_NUM_LL, ll_counts2);
OptimizeHuffmanForRle(ZOPFLI_NUM_D, d_counts2);
ZopfliCalculateBitLengths(ll_counts2, ZOPFLI_NUM_LL, 15, ll_lengths2);
ZopfliCalculateBitLengths(d_counts2, ZOPFLI_NUM_D, 15, d_lengths2);
PatchDistanceCodesForBuggyDecoders(d_lengths2);
treesize2 = CalculateTreeSize(ll_lengths2, d_lengths2);
datasize2 = CalculateBlockSymbolSizeGivenCounts(ll_counts, d_counts,
ll_lengths2, d_lengths2, lz77, lstart, lend);
if (treesize2 + datasize2 < treesize + datasize) {
memcpy(ll_lengths, ll_lengths2, sizeof(ll_lengths2));
memcpy(d_lengths, d_lengths2, sizeof(d_lengths2));
return treesize2 + datasize2;
}
return treesize + datasize;
}
/*
Calculates the bit lengths for the symbols for dynamic blocks. Chooses bit
lengths that give the smallest size of tree encoding + encoding of all the
symbols to have smallest output size. This are not necessarily the ideal Huffman
bit lengths. Returns size of encoded tree and data in bits, not including the
3-bit block header.
*/
static double GetDynamicLengths(const ZopfliLZ77Store* lz77,
size_t lstart, size_t lend,
unsigned* ll_lengths, unsigned* d_lengths) {
size_t ll_counts[ZOPFLI_NUM_LL];
size_t d_counts[ZOPFLI_NUM_D];
ZopfliLZ77GetHistogram(lz77, lstart, lend, ll_counts, d_counts);
ll_counts[256] = 1; /* End symbol. */
ZopfliCalculateBitLengths(ll_counts, ZOPFLI_NUM_LL, 15, ll_lengths);
ZopfliCalculateBitLengths(d_counts, ZOPFLI_NUM_D, 15, d_lengths);
PatchDistanceCodesForBuggyDecoders(d_lengths);
return TryOptimizeHuffmanForRle(
lz77, lstart, lend, ll_counts, d_counts, ll_lengths, d_lengths);
}
double ZopfliCalculateBlockSize(const ZopfliLZ77Store* lz77,
size_t lstart, size_t lend, int btype) {
unsigned ll_lengths[ZOPFLI_NUM_LL];
unsigned d_lengths[ZOPFLI_NUM_D];
double result = 3; /* bfinal and btype bits */
if (btype == 0) {
size_t length = ZopfliLZ77GetByteRange(lz77, lstart, lend);
size_t rem = length % 65535;
size_t blocks = length / 65535 + (rem ? 1 : 0);
/* An uncompressed block must actually be split into multiple blocks if it's
larger than 65535 bytes long. Eeach block header is 5 bytes: 3 bits,
padding, LEN and NLEN (potential less padding for first one ignored). */
return blocks * 5 * 8 + length * 8;
} if (btype == 1) {
GetFixedTree(ll_lengths, d_lengths);
result += CalculateBlockSymbolSize(
ll_lengths, d_lengths, lz77, lstart, lend);
} else {
result += GetDynamicLengths(lz77, lstart, lend, ll_lengths, d_lengths);
}
return result;
}
double ZopfliCalculateBlockSizeAutoType(const ZopfliLZ77Store* lz77,
size_t lstart, size_t lend) {
double uncompressedcost = ZopfliCalculateBlockSize(lz77, lstart, lend, 0);
/* Don't do the expensive fixed cost calculation for larger blocks that are
unlikely to use it. */
double fixedcost = (lz77->size > 1000) ?
uncompressedcost : ZopfliCalculateBlockSize(lz77, lstart, lend, 1);
double dyncost = ZopfliCalculateBlockSize(lz77, lstart, lend, 2);
return (uncompressedcost < fixedcost && uncompressedcost < dyncost)
? uncompressedcost
: (fixedcost < dyncost ? fixedcost : dyncost);
}
/* Since an uncompressed block can be max 65535 in size, it actually adds
multible blocks if needed. */
static void AddNonCompressedBlock(const ZopfliOptions* options, int final,
const unsigned char* in, size_t instart,
size_t inend,
unsigned char* bp,
unsigned char** out, size_t* outsize) {
size_t pos = instart;
(void)options;
for (;;) {
size_t i;
unsigned short blocksize = 65535;
unsigned short nlen;
int currentfinal;
if (pos + blocksize > inend) blocksize = inend - pos;
currentfinal = pos + blocksize >= inend;
nlen = ~blocksize;
AddBit(final && currentfinal, bp, out, outsize);
/* BTYPE 00 */
AddBit(0, bp, out, outsize);
AddBit(0, bp, out, outsize);
/* Any bits of input up to the next byte boundary are ignored. */
*bp = 0;
ZOPFLI_APPEND_DATA(blocksize % 256, out, outsize);
ZOPFLI_APPEND_DATA((blocksize / 256) % 256, out, outsize);
ZOPFLI_APPEND_DATA(nlen % 256, out, outsize);
ZOPFLI_APPEND_DATA((nlen / 256) % 256, out, outsize);
for (i = 0; i < blocksize; i++) {
ZOPFLI_APPEND_DATA(in[pos + i], out, outsize);
}
if (currentfinal) break;
pos += blocksize;
}
}
/*
Adds a deflate block with the given LZ77 data to the output.
options: global program options
btype: the block type, must be 1 or 2
final: whether to set the "final" bit on this block, must be the last block
litlens: literal/length array of the LZ77 data, in the same format as in
ZopfliLZ77Store.
dists: distance array of the LZ77 data, in the same format as in
ZopfliLZ77Store.
lstart: where to start in the LZ77 data
lend: where to end in the LZ77 data (not inclusive)
expected_data_size: the uncompressed block size, used for assert, but you can
set it to 0 to not do the assertion.
bp: output bit pointer
out: dynamic output array to append to
outsize: dynamic output array size
*/
static void AddLZ77Block(const ZopfliOptions* options, int btype, int final,
const ZopfliLZ77Store* lz77,
size_t lstart, size_t lend,
size_t expected_data_size,
unsigned char* bp,
unsigned char** out, size_t* outsize) {
unsigned ll_lengths[ZOPFLI_NUM_LL];
unsigned d_lengths[ZOPFLI_NUM_D];
unsigned ll_symbols[ZOPFLI_NUM_LL];
unsigned d_symbols[ZOPFLI_NUM_D];
size_t detect_block_size = *outsize;
size_t compressed_size;
size_t uncompressed_size = 0;
size_t i;
if (btype == 0) {
size_t length = ZopfliLZ77GetByteRange(lz77, lstart, lend);
size_t pos = lstart == lend ? 0 : lz77->pos[lstart];
size_t end = pos + length;
AddNonCompressedBlock(options, final,
lz77->data, pos, end, bp, out, outsize);
return;
}
AddBit(final, bp, out, outsize);
AddBit(btype & 1, bp, out, outsize);
AddBit((btype & 2) >> 1, bp, out, outsize);
if (btype == 1) {
/* Fixed block. */
GetFixedTree(ll_lengths, d_lengths);
} else {
/* Dynamic block. */
unsigned detect_tree_size;
assert(btype == 2);
GetDynamicLengths(lz77, lstart, lend, ll_lengths, d_lengths);
detect_tree_size = *outsize;
AddDynamicTree(ll_lengths, d_lengths, bp, out, outsize);
if (options->verbose) {
fprintf(stderr, "treesize: %d\n", (int)(*outsize - detect_tree_size));
}
}
ZopfliLengthsToSymbols(ll_lengths, ZOPFLI_NUM_LL, 15, ll_symbols);
ZopfliLengthsToSymbols(d_lengths, ZOPFLI_NUM_D, 15, d_symbols);
detect_block_size = *outsize;
AddLZ77Data(lz77, lstart, lend, expected_data_size,
ll_symbols, ll_lengths, d_symbols, d_lengths,
bp, out, outsize);
/* End symbol. */
AddHuffmanBits(ll_symbols[256], ll_lengths[256], bp, out, outsize);
for (i = lstart; i < lend; i++) {
uncompressed_size += lz77->dists[i] == 0 ? 1 : lz77->litlens[i];
}
compressed_size = *outsize - detect_block_size;
if (options->verbose) {
fprintf(stderr, "compressed block size: %d (%dk) (unc: %d)\n",
(int)compressed_size, (int)(compressed_size / 1024),
(int)(uncompressed_size));
}
}
static void AddLZ77BlockAutoType(const ZopfliOptions* options, int final,
const ZopfliLZ77Store* lz77,
size_t lstart, size_t lend,
size_t expected_data_size,
unsigned char* bp,
unsigned char** out, size_t* outsize) {
double uncompressedcost = ZopfliCalculateBlockSize(lz77, lstart, lend, 0);
double fixedcost = ZopfliCalculateBlockSize(lz77, lstart, lend, 1);
double dyncost = ZopfliCalculateBlockSize(lz77, lstart, lend, 2);
/* Whether to perform the expensive calculation of creating an optimal block
with fixed huffman tree to check if smaller. Only do this for small blocks or
blocks which already are pretty good with fixed huffman tree. */
int expensivefixed = (lz77->size < 1000) || fixedcost <= dyncost * 1.1;
ZopfliLZ77Store fixedstore;
if (lstart == lend) {
/* Smallest empty block is represented by fixed block */
AddBits(final, 1, bp, out, outsize);
AddBits(1, 2, bp, out, outsize); /* btype 01 */
AddBits(0, 7, bp, out, outsize); /* end symbol has code 0000000 */
return;
}
ZopfliInitLZ77Store(lz77->data, &fixedstore);
if (expensivefixed) {
/* Recalculate the LZ77 with ZopfliLZ77OptimalFixed */
size_t instart = lz77->pos[lstart];
size_t inend = instart + ZopfliLZ77GetByteRange(lz77, lstart, lend);
ZopfliBlockState s;
ZopfliInitBlockState(options, instart, inend, 1, &s);
ZopfliLZ77OptimalFixed(&s, lz77->data, instart, inend, &fixedstore);
fixedcost = ZopfliCalculateBlockSize(&fixedstore, 0, fixedstore.size, 1);
ZopfliCleanBlockState(&s);
}
if (uncompressedcost < fixedcost && uncompressedcost < dyncost) {
AddLZ77Block(options, 0, final, lz77, lstart, lend,
expected_data_size, bp, out, outsize);
} else if (fixedcost < dyncost) {
if (expensivefixed) {
AddLZ77Block(options, 1, final, &fixedstore, 0, fixedstore.size,
expected_data_size, bp, out, outsize);
} else {
AddLZ77Block(options, 1, final, lz77, lstart, lend,
expected_data_size, bp, out, outsize);
}
} else {
AddLZ77Block(options, 2, final, lz77, lstart, lend,
expected_data_size, bp, out, outsize);
}
ZopfliCleanLZ77Store(&fixedstore);
}
/*
Deflate a part, to allow ZopfliDeflate() to use multiple master blocks if
needed.
It is possible to call this function multiple times in a row, shifting
instart and inend to next bytes of the data. If instart is larger than 0, then
previous bytes are used as the initial dictionary for LZ77.
This function will usually output multiple deflate blocks. If final is 1, then
the final bit will be set on the last block.
*/
void ZopfliDeflatePart(const ZopfliOptions* options, int btype, int final,
const unsigned char* in, size_t instart, size_t inend,
unsigned char* bp, unsigned char** out,
size_t* outsize) {
size_t i;
/* byte coordinates rather than lz77 index */
size_t* splitpoints_uncompressed = 0;
size_t npoints = 0;
size_t* splitpoints = 0;
double totalcost = 0;
ZopfliLZ77Store lz77;
/* If btype=2 is specified, it tries all block types. If a lesser btype is
given, then however it forces that one. Neither of the lesser types needs
block splitting as they have no dynamic huffman trees. */
if (btype == 0) {
AddNonCompressedBlock(options, final, in, instart, inend, bp, out, outsize);
return;
} else if (btype == 1) {
ZopfliLZ77Store store;
ZopfliBlockState s;
ZopfliInitLZ77Store(in, &store);
ZopfliInitBlockState(options, instart, inend, 1, &s);
ZopfliLZ77OptimalFixed(&s, in, instart, inend, &store);
AddLZ77Block(options, btype, final, &store, 0, store.size, 0,
bp, out, outsize);
ZopfliCleanBlockState(&s);
ZopfliCleanLZ77Store(&store);
return;
}
if (options->blocksplitting) {
ZopfliBlockSplit(options, in, instart, inend,
options->blocksplittingmax,
&splitpoints_uncompressed, &npoints);
splitpoints = (size_t*)malloc(sizeof(*splitpoints) * npoints);
}
ZopfliInitLZ77Store(in, &lz77);
for (i = 0; i <= npoints; i++) {
size_t start = i == 0 ? instart : splitpoints_uncompressed[i - 1];
size_t end = i == npoints ? inend : splitpoints_uncompressed[i];
ZopfliBlockState s;
ZopfliLZ77Store store;
ZopfliInitLZ77Store(in, &store);
ZopfliInitBlockState(options, start, end, 1, &s);
ZopfliLZ77Optimal(&s, in, start, end, options->numiterations, &store);
totalcost += ZopfliCalculateBlockSizeAutoType(&store, 0, store.size);
ZopfliAppendLZ77Store(&store, &lz77);
if (i < npoints) splitpoints[i] = lz77.size;
ZopfliCleanBlockState(&s);
ZopfliCleanLZ77Store(&store);
}
/* Second block splitting attempt */
if (options->blocksplitting && npoints > 1) {
size_t* splitpoints2 = 0;
size_t npoints2 = 0;
double totalcost2 = 0;
ZopfliBlockSplitLZ77(options, &lz77,
options->blocksplittingmax, &splitpoints2, &npoints2);
for (i = 0; i <= npoints2; i++) {
size_t start = i == 0 ? 0 : splitpoints2[i - 1];
size_t end = i == npoints2 ? lz77.size : splitpoints2[i];
totalcost2 += ZopfliCalculateBlockSizeAutoType(&lz77, start, end);
}
if (totalcost2 < totalcost) {
free(splitpoints);
splitpoints = splitpoints2;
npoints = npoints2;
} else {
free(splitpoints2);
}
}
for (i = 0; i <= npoints; i++) {
size_t start = i == 0 ? 0 : splitpoints[i - 1];
size_t end = i == npoints ? lz77.size : splitpoints[i];
AddLZ77BlockAutoType(options, i == npoints && final,
&lz77, start, end, 0,
bp, out, outsize);
}
ZopfliCleanLZ77Store(&lz77);
free(splitpoints);
free(splitpoints_uncompressed);
}
void ZopfliDeflate(const ZopfliOptions* options, int btype, int final,
const unsigned char* in, size_t insize,
unsigned char* bp, unsigned char** out, size_t* outsize) {
size_t offset = *outsize;
#if ZOPFLI_MASTER_BLOCK_SIZE == 0
ZopfliDeflatePart(options, btype, final, in, 0, insize, bp, out, outsize);
#else
size_t i = 0;
do {
int masterfinal = (i + ZOPFLI_MASTER_BLOCK_SIZE >= insize);
int final2 = final && masterfinal;
size_t size = masterfinal ? insize - i : ZOPFLI_MASTER_BLOCK_SIZE;
ZopfliDeflatePart(options, btype, final2,
in, i, i + size, bp, out, outsize);
i += size;
} while (i < insize);
#endif
if (options->verbose) {
fprintf(stderr,
"Original Size: %lu, Deflate: %lu, Compression: %f%% Removed\n",
(unsigned long)insize, (unsigned long)(*outsize - offset),
100.0 * (double)(insize - (*outsize - offset)) / (double)insize);
}
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQZopfli/zopfli/deflate.c
|
c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 9,622
|
```c
/*
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Author: lode.vandevenne@gmail.com (Lode Vandevenne)
Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala)
*/
#include "lz77.h"
#include "symbols.h"
#include "util.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
void ZopfliInitLZ77Store(const unsigned char* data, ZopfliLZ77Store* store) {
store->size = 0;
store->litlens = 0;
store->dists = 0;
store->pos = 0;
store->data = data;
store->ll_symbol = 0;
store->d_symbol = 0;
store->ll_counts = 0;
store->d_counts = 0;
}
void ZopfliCleanLZ77Store(ZopfliLZ77Store* store) {
free(store->litlens);
free(store->dists);
free(store->pos);
free(store->ll_symbol);
free(store->d_symbol);
free(store->ll_counts);
free(store->d_counts);
}
static size_t CeilDiv(size_t a, size_t b) {
return (a + b - 1) / b;
}
void ZopfliCopyLZ77Store(
const ZopfliLZ77Store* source, ZopfliLZ77Store* dest) {
size_t i;
size_t llsize = ZOPFLI_NUM_LL * CeilDiv(source->size, ZOPFLI_NUM_LL);
size_t dsize = ZOPFLI_NUM_D * CeilDiv(source->size, ZOPFLI_NUM_D);
ZopfliCleanLZ77Store(dest);
ZopfliInitLZ77Store(source->data, dest);
dest->litlens =
(unsigned short*)malloc(sizeof(*dest->litlens) * source->size);
dest->dists = (unsigned short*)malloc(sizeof(*dest->dists) * source->size);
dest->pos = (size_t*)malloc(sizeof(*dest->pos) * source->size);
dest->ll_symbol =
(unsigned short*)malloc(sizeof(*dest->ll_symbol) * source->size);
dest->d_symbol =
(unsigned short*)malloc(sizeof(*dest->d_symbol) * source->size);
dest->ll_counts = (size_t*)malloc(sizeof(*dest->ll_counts) * llsize);
dest->d_counts = (size_t*)malloc(sizeof(*dest->d_counts) * dsize);
/* Allocation failed. */
if (!dest->litlens || !dest->dists) exit(-1);
if (!dest->pos) exit(-1);
if (!dest->ll_symbol || !dest->d_symbol) exit(-1);
if (!dest->ll_counts || !dest->d_counts) exit(-1);
dest->size = source->size;
for (i = 0; i < source->size; i++) {
dest->litlens[i] = source->litlens[i];
dest->dists[i] = source->dists[i];
dest->pos[i] = source->pos[i];
dest->ll_symbol[i] = source->ll_symbol[i];
dest->d_symbol[i] = source->d_symbol[i];
}
for (i = 0; i < llsize; i++) {
dest->ll_counts[i] = source->ll_counts[i];
}
for (i = 0; i < dsize; i++) {
dest->d_counts[i] = source->d_counts[i];
}
}
/*
Appends the length and distance to the LZ77 arrays of the ZopfliLZ77Store.
context must be a ZopfliLZ77Store*.
*/
void ZopfliStoreLitLenDist(unsigned short length, unsigned short dist,
size_t pos, ZopfliLZ77Store* store) {
size_t i;
/* Needed for using ZOPFLI_APPEND_DATA multiple times. */
size_t origsize = store->size;
size_t llstart = ZOPFLI_NUM_LL * (origsize / ZOPFLI_NUM_LL);
size_t dstart = ZOPFLI_NUM_D * (origsize / ZOPFLI_NUM_D);
/* Everytime the index wraps around, a new cumulative histogram is made: we're
keeping one histogram value per LZ77 symbol rather than a full histogram for
each to save memory. */
if (origsize % ZOPFLI_NUM_LL == 0) {
size_t llsize = origsize;
for (i = 0; i < ZOPFLI_NUM_LL; i++) {
ZOPFLI_APPEND_DATA(
origsize == 0 ? 0 : store->ll_counts[origsize - ZOPFLI_NUM_LL + i],
&store->ll_counts, &llsize);
}
}
if (origsize % ZOPFLI_NUM_D == 0) {
size_t dsize = origsize;
for (i = 0; i < ZOPFLI_NUM_D; i++) {
ZOPFLI_APPEND_DATA(
origsize == 0 ? 0 : store->d_counts[origsize - ZOPFLI_NUM_D + i],
&store->d_counts, &dsize);
}
}
ZOPFLI_APPEND_DATA(length, &store->litlens, &store->size);
store->size = origsize;
ZOPFLI_APPEND_DATA(dist, &store->dists, &store->size);
store->size = origsize;
ZOPFLI_APPEND_DATA(pos, &store->pos, &store->size);
assert(length < 259);
if (dist == 0) {
store->size = origsize;
ZOPFLI_APPEND_DATA(length, &store->ll_symbol, &store->size);
store->size = origsize;
ZOPFLI_APPEND_DATA(0, &store->d_symbol, &store->size);
store->ll_counts[llstart + length]++;
} else {
store->size = origsize;
ZOPFLI_APPEND_DATA(ZopfliGetLengthSymbol(length),
&store->ll_symbol, &store->size);
store->size = origsize;
ZOPFLI_APPEND_DATA(ZopfliGetDistSymbol(dist),
&store->d_symbol, &store->size);
store->ll_counts[llstart + ZopfliGetLengthSymbol(length)]++;
store->d_counts[dstart + ZopfliGetDistSymbol(dist)]++;
}
}
void ZopfliAppendLZ77Store(const ZopfliLZ77Store* store,
ZopfliLZ77Store* target) {
size_t i;
for (i = 0; i < store->size; i++) {
ZopfliStoreLitLenDist(store->litlens[i], store->dists[i],
store->pos[i], target);
}
}
size_t ZopfliLZ77GetByteRange(const ZopfliLZ77Store* lz77,
size_t lstart, size_t lend) {
size_t l = lend - 1;
if (lstart == lend) return 0;
return lz77->pos[l] + ((lz77->dists[l] == 0) ?
1 : lz77->litlens[l]) - lz77->pos[lstart];
}
static void ZopfliLZ77GetHistogramAt(const ZopfliLZ77Store* lz77, size_t lpos,
size_t* ll_counts, size_t* d_counts) {
/* The real histogram is created by using the histogram for this chunk, but
all superfluous values of this chunk subtracted. */
size_t llpos = ZOPFLI_NUM_LL * (lpos / ZOPFLI_NUM_LL);
size_t dpos = ZOPFLI_NUM_D * (lpos / ZOPFLI_NUM_D);
size_t i;
for (i = 0; i < ZOPFLI_NUM_LL; i++) {
ll_counts[i] = lz77->ll_counts[llpos + i];
}
for (i = lpos + 1; i < llpos + ZOPFLI_NUM_LL && i < lz77->size; i++) {
ll_counts[lz77->ll_symbol[i]]--;
}
for (i = 0; i < ZOPFLI_NUM_D; i++) {
d_counts[i] = lz77->d_counts[dpos + i];
}
for (i = lpos + 1; i < dpos + ZOPFLI_NUM_D && i < lz77->size; i++) {
if (lz77->dists[i] != 0) d_counts[lz77->d_symbol[i]]--;
}
}
void ZopfliLZ77GetHistogram(const ZopfliLZ77Store* lz77,
size_t lstart, size_t lend,
size_t* ll_counts, size_t* d_counts) {
size_t i;
if (lstart + ZOPFLI_NUM_LL * 3 > lend) {
memset(ll_counts, 0, sizeof(*ll_counts) * ZOPFLI_NUM_LL);
memset(d_counts, 0, sizeof(*d_counts) * ZOPFLI_NUM_D);
for (i = lstart; i < lend; i++) {
ll_counts[lz77->ll_symbol[i]]++;
if (lz77->dists[i] != 0) d_counts[lz77->d_symbol[i]]++;
}
} else {
/* Subtract the cumulative histograms at the end and the start to get the
histogram for this range. */
ZopfliLZ77GetHistogramAt(lz77, lend - 1, ll_counts, d_counts);
if (lstart > 0) {
size_t ll_counts2[ZOPFLI_NUM_LL];
size_t d_counts2[ZOPFLI_NUM_D];
ZopfliLZ77GetHistogramAt(lz77, lstart - 1, ll_counts2, d_counts2);
for (i = 0; i < ZOPFLI_NUM_LL; i++) {
ll_counts[i] -= ll_counts2[i];
}
for (i = 0; i < ZOPFLI_NUM_D; i++) {
d_counts[i] -= d_counts2[i];
}
}
}
}
void ZopfliInitBlockState(const ZopfliOptions* options,
size_t blockstart, size_t blockend, int add_lmc,
ZopfliBlockState* s) {
s->options = options;
s->blockstart = blockstart;
s->blockend = blockend;
#ifdef ZOPFLI_LONGEST_MATCH_CACHE
if (add_lmc) {
s->lmc = (ZopfliLongestMatchCache*)malloc(sizeof(ZopfliLongestMatchCache));
ZopfliInitCache(blockend - blockstart, s->lmc);
} else {
s->lmc = 0;
}
#endif
}
void ZopfliCleanBlockState(ZopfliBlockState* s) {
#ifdef ZOPFLI_LONGEST_MATCH_CACHE
if (s->lmc) {
ZopfliCleanCache(s->lmc);
free(s->lmc);
}
#endif
}
/*
Gets a score of the length given the distance. Typically, the score of the
length is the length itself, but if the distance is very long, decrease the
score of the length a bit to make up for the fact that long distances use large
amounts of extra bits.
This is not an accurate score, it is a heuristic only for the greedy LZ77
implementation. More accurate cost models are employed later. Making this
heuristic more accurate may hurt rather than improve compression.
The two direct uses of this heuristic are:
-avoid using a length of 3 in combination with a long distance. This only has
an effect if length == 3.
-make a slightly better choice between the two options of the lazy matching.
Indirectly, this affects:
-the block split points if the default of block splitting first is used, in a
rather unpredictable way
-the first zopfli run, so it affects the chance of the first run being closer
to the optimal output
*/
static int GetLengthScore(int length, int distance) {
/*
At 1024, the distance uses 9+ extra bits and this seems to be the sweet spot
on tested files.
*/
return distance > 1024 ? length - 1 : length;
}
void ZopfliVerifyLenDist(const unsigned char* data, size_t datasize, size_t pos,
unsigned short dist, unsigned short length) {
/* TODO(lode): make this only run in a debug compile, it's for assert only. */
size_t i;
assert(pos + length <= datasize);
for (i = 0; i < length; i++) {
if (data[pos - dist + i] != data[pos + i]) {
assert(data[pos - dist + i] == data[pos + i]);
break;
}
}
}
/*
Finds how long the match of scan and match is. Can be used to find how many
bytes starting from scan, and from match, are equal. Returns the last byte
after scan, which is still equal to the correspondinb byte after match.
scan is the position to compare
match is the earlier position to compare.
end is the last possible byte, beyond which to stop looking.
safe_end is a few (8) bytes before end, for comparing multiple bytes at once.
*/
static const unsigned char* GetMatch(const unsigned char* scan,
const unsigned char* match,
const unsigned char* end,
const unsigned char* safe_end) {
if (sizeof(size_t) == 8) {
/* 8 checks at once per array bounds check (size_t is 64-bit). */
while (scan < safe_end && *((size_t*)scan) == *((size_t*)match)) {
scan += 8;
match += 8;
}
} else if (sizeof(unsigned int) == 4) {
/* 4 checks at once per array bounds check (unsigned int is 32-bit). */
while (scan < safe_end
&& *((unsigned int*)scan) == *((unsigned int*)match)) {
scan += 4;
match += 4;
}
} else {
/* do 8 checks at once per array bounds check. */
while (scan < safe_end && *scan == *match && *++scan == *++match
&& *++scan == *++match && *++scan == *++match
&& *++scan == *++match && *++scan == *++match
&& *++scan == *++match && *++scan == *++match) {
scan++; match++;
}
}
/* The remaining few bytes. */
while (scan != end && *scan == *match) {
scan++; match++;
}
return scan;
}
#ifdef ZOPFLI_LONGEST_MATCH_CACHE
/*
Gets distance, length and sublen values from the cache if possible.
Returns 1 if it got the values from the cache, 0 if not.
Updates the limit value to a smaller one if possible with more limited
information from the cache.
*/
static int TryGetFromLongestMatchCache(ZopfliBlockState* s,
size_t pos, size_t* limit,
unsigned short* sublen, unsigned short* distance, unsigned short* length) {
/* The LMC cache starts at the beginning of the block rather than the
beginning of the whole array. */
size_t lmcpos = pos - s->blockstart;
/* Length > 0 and dist 0 is invalid combination, which indicates on purpose
that this cache value is not filled in yet. */
unsigned char cache_available = s->lmc && (s->lmc->length[lmcpos] == 0 ||
s->lmc->dist[lmcpos] != 0);
unsigned char limit_ok_for_cache = cache_available &&
(*limit == ZOPFLI_MAX_MATCH || s->lmc->length[lmcpos] <= *limit ||
(sublen && ZopfliMaxCachedSublen(s->lmc,
lmcpos, s->lmc->length[lmcpos]) >= *limit));
if (s->lmc && limit_ok_for_cache && cache_available) {
if (!sublen || s->lmc->length[lmcpos]
<= ZopfliMaxCachedSublen(s->lmc, lmcpos, s->lmc->length[lmcpos])) {
*length = s->lmc->length[lmcpos];
if (*length > *limit) *length = *limit;
if (sublen) {
ZopfliCacheToSublen(s->lmc, lmcpos, *length, sublen);
*distance = sublen[*length];
if (*limit == ZOPFLI_MAX_MATCH && *length >= ZOPFLI_MIN_MATCH) {
assert(sublen[*length] == s->lmc->dist[lmcpos]);
}
} else {
*distance = s->lmc->dist[lmcpos];
}
return 1;
}
/* Can't use much of the cache, since the "sublens" need to be calculated,
but at least we already know when to stop. */
*limit = s->lmc->length[lmcpos];
}
return 0;
}
/*
Stores the found sublen, distance and length in the longest match cache, if
possible.
*/
static void StoreInLongestMatchCache(ZopfliBlockState* s,
size_t pos, size_t limit,
const unsigned short* sublen,
unsigned short distance, unsigned short length) {
/* The LMC cache starts at the beginning of the block rather than the
beginning of the whole array. */
size_t lmcpos = pos - s->blockstart;
/* Length > 0 and dist 0 is invalid combination, which indicates on purpose
that this cache value is not filled in yet. */
unsigned char cache_available = s->lmc && (s->lmc->length[lmcpos] == 0 ||
s->lmc->dist[lmcpos] != 0);
if (s->lmc && limit == ZOPFLI_MAX_MATCH && sublen && !cache_available) {
assert(s->lmc->length[lmcpos] == 1 && s->lmc->dist[lmcpos] == 0);
s->lmc->dist[lmcpos] = length < ZOPFLI_MIN_MATCH ? 0 : distance;
s->lmc->length[lmcpos] = length < ZOPFLI_MIN_MATCH ? 0 : length;
assert(!(s->lmc->length[lmcpos] == 1 && s->lmc->dist[lmcpos] == 0));
ZopfliSublenToCache(sublen, lmcpos, length, s->lmc);
}
}
#endif
void ZopfliFindLongestMatch(ZopfliBlockState* s, const ZopfliHash* h,
const unsigned char* array,
size_t pos, size_t size, size_t limit,
unsigned short* sublen, unsigned short* distance, unsigned short* length) {
unsigned short hpos = pos & ZOPFLI_WINDOW_MASK, p, pp;
unsigned short bestdist = 0;
unsigned short bestlength = 1;
const unsigned char* scan;
const unsigned char* match;
const unsigned char* arrayend;
const unsigned char* arrayend_safe;
#if ZOPFLI_MAX_CHAIN_HITS < ZOPFLI_WINDOW_SIZE
int chain_counter = ZOPFLI_MAX_CHAIN_HITS; /* For quitting early. */
#endif
unsigned dist = 0; /* Not unsigned short on purpose. */
int* hhead = h->head;
unsigned short* hprev = h->prev;
int* hhashval = h->hashval;
int hval = h->val;
#ifdef ZOPFLI_LONGEST_MATCH_CACHE
if (TryGetFromLongestMatchCache(s, pos, &limit, sublen, distance, length)) {
assert(pos + *length <= size);
return;
}
#endif
assert(limit <= ZOPFLI_MAX_MATCH);
assert(limit >= ZOPFLI_MIN_MATCH);
assert(pos < size);
if (size - pos < ZOPFLI_MIN_MATCH) {
/* The rest of the code assumes there are at least ZOPFLI_MIN_MATCH bytes to
try. */
*length = 0;
*distance = 0;
return;
}
if (pos + limit > size) {
limit = size - pos;
}
arrayend = &array[pos] + limit;
arrayend_safe = arrayend - 8;
assert(hval < 65536);
pp = hhead[hval]; /* During the whole loop, p == hprev[pp]. */
p = hprev[pp];
assert(pp == hpos);
dist = p < pp ? pp - p : ((ZOPFLI_WINDOW_SIZE - p) + pp);
/* Go through all distances. */
while (dist < ZOPFLI_WINDOW_SIZE) {
unsigned short currentlength = 0;
assert(p < ZOPFLI_WINDOW_SIZE);
assert(p == hprev[pp]);
assert(hhashval[p] == hval);
if (dist > 0) {
assert(pos < size);
assert(dist <= pos);
scan = &array[pos];
match = &array[pos - dist];
/* Testing the byte at position bestlength first, goes slightly faster. */
if (pos + bestlength >= size
|| *(scan + bestlength) == *(match + bestlength)) {
#ifdef ZOPFLI_HASH_SAME
unsigned short same0 = h->same[pos & ZOPFLI_WINDOW_MASK];
if (same0 > 2 && *scan == *match) {
unsigned short same1 = h->same[(pos - dist) & ZOPFLI_WINDOW_MASK];
unsigned short same = same0 < same1 ? same0 : same1;
if (same > limit) same = limit;
scan += same;
match += same;
}
#endif
scan = GetMatch(scan, match, arrayend, arrayend_safe);
currentlength = scan - &array[pos]; /* The found length. */
}
if (currentlength > bestlength) {
if (sublen) {
unsigned short j;
for (j = bestlength + 1; j <= currentlength; j++) {
sublen[j] = dist;
}
}
bestdist = dist;
bestlength = currentlength;
if (currentlength >= limit) break;
}
}
#ifdef ZOPFLI_HASH_SAME_HASH
/* Switch to the other hash once this will be more efficient. */
if (hhead != h->head2 && bestlength >= h->same[hpos] &&
h->val2 == h->hashval2[p]) {
/* Now use the hash that encodes the length and first byte. */
hhead = h->head2;
hprev = h->prev2;
hhashval = h->hashval2;
hval = h->val2;
}
#endif
pp = p;
p = hprev[p];
if (p == pp) break; /* Uninited prev value. */
dist += p < pp ? pp - p : ((ZOPFLI_WINDOW_SIZE - p) + pp);
#if ZOPFLI_MAX_CHAIN_HITS < ZOPFLI_WINDOW_SIZE
chain_counter--;
if (chain_counter <= 0) break;
#endif
}
#ifdef ZOPFLI_LONGEST_MATCH_CACHE
StoreInLongestMatchCache(s, pos, limit, sublen, bestdist, bestlength);
#endif
assert(bestlength <= limit);
*distance = bestdist;
*length = bestlength;
assert(pos + *length <= size);
}
void ZopfliLZ77Greedy(ZopfliBlockState* s, const unsigned char* in,
size_t instart, size_t inend,
ZopfliLZ77Store* store, ZopfliHash* h) {
size_t i = 0, j;
unsigned short leng;
unsigned short dist;
int lengthscore;
size_t windowstart = instart > ZOPFLI_WINDOW_SIZE
? instart - ZOPFLI_WINDOW_SIZE : 0;
unsigned short dummysublen[259];
#ifdef ZOPFLI_LAZY_MATCHING
/* Lazy matching. */
unsigned prev_length = 0;
unsigned prev_match = 0;
int prevlengthscore;
int match_available = 0;
#endif
if (instart == inend) return;
ZopfliResetHash(ZOPFLI_WINDOW_SIZE, h);
ZopfliWarmupHash(in, windowstart, inend, h);
for (i = windowstart; i < instart; i++) {
ZopfliUpdateHash(in, i, inend, h);
}
for (i = instart; i < inend; i++) {
ZopfliUpdateHash(in, i, inend, h);
ZopfliFindLongestMatch(s, h, in, i, inend, ZOPFLI_MAX_MATCH, dummysublen,
&dist, &leng);
lengthscore = GetLengthScore(leng, dist);
#ifdef ZOPFLI_LAZY_MATCHING
/* Lazy matching. */
prevlengthscore = GetLengthScore(prev_length, prev_match);
if (match_available) {
match_available = 0;
if (lengthscore > prevlengthscore + 1) {
ZopfliStoreLitLenDist(in[i - 1], 0, i - 1, store);
if (lengthscore >= ZOPFLI_MIN_MATCH && leng < ZOPFLI_MAX_MATCH) {
match_available = 1;
prev_length = leng;
prev_match = dist;
continue;
}
} else {
/* Add previous to output. */
leng = prev_length;
dist = prev_match;
lengthscore = prevlengthscore;
/* Add to output. */
ZopfliVerifyLenDist(in, inend, i - 1, dist, leng);
ZopfliStoreLitLenDist(leng, dist, i - 1, store);
for (j = 2; j < leng; j++) {
assert(i < inend);
i++;
ZopfliUpdateHash(in, i, inend, h);
}
continue;
}
}
else if (lengthscore >= ZOPFLI_MIN_MATCH && leng < ZOPFLI_MAX_MATCH) {
match_available = 1;
prev_length = leng;
prev_match = dist;
continue;
}
/* End of lazy matching. */
#endif
/* Add to output. */
if (lengthscore >= ZOPFLI_MIN_MATCH) {
ZopfliVerifyLenDist(in, inend, i, dist, leng);
ZopfliStoreLitLenDist(leng, dist, i, store);
} else {
leng = 1;
ZopfliStoreLitLenDist(in[i], 0, i, store);
}
for (j = 1; j < leng; j++) {
assert(i < inend);
i++;
ZopfliUpdateHash(in, i, inend, h);
}
}
}
```
|
/content/code_sandbox/library/JQLibrary/src/JQZopfli/zopfli/lz77.c
|
c
| 2016-05-15T04:09:51
| 2024-08-15T07:23:05
|
JQTools
|
188080501/JQTools
| 1,683
| 6,169
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.