Initial commit

sources/com/google/zxing/pdf417/detector/Detector.java

@@ -0,0 +1,296 @@
+package com.google.zxing.pdf417.detector;
+
+import com.google.zxing.BinaryBitmap;
+import com.google.zxing.DecodeHintType;
+import com.google.zxing.NotFoundException;
+import com.google.zxing.ResultPoint;
+import com.google.zxing.common.BitMatrix;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public final class Detector {
+    private static final int[] a = {0, 4, 1, 5};
+    private static final int[] b = {6, 2, 7, 3};
+    private static final int[] c = {8, 1, 1, 1, 1, 1, 1, 3};
+    private static final int[] d = {7, 1, 1, 3, 1, 1, 1, 2, 1};
+
+    public static PDF417DetectorResult a(BinaryBitmap binaryBitmap, Map<DecodeHintType, ?> map, boolean z) throws NotFoundException {
+        BitMatrix a2 = binaryBitmap.a();
+        List<ResultPoint[]> a3 = a(z, a2);
+        if (a3.isEmpty()) {
+            a2 = a2.m15clone();
+            a2.l();
+            a3 = a(z, a2);
+        }
+        return new PDF417DetectorResult(a2, a3);
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:10:0x001d, code lost:
+    
+        if (r5 == false) goto L31;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:11:0x001f, code lost:
+    
+        r4 = r0.iterator();
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:13:0x0027, code lost:
+    
+        if (r4.hasNext() == false) goto L36;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:14:0x0029, code lost:
+    
+        r5 = (com.google.zxing.ResultPoint[]) r4.next();
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:15:0x0031, code lost:
+    
+        if (r5[1] == null) goto L17;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:16:0x0033, code lost:
+    
+        r3 = (int) java.lang.Math.max(r3, r5[1].b());
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:18:0x0041, code lost:
+    
+        if (r5[3] == null) goto L38;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:20:0x0043, code lost:
+    
+        r3 = java.lang.Math.max(r3, (int) r5[3].b());
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    private static java.util.List<com.google.zxing.ResultPoint[]> a(boolean r8, com.google.zxing.common.BitMatrix r9) {
+        /*
+            java.util.ArrayList r0 = new java.util.ArrayList
+            r0.<init>()
+            r1 = 1
+            r2 = 0
+            r3 = 0
+        L8:
+            r4 = 0
+            r5 = 0
+        La:
+            int r6 = r9.i()
+            if (r3 >= r6) goto L7c
+            com.google.zxing.ResultPoint[] r4 = a(r9, r3, r4)
+            r6 = r4[r2]
+            if (r6 != 0) goto L52
+            r6 = 3
+            r7 = r4[r6]
+            if (r7 != 0) goto L52
+            if (r5 == 0) goto L7c
+            java.util.Iterator r4 = r0.iterator()
+        L23:
+            boolean r5 = r4.hasNext()
+            if (r5 == 0) goto L4f
+            java.lang.Object r5 = r4.next()
+            com.google.zxing.ResultPoint[] r5 = (com.google.zxing.ResultPoint[]) r5
+            r7 = r5[r1]
+            if (r7 == 0) goto L3f
+            float r3 = (float) r3
+            r7 = r5[r1]
+            float r7 = r7.b()
+            float r3 = java.lang.Math.max(r3, r7)
+            int r3 = (int) r3
+        L3f:
+            r7 = r5[r6]
+            if (r7 == 0) goto L23
+            r5 = r5[r6]
+            float r5 = r5.b()
+            int r5 = (int) r5
+            int r3 = java.lang.Math.max(r3, r5)
+            goto L23
+        L4f:
+            int r3 = r3 + 5
+            goto L8
+        L52:
+            r0.add(r4)
+            if (r8 == 0) goto L7c
+            r3 = 2
+            r5 = r4[r3]
+            if (r5 == 0) goto L6a
+            r5 = r4[r3]
+            float r5 = r5.a()
+            int r5 = (int) r5
+            r3 = r4[r3]
+            float r3 = r3.b()
+            goto L78
+        L6a:
+            r3 = 4
+            r5 = r4[r3]
+            float r5 = r5.a()
+            int r5 = (int) r5
+            r3 = r4[r3]
+            float r3 = r3.b()
+        L78:
+            int r3 = (int) r3
+            r4 = r5
+            r5 = 1
+            goto La
+        L7c:
+            return r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.zxing.pdf417.detector.Detector.a(boolean, com.google.zxing.common.BitMatrix):java.util.List");
+    }
+
+    private static ResultPoint[] a(BitMatrix bitMatrix, int i, int i2) {
+        int i3 = bitMatrix.i();
+        int k = bitMatrix.k();
+        ResultPoint[] resultPointArr = new ResultPoint[8];
+        a(resultPointArr, a(bitMatrix, i3, k, i, i2, c), a);
+        if (resultPointArr[4] != null) {
+            i2 = (int) resultPointArr[4].a();
+            i = (int) resultPointArr[4].b();
+        }
+        a(resultPointArr, a(bitMatrix, i3, k, i, i2, d), b);
+        return resultPointArr;
+    }
+
+    private static void a(ResultPoint[] resultPointArr, ResultPoint[] resultPointArr2, int[] iArr) {
+        for (int i = 0; i < iArr.length; i++) {
+            resultPointArr[iArr[i]] = resultPointArr2[i];
+        }
+    }
+
+    private static ResultPoint[] a(BitMatrix bitMatrix, int i, int i2, int i3, int i4, int[] iArr) {
+        boolean z;
+        int i5;
+        int[] iArr2;
+        ResultPoint[] resultPointArr = new ResultPoint[4];
+        int[] iArr3 = new int[iArr.length];
+        int i6 = i3;
+        while (true) {
+            if (i6 >= i) {
+                z = false;
+                break;
+            }
+            int[] a2 = a(bitMatrix, i4, i6, i2, false, iArr, iArr3);
+            if (a2 != null) {
+                while (true) {
+                    iArr2 = a2;
+                    if (i6 <= 0) {
+                        break;
+                    }
+                    i6--;
+                    a2 = a(bitMatrix, i4, i6, i2, false, iArr, iArr3);
+                    if (a2 == null) {
+                        i6++;
+                        break;
+                    }
+                }
+                float f = i6;
+                resultPointArr[0] = new ResultPoint(iArr2[0], f);
+                resultPointArr[1] = new ResultPoint(iArr2[1], f);
+                z = true;
+            } else {
+                i6 += 5;
+            }
+        }
+        int i7 = i6 + 1;
+        if (z) {
+            int[] iArr4 = {(int) resultPointArr[0].a(), (int) resultPointArr[1].a()};
+            int i8 = i7;
+            int i9 = 0;
+            while (true) {
+                if (i8 >= i) {
+                    i5 = i9;
+                    break;
+                }
+                i5 = i9;
+                int[] a3 = a(bitMatrix, iArr4[0], i8, i2, false, iArr, iArr3);
+                if (a3 != null && Math.abs(iArr4[0] - a3[0]) < 5 && Math.abs(iArr4[1] - a3[1]) < 5) {
+                    iArr4 = a3;
+                    i9 = 0;
+                } else {
+                    if (i5 > 25) {
+                        break;
+                    }
+                    i9 = i5 + 1;
+                }
+                i8++;
+            }
+            i7 = i8 - (i5 + 1);
+            float f2 = i7;
+            resultPointArr[2] = new ResultPoint(iArr4[0], f2);
+            resultPointArr[3] = new ResultPoint(iArr4[1], f2);
+        }
+        if (i7 - i6 < 10) {
+            Arrays.fill(resultPointArr, (Object) null);
+        }
+        return resultPointArr;
+    }
+
+    private static int[] a(BitMatrix bitMatrix, int i, int i2, int i3, boolean z, int[] iArr, int[] iArr2) {
+        Arrays.fill(iArr2, 0, iArr2.length, 0);
+        int i4 = 0;
+        while (bitMatrix.b(i, i2) && i > 0) {
+            int i5 = i4 + 1;
+            if (i4 >= 3) {
+                break;
+            }
+            i--;
+            i4 = i5;
+        }
+        int length = iArr.length;
+        int i6 = i;
+        boolean z2 = z;
+        int i7 = 0;
+        while (i < i3) {
+            if (bitMatrix.b(i, i2) != z2) {
+                iArr2[i7] = iArr2[i7] + 1;
+            } else {
+                if (i7 != length - 1) {
+                    i7++;
+                } else {
+                    if (a(iArr2, iArr, 0.8f) < 0.42f) {
+                        return new int[]{i6, i};
+                    }
+                    i6 += iArr2[0] + iArr2[1];
+                    int i8 = i7 - 1;
+                    System.arraycopy(iArr2, 2, iArr2, 0, i8);
+                    iArr2[i8] = 0;
+                    iArr2[i7] = 0;
+                    i7--;
+                }
+                iArr2[i7] = 1;
+                z2 = !z2;
+            }
+            i++;
+        }
+        if (i7 != length - 1 || a(iArr2, iArr, 0.8f) >= 0.42f) {
+            return null;
+        }
+        return new int[]{i6, i - 1};
+    }
+
+    private static float a(int[] iArr, int[] iArr2, float f) {
+        int length = iArr.length;
+        int i = 0;
+        int i2 = 0;
+        for (int i3 = 0; i3 < length; i3++) {
+            i += iArr[i3];
+            i2 += iArr2[i3];
+        }
+        if (i < i2) {
+            return Float.POSITIVE_INFINITY;
+        }
+        float f2 = i;
+        float f3 = f2 / i2;
+        float f4 = f * f3;
+        float f5 = 0.0f;
+        for (int i4 = 0; i4 < length; i4++) {
+            float f6 = iArr2[i4] * f3;
+            float f7 = iArr[i4];
+            float f8 = f7 > f6 ? f7 - f6 : f6 - f7;
+            if (f8 > f4) {
+                return Float.POSITIVE_INFINITY;
+            }
+            f5 += f8;
+        }
+        return f5 / f2;
+    }
+}

sources/com/google/zxing/pdf417/detector/PDF417DetectorResult.java

@@ -0,0 +1,24 @@
+package com.google.zxing.pdf417.detector;
+
+import com.google.zxing.ResultPoint;
+import com.google.zxing.common.BitMatrix;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public final class PDF417DetectorResult {
+    private final BitMatrix a;
+    private final List<ResultPoint[]> b;
+
+    public PDF417DetectorResult(BitMatrix bitMatrix, List<ResultPoint[]> list) {
+        this.a = bitMatrix;
+        this.b = list;
+    }
+
+    public BitMatrix a() {
+        return this.a;
+    }
+
+    public List<ResultPoint[]> b() {
+        return this.b;
+    }
+}