mirror of
https://github.com/Pinball3D/Rabbit-R1.git
synced 2025-01-09 13:43:22 +00:00
297 lines
12 KiB
Java
297 lines
12 KiB
Java
package com.google.zxing.oned.rss;
|
|
|
|
import com.google.zxing.BarcodeFormat;
|
|
import com.google.zxing.DecodeHintType;
|
|
import com.google.zxing.NotFoundException;
|
|
import com.google.zxing.Result;
|
|
import com.google.zxing.ResultPoint;
|
|
import com.google.zxing.ResultPointCallback;
|
|
import com.google.zxing.common.BitArray;
|
|
import com.google.zxing.common.detector.MathUtils;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collection;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import okhttp3.internal.ws.WebSocketProtocol;
|
|
|
|
/* loaded from: classes3.dex */
|
|
public final class RSS14Reader extends AbstractRSSReader {
|
|
private final List<Pair> possibleLeftPairs = new ArrayList();
|
|
private final List<Pair> possibleRightPairs = new ArrayList();
|
|
private static final int[] OUTSIDE_EVEN_TOTAL_SUBSET = {1, 10, 34, 70, WebSocketProtocol.PAYLOAD_SHORT};
|
|
private static final int[] INSIDE_ODD_TOTAL_SUBSET = {4, 20, 48, 81};
|
|
private static final int[] OUTSIDE_GSUM = {0, 161, 961, 2015, 2715};
|
|
private static final int[] INSIDE_GSUM = {0, 336, 1036, 1516};
|
|
private static final int[] OUTSIDE_ODD_WIDEST = {8, 6, 4, 3, 1};
|
|
private static final int[] INSIDE_ODD_WIDEST = {2, 4, 6, 8};
|
|
private static final int[][] FINDER_PATTERNS = {new int[]{3, 8, 2, 1}, new int[]{3, 5, 5, 1}, new int[]{3, 3, 7, 1}, new int[]{3, 1, 9, 1}, new int[]{2, 7, 4, 1}, new int[]{2, 5, 6, 1}, new int[]{2, 3, 8, 1}, new int[]{1, 5, 7, 1}, new int[]{1, 3, 9, 1}};
|
|
|
|
@Override // com.google.zxing.oned.OneDReader
|
|
public Result decodeRow(int i, BitArray bitArray, Map<DecodeHintType, ?> map) throws NotFoundException {
|
|
addOrTally(this.possibleLeftPairs, decodePair(bitArray, false, i, map));
|
|
bitArray.reverse();
|
|
addOrTally(this.possibleRightPairs, decodePair(bitArray, true, i, map));
|
|
bitArray.reverse();
|
|
for (Pair pair : this.possibleLeftPairs) {
|
|
if (pair.getCount() > 1) {
|
|
for (Pair pair2 : this.possibleRightPairs) {
|
|
if (pair2.getCount() > 1 && checkChecksum(pair, pair2)) {
|
|
return constructResult(pair, pair2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
throw NotFoundException.getNotFoundInstance();
|
|
}
|
|
|
|
private static void addOrTally(Collection<Pair> collection, Pair pair) {
|
|
if (pair == null) {
|
|
return;
|
|
}
|
|
for (Pair pair2 : collection) {
|
|
if (pair2.getValue() == pair.getValue()) {
|
|
pair2.incrementCount();
|
|
return;
|
|
}
|
|
}
|
|
collection.add(pair);
|
|
}
|
|
|
|
@Override // com.google.zxing.oned.OneDReader, com.google.zxing.Reader
|
|
public void reset() {
|
|
this.possibleLeftPairs.clear();
|
|
this.possibleRightPairs.clear();
|
|
}
|
|
|
|
private static Result constructResult(Pair pair, Pair pair2) {
|
|
String valueOf = String.valueOf((pair.getValue() * 4537077) + pair2.getValue());
|
|
StringBuilder sb = new StringBuilder(14);
|
|
for (int length = 13 - valueOf.length(); length > 0; length--) {
|
|
sb.append('0');
|
|
}
|
|
sb.append(valueOf);
|
|
int i = 0;
|
|
for (int i2 = 0; i2 < 13; i2++) {
|
|
int charAt = sb.charAt(i2) - '0';
|
|
if ((i2 & 1) == 0) {
|
|
charAt *= 3;
|
|
}
|
|
i += charAt;
|
|
}
|
|
int i3 = 10 - (i % 10);
|
|
if (i3 == 10) {
|
|
i3 = 0;
|
|
}
|
|
sb.append(i3);
|
|
ResultPoint[] resultPoints = pair.getFinderPattern().getResultPoints();
|
|
ResultPoint[] resultPoints2 = pair2.getFinderPattern().getResultPoints();
|
|
return new Result(sb.toString(), null, new ResultPoint[]{resultPoints[0], resultPoints[1], resultPoints2[0], resultPoints2[1]}, BarcodeFormat.RSS_14);
|
|
}
|
|
|
|
private static boolean checkChecksum(Pair pair, Pair pair2) {
|
|
int checksumPortion = (pair.getChecksumPortion() + (pair2.getChecksumPortion() * 16)) % 79;
|
|
int value = (pair.getFinderPattern().getValue() * 9) + pair2.getFinderPattern().getValue();
|
|
if (value > 72) {
|
|
value--;
|
|
}
|
|
if (value > 8) {
|
|
value--;
|
|
}
|
|
return checksumPortion == value;
|
|
}
|
|
|
|
private Pair decodePair(BitArray bitArray, boolean z, int i, Map<DecodeHintType, ?> map) {
|
|
try {
|
|
FinderPattern parseFoundFinderPattern = parseFoundFinderPattern(bitArray, i, z, findFinderPattern(bitArray, z));
|
|
ResultPointCallback resultPointCallback = map == null ? null : (ResultPointCallback) map.get(DecodeHintType.NEED_RESULT_POINT_CALLBACK);
|
|
if (resultPointCallback != null) {
|
|
int[] startEnd = parseFoundFinderPattern.getStartEnd();
|
|
float f = ((startEnd[0] + startEnd[1]) - 1) / 2.0f;
|
|
if (z) {
|
|
f = (bitArray.getSize() - 1) - f;
|
|
}
|
|
resultPointCallback.foundPossibleResultPoint(new ResultPoint(f, i));
|
|
}
|
|
DataCharacter decodeDataCharacter = decodeDataCharacter(bitArray, parseFoundFinderPattern, true);
|
|
DataCharacter decodeDataCharacter2 = decodeDataCharacter(bitArray, parseFoundFinderPattern, false);
|
|
return new Pair((decodeDataCharacter.getValue() * 1597) + decodeDataCharacter2.getValue(), decodeDataCharacter.getChecksumPortion() + (decodeDataCharacter2.getChecksumPortion() * 4), parseFoundFinderPattern);
|
|
} catch (NotFoundException unused) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private DataCharacter decodeDataCharacter(BitArray bitArray, FinderPattern finderPattern, boolean z) throws NotFoundException {
|
|
int[] dataCharacterCounters = getDataCharacterCounters();
|
|
Arrays.fill(dataCharacterCounters, 0);
|
|
if (z) {
|
|
recordPatternInReverse(bitArray, finderPattern.getStartEnd()[0], dataCharacterCounters);
|
|
} else {
|
|
recordPattern(bitArray, finderPattern.getStartEnd()[1], dataCharacterCounters);
|
|
int i = 0;
|
|
for (int length = dataCharacterCounters.length - 1; i < length; length--) {
|
|
int i2 = dataCharacterCounters[i];
|
|
dataCharacterCounters[i] = dataCharacterCounters[length];
|
|
dataCharacterCounters[length] = i2;
|
|
i++;
|
|
}
|
|
}
|
|
int i3 = z ? 16 : 15;
|
|
float sum = MathUtils.sum(dataCharacterCounters) / i3;
|
|
int[] oddCounts = getOddCounts();
|
|
int[] evenCounts = getEvenCounts();
|
|
float[] oddRoundingErrors = getOddRoundingErrors();
|
|
float[] evenRoundingErrors = getEvenRoundingErrors();
|
|
for (int i4 = 0; i4 < dataCharacterCounters.length; i4++) {
|
|
float f = dataCharacterCounters[i4] / sum;
|
|
int i5 = (int) (0.5f + f);
|
|
if (i5 <= 0) {
|
|
i5 = 1;
|
|
} else if (i5 > 8) {
|
|
i5 = 8;
|
|
}
|
|
int i6 = i4 / 2;
|
|
if ((i4 & 1) == 0) {
|
|
oddCounts[i6] = i5;
|
|
oddRoundingErrors[i6] = f - i5;
|
|
} else {
|
|
evenCounts[i6] = i5;
|
|
evenRoundingErrors[i6] = f - i5;
|
|
}
|
|
}
|
|
adjustOddEvenCounts(z, i3);
|
|
int i7 = 0;
|
|
int i8 = 0;
|
|
for (int length2 = oddCounts.length - 1; length2 >= 0; length2--) {
|
|
int i9 = oddCounts[length2];
|
|
i7 = (i7 * 9) + i9;
|
|
i8 += i9;
|
|
}
|
|
int i10 = 0;
|
|
int i11 = 0;
|
|
for (int length3 = evenCounts.length - 1; length3 >= 0; length3--) {
|
|
int i12 = evenCounts[length3];
|
|
i10 = (i10 * 9) + i12;
|
|
i11 += i12;
|
|
}
|
|
int i13 = i7 + (i10 * 3);
|
|
if (!z) {
|
|
if ((i11 & 1) != 0 || i11 > 10 || i11 < 4) {
|
|
throw NotFoundException.getNotFoundInstance();
|
|
}
|
|
int i14 = (10 - i11) / 2;
|
|
int i15 = INSIDE_ODD_WIDEST[i14];
|
|
return new DataCharacter((RSSUtils.getRSSvalue(evenCounts, 9 - i15, false) * INSIDE_ODD_TOTAL_SUBSET[i14]) + RSSUtils.getRSSvalue(oddCounts, i15, true) + INSIDE_GSUM[i14], i13);
|
|
}
|
|
if ((i8 & 1) != 0 || i8 > 12 || i8 < 4) {
|
|
throw NotFoundException.getNotFoundInstance();
|
|
}
|
|
int i16 = (12 - i8) / 2;
|
|
int i17 = OUTSIDE_ODD_WIDEST[i16];
|
|
return new DataCharacter((RSSUtils.getRSSvalue(oddCounts, i17, false) * OUTSIDE_EVEN_TOTAL_SUBSET[i16]) + RSSUtils.getRSSvalue(evenCounts, 9 - i17, true) + OUTSIDE_GSUM[i16], i13);
|
|
}
|
|
|
|
private int[] findFinderPattern(BitArray bitArray, boolean z) throws NotFoundException {
|
|
int[] decodeFinderCounters = getDecodeFinderCounters();
|
|
decodeFinderCounters[0] = 0;
|
|
decodeFinderCounters[1] = 0;
|
|
decodeFinderCounters[2] = 0;
|
|
decodeFinderCounters[3] = 0;
|
|
int size = bitArray.getSize();
|
|
int i = 0;
|
|
boolean z2 = false;
|
|
while (i < size) {
|
|
z2 = !bitArray.get(i);
|
|
if (z == z2) {
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
int i2 = 0;
|
|
int i3 = i;
|
|
while (i < size) {
|
|
if (bitArray.get(i) != z2) {
|
|
decodeFinderCounters[i2] = decodeFinderCounters[i2] + 1;
|
|
} else {
|
|
if (i2 != 3) {
|
|
i2++;
|
|
} else {
|
|
if (isFinderPattern(decodeFinderCounters)) {
|
|
return new int[]{i3, i};
|
|
}
|
|
i3 += decodeFinderCounters[0] + decodeFinderCounters[1];
|
|
decodeFinderCounters[0] = decodeFinderCounters[2];
|
|
decodeFinderCounters[1] = decodeFinderCounters[3];
|
|
decodeFinderCounters[2] = 0;
|
|
decodeFinderCounters[3] = 0;
|
|
i2--;
|
|
}
|
|
decodeFinderCounters[i2] = 1;
|
|
z2 = !z2;
|
|
}
|
|
i++;
|
|
}
|
|
throw NotFoundException.getNotFoundInstance();
|
|
}
|
|
|
|
private FinderPattern parseFoundFinderPattern(BitArray bitArray, int i, boolean z, int[] iArr) throws NotFoundException {
|
|
int i2;
|
|
int i3;
|
|
boolean z2 = bitArray.get(iArr[0]);
|
|
int i4 = iArr[0] - 1;
|
|
while (i4 >= 0 && z2 != bitArray.get(i4)) {
|
|
i4--;
|
|
}
|
|
int i5 = i4 + 1;
|
|
int i6 = iArr[0] - i5;
|
|
int[] decodeFinderCounters = getDecodeFinderCounters();
|
|
System.arraycopy(decodeFinderCounters, 0, decodeFinderCounters, 1, decodeFinderCounters.length - 1);
|
|
decodeFinderCounters[0] = i6;
|
|
int parseFinderValue = parseFinderValue(decodeFinderCounters, FINDER_PATTERNS);
|
|
int i7 = iArr[1];
|
|
if (z) {
|
|
int size = (bitArray.getSize() - 1) - i5;
|
|
i2 = (bitArray.getSize() - 1) - i7;
|
|
i3 = size;
|
|
} else {
|
|
i2 = i7;
|
|
i3 = i5;
|
|
}
|
|
return new FinderPattern(parseFinderValue, new int[]{i5, iArr[1]}, i3, i2, i);
|
|
}
|
|
|
|
/* JADX WARN: Code restructure failed: missing block: B:67:0x0041, code lost:
|
|
|
|
r2 = true;
|
|
r5 = false;
|
|
*/
|
|
/* JADX WARN: Code restructure failed: missing block: B:77:0x003f, code lost:
|
|
|
|
if (r1 < 4) goto L25;
|
|
*/
|
|
/* JADX WARN: Code restructure failed: missing block: B:7:0x0026, code lost:
|
|
|
|
if (r1 < 4) goto L25;
|
|
*/
|
|
/* JADX WARN: Code restructure failed: missing block: B:8:0x0044, code lost:
|
|
|
|
r2 = false;
|
|
r5 = false;
|
|
*/
|
|
/* JADX WARN: Removed duplicated region for block: B:24:0x009e */
|
|
/* JADX WARN: Removed duplicated region for block: B:30:0x00b3 */
|
|
/* JADX WARN: Removed duplicated region for block: B:32:0x00c0 */
|
|
/* JADX WARN: Removed duplicated region for block: B:37:0x00d5 */
|
|
/* JADX WARN: Removed duplicated region for block: B:39:? A[RETURN, SYNTHETIC] */
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
private void adjustOddEvenCounts(boolean r10, int r11) throws com.google.zxing.NotFoundException {
|
|
/*
|
|
Method dump skipped, instructions count: 230
|
|
To view this dump add '--comments-level debug' option
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: com.google.zxing.oned.rss.RSS14Reader.adjustOddEvenCounts(boolean, int):void");
|
|
}
|
|
}
|