/*
|
* Copyright 2013 ZXing authors
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
#import "ZXAztecCode.h"
|
#import "ZXAztecEncoder.h"
|
#import "ZXAztecHighLevelEncoder.h"
|
#import "ZXBitArray.h"
|
#import "ZXBitMatrix.h"
|
#import "ZXByteArray.h"
|
#import "ZXGenericGF.h"
|
#import "ZXIntArray.h"
|
#import "ZXReedSolomonEncoder.h"
|
|
const int ZX_AZTEC_DEFAULT_EC_PERCENT = 33; // default minimal percentage of error check words
|
const int ZX_AZTEC_DEFAULT_LAYERS = 0;
|
const int ZX_AZTEC_MAX_NB_BITS = 32;
|
const int ZX_AZTEC_MAX_NB_BITS_COMPACT = 4;
|
|
const int ZX_AZTEC_WORD_SIZE[] = {
|
4, 6, 6, 8, 8, 8, 8, 8, 8, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
|
12, 12, 12, 12, 12, 12, 12, 12, 12, 12
|
};
|
|
@implementation ZXAztecEncoder
|
|
+ (ZXAztecCode *)encode:(ZXByteArray *)data {
|
return [self encode:data minECCPercent:ZX_AZTEC_DEFAULT_EC_PERCENT userSpecifiedLayers:ZX_AZTEC_DEFAULT_LAYERS];
|
}
|
|
+ (ZXAztecCode *)encode:(ZXByteArray *)data minECCPercent:(int)minECCPercent userSpecifiedLayers:(int)userSpecifiedLayers {
|
// High-level encode
|
ZXBitArray *bits = [[[ZXAztecHighLevelEncoder alloc] initWithText:data] encode];
|
|
// stuff bits and choose symbol size
|
int eccBits = bits.size * minECCPercent / 100 + 11;
|
int totalSizeBits = bits.size + eccBits;
|
BOOL compact;
|
int layers;
|
int totalBitsInLayer;
|
int wordSize = ZX_AZTEC_WORD_SIZE[0];
|
ZXBitArray *stuffedBits;
|
if (userSpecifiedLayers != ZX_AZTEC_DEFAULT_LAYERS) {
|
compact = userSpecifiedLayers < 0;
|
layers = abs(userSpecifiedLayers);
|
if (layers > (compact ? ZX_AZTEC_MAX_NB_BITS_COMPACT : ZX_AZTEC_MAX_NB_BITS)) {
|
@throw [NSException exceptionWithName:@"IllegalArgumentException"
|
reason:[NSString stringWithFormat:@"Illegal value %d for layers", userSpecifiedLayers]
|
userInfo:nil];
|
}
|
totalBitsInLayer = [self totalBitsInLayer:layers compact:compact];
|
wordSize = ZX_AZTEC_WORD_SIZE[layers];
|
int usableBitsInLayers = totalBitsInLayer - (totalBitsInLayer % wordSize);
|
stuffedBits = [self stuffBits:bits wordSize:wordSize];
|
if (stuffedBits.size + eccBits > usableBitsInLayers) {
|
@throw [NSException exceptionWithName:@"IllegalArgumentException"
|
reason:@"Data too large for user specified layer"
|
userInfo:nil];
|
}
|
if (compact && stuffedBits.size > wordSize * 64) {
|
// Compact format only allows 64 data words, though C4 can hold more words than that
|
@throw [NSException exceptionWithName:@"IllegalArgumentException"
|
reason:@"Data too large for user specified layer"
|
userInfo:nil];
|
}
|
} else {
|
// We look at the possible table sizes in the order Compact1, Compact2, Compact3,
|
// Compact4, Normal4,... Normal(i) for i < 4 isn't typically used since Compact(i+1)
|
// is the same size, but has more data.
|
for (int i = 0; ; i++) {
|
if (i > ZX_AZTEC_MAX_NB_BITS) {
|
@throw [NSException exceptionWithName:@"IllegalArgumentException"
|
reason:@"Data too large for an Aztec code"
|
userInfo:nil];
|
}
|
compact = i <= 3;
|
layers = compact ? i + 1 : i;
|
totalBitsInLayer = [self totalBitsInLayer:layers compact:compact];
|
if (totalSizeBits > totalBitsInLayer) {
|
continue;
|
}
|
// [Re]stuff the bits if this is the first opportunity, or if the
|
// wordSize has changed
|
if (wordSize != ZX_AZTEC_WORD_SIZE[layers]) {
|
wordSize = ZX_AZTEC_WORD_SIZE[layers];
|
stuffedBits = [self stuffBits:bits wordSize:wordSize];
|
}
|
int usableBitsInLayers = totalBitsInLayer - (totalBitsInLayer % wordSize);
|
if (compact && stuffedBits.size > wordSize * 64) {
|
// Compact format only allows 64 data words, though C4 can hold more words than that
|
continue;
|
}
|
if (stuffedBits.size + eccBits <= usableBitsInLayers) {
|
break;
|
}
|
}
|
}
|
ZXBitArray *messageBits = [self generateCheckWords:stuffedBits totalBits:totalBitsInLayer wordSize:wordSize];
|
|
// generate check words
|
int messageSizeInWords = stuffedBits.size / wordSize;
|
ZXBitArray *modeMessage = [self generateModeMessageCompact:compact layers:layers messageSizeInWords:messageSizeInWords];
|
|
// allocate symbol
|
int baseMatrixSize = compact ? 11 + layers * 4 : 14 + layers * 4; // not including alignment lines
|
int alignmentMap[baseMatrixSize];
|
memset(alignmentMap, 0, baseMatrixSize * sizeof(int));
|
int matrixSize;
|
if (compact) {
|
// no alignment marks in compact mode, alignmentMap is a no-op
|
matrixSize = baseMatrixSize;
|
for (int i = 0; i < baseMatrixSize; i++) {
|
alignmentMap[i] = i;
|
}
|
} else {
|
matrixSize = baseMatrixSize + 1 + 2 * ((baseMatrixSize / 2 - 1) / 15);
|
int origCenter = baseMatrixSize / 2;
|
int center = matrixSize / 2;
|
for (int i = 0; i < origCenter; i++) {
|
int newOffset = i + i / 15;
|
alignmentMap[origCenter - i - 1] = center - newOffset - 1;
|
alignmentMap[origCenter + i] = center + newOffset + 1;
|
}
|
}
|
ZXBitMatrix *matrix = [[ZXBitMatrix alloc] initWithDimension:matrixSize];
|
|
// draw data bits
|
for (int i = 0, rowOffset = 0; i < layers; i++) {
|
int rowSize = compact ? (layers - i) * 4 + 9 : (layers - i) * 4 + 12;
|
for (int j = 0; j < rowSize; j++) {
|
int columnOffset = j * 2;
|
for (int k = 0; k < 2; k++) {
|
if ([messageBits get:rowOffset + columnOffset + k]) {
|
[matrix setX:alignmentMap[i * 2 + k] y:alignmentMap[i * 2 + j]];
|
}
|
if ([messageBits get:rowOffset + rowSize * 2 + columnOffset + k]) {
|
[matrix setX:alignmentMap[i * 2 + j] y:alignmentMap[baseMatrixSize - 1 - i * 2 - k]];
|
}
|
if ([messageBits get:rowOffset + rowSize * 4 + columnOffset + k]) {
|
[matrix setX:alignmentMap[baseMatrixSize - 1 - i * 2 - k] y:alignmentMap[baseMatrixSize - 1 - i * 2 - j]];
|
}
|
if ([messageBits get:rowOffset + rowSize * 6 + columnOffset + k]) {
|
[matrix setX:alignmentMap[baseMatrixSize - 1 - i * 2 - j] y:alignmentMap[i * 2 + k]];
|
}
|
}
|
}
|
rowOffset += rowSize * 8;
|
}
|
|
// draw mode message
|
[self drawModeMessage:matrix compact:compact matrixSize:matrixSize modeMessage:modeMessage];
|
|
// draw alignment marks
|
if (compact) {
|
[self drawBullsEye:matrix center:matrixSize / 2 size:5];
|
} else {
|
[self drawBullsEye:matrix center:matrixSize / 2 size:7];
|
for (int i = 0, j = 0; i < baseMatrixSize / 2 - 1; i += 15, j += 16) {
|
for (int k = (matrixSize / 2) & 1; k < matrixSize; k += 2) {
|
[matrix setX:matrixSize / 2 - j y:k];
|
[matrix setX:matrixSize / 2 + j y:k];
|
[matrix setX:k y:matrixSize / 2 - j];
|
[matrix setX:k y:matrixSize / 2 + j];
|
}
|
}
|
}
|
|
ZXAztecCode *aztec = [[ZXAztecCode alloc] init];
|
aztec.compact = compact;
|
aztec.size = matrixSize;
|
aztec.layers = layers;
|
aztec.codeWords = messageSizeInWords;
|
aztec.matrix = matrix;
|
return aztec;
|
}
|
|
+ (void)drawBullsEye:(ZXBitMatrix *)matrix center:(int)center size:(int)size {
|
for (int i = 0; i < size; i += 2) {
|
for (int j = center - i; j <= center + i; j++) {
|
[matrix setX:j y:center - i];
|
[matrix setX:j y:center + i];
|
[matrix setX:center - i y:j];
|
[matrix setX:center + i y:j];
|
}
|
}
|
[matrix setX:center - size y:center - size];
|
[matrix setX:center - size + 1 y:center - size];
|
[matrix setX:center - size y:center - size + 1];
|
[matrix setX:center + size y:center - size];
|
[matrix setX:center + size y:center - size + 1];
|
[matrix setX:center + size y:center + size - 1];
|
}
|
|
+ (ZXBitArray *)generateModeMessageCompact:(BOOL)compact layers:(int)layers messageSizeInWords:(int)messageSizeInWords {
|
ZXBitArray *modeMessage = [[ZXBitArray alloc] init];
|
if (compact) {
|
[modeMessage appendBits:layers - 1 numBits:2];
|
[modeMessage appendBits:messageSizeInWords - 1 numBits:6];
|
modeMessage = [self generateCheckWords:modeMessage totalBits:28 wordSize:4];
|
} else {
|
[modeMessage appendBits:layers - 1 numBits:5];
|
[modeMessage appendBits:messageSizeInWords - 1 numBits:11];
|
modeMessage = [self generateCheckWords:modeMessage totalBits:40 wordSize:4];
|
}
|
return modeMessage;
|
}
|
|
+ (void)drawModeMessage:(ZXBitMatrix *)matrix compact:(BOOL)compact matrixSize:(int)matrixSize modeMessage:(ZXBitArray *)modeMessage {
|
int center = matrixSize / 2;
|
if (compact) {
|
for (int i = 0; i < 7; i++) {
|
int offset = center - 3 + i;
|
if ([modeMessage get:i]) {
|
[matrix setX:offset y:center - 5];
|
}
|
if ([modeMessage get:i + 7]) {
|
[matrix setX:center + 5 y:offset];
|
}
|
if ([modeMessage get:20 - i]) {
|
[matrix setX:offset y:center + 5];
|
}
|
if ([modeMessage get:27 - i]) {
|
[matrix setX:center - 5 y:offset];
|
}
|
}
|
} else {
|
for (int i = 0; i < 10; i++) {
|
int offset = center - 5 + i + i / 5;
|
if ([modeMessage get:i]) {
|
[matrix setX:offset y:center - 7];
|
}
|
if ([modeMessage get:i + 10]) {
|
[matrix setX:center + 7 y:offset];
|
}
|
if ([modeMessage get:29 - i]) {
|
[matrix setX:offset y:center + 7];
|
}
|
if ([modeMessage get:39 - i]) {
|
[matrix setX:center - 7 y:offset];
|
}
|
}
|
}
|
}
|
|
+ (ZXBitArray *)generateCheckWords:(ZXBitArray *)bitArray totalBits:(int)totalBits wordSize:(int)wordSize {
|
// bitArray is guaranteed to be a multiple of the wordSize, so no padding needed
|
int messageSizeInWords = bitArray.size / wordSize;
|
ZXReedSolomonEncoder *rs = [[ZXReedSolomonEncoder alloc] initWithField:[self getGF:wordSize]];
|
int totalWords = totalBits / wordSize;
|
|
ZXIntArray *messageWords = [self bitsToWords:bitArray wordSize:wordSize totalWords:totalWords];
|
[rs encode:messageWords ecBytes:totalWords - messageSizeInWords];
|
int startPad = totalBits % wordSize;
|
ZXBitArray *messageBits = [[ZXBitArray alloc] init];
|
[messageBits appendBits:0 numBits:startPad];
|
for (int i = 0; i < totalWords; i++) {
|
[messageBits appendBits:messageWords.array[i] numBits:wordSize];
|
}
|
return messageBits;
|
}
|
|
+ (ZXIntArray *)bitsToWords:(ZXBitArray *)stuffedBits wordSize:(int)wordSize totalWords:(int)totalWords {
|
ZXIntArray *message = [[ZXIntArray alloc] initWithLength:totalWords];
|
int i;
|
int n;
|
for (i = 0, n = stuffedBits.size / wordSize; i < n; i++) {
|
int32_t value = 0;
|
for (int j = 0; j < wordSize; j++) {
|
value |= [stuffedBits get:i * wordSize + j] ? (1 << (wordSize - j - 1)) : 0;
|
}
|
message.array[i] = value;
|
}
|
return message;
|
}
|
|
+ (ZXGenericGF *)getGF:(int)wordSize {
|
switch (wordSize) {
|
case 4:
|
return [ZXGenericGF AztecParam];
|
case 6:
|
return [ZXGenericGF AztecData6];
|
case 8:
|
return [ZXGenericGF AztecData8];
|
case 10:
|
return [ZXGenericGF AztecData10];
|
case 12:
|
return [ZXGenericGF AztecData12];
|
default:
|
return nil;
|
}
|
}
|
|
+ (ZXBitArray *)stuffBits:(ZXBitArray *)bits wordSize:(int)wordSize {
|
ZXBitArray *arrayOut = [[ZXBitArray alloc] init];
|
|
int n = bits.size;
|
int mask = (1 << wordSize) - 2;
|
for (int i = 0; i < n; i += wordSize) {
|
int word = 0;
|
for (int j = 0; j < wordSize; j++) {
|
if (i + j >= n || [bits get:i + j]) {
|
word |= 1 << (wordSize - 1 - j);
|
}
|
}
|
if ((word & mask) == mask) {
|
[arrayOut appendBits:word & mask numBits:wordSize];
|
i--;
|
} else if ((word & mask) == 0) {
|
[arrayOut appendBits:word | 1 numBits:wordSize];
|
i--;
|
} else {
|
[arrayOut appendBits:word numBits:wordSize];
|
}
|
}
|
|
return arrayOut;
|
}
|
|
+ (int)totalBitsInLayer:(int)layers compact:(BOOL)compact {
|
return ((compact ? 88 : 112) + 16 * layers) * layers;
|
}
|
|
@end
|
