Initial commit

sources/com/google/zxing/datamatrix/DataMatrixWriter.java

@@ -0,0 +1,130 @@
+package com.google.zxing.datamatrix;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.Dimension;
+import com.google.zxing.EncodeHintType;
+import com.google.zxing.Writer;
+import com.google.zxing.common.BitMatrix;
+import com.google.zxing.datamatrix.encoder.DefaultPlacement;
+import com.google.zxing.datamatrix.encoder.ErrorCorrection;
+import com.google.zxing.datamatrix.encoder.HighLevelEncoder;
+import com.google.zxing.datamatrix.encoder.SymbolInfo;
+import com.google.zxing.datamatrix.encoder.SymbolShapeHint;
+import com.google.zxing.qrcode.encoder.ByteMatrix;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public final class DataMatrixWriter implements Writer {
+    @Override // com.google.zxing.Writer
+    public BitMatrix a(String str, BarcodeFormat barcodeFormat, int i, int i2, Map<EncodeHintType, ?> map) {
+        Dimension dimension;
+        if (str.isEmpty()) {
+            throw new IllegalArgumentException("Found empty contents");
+        }
+        if (barcodeFormat != BarcodeFormat.DATA_MATRIX) {
+            throw new IllegalArgumentException("Can only encode DATA_MATRIX, but got ".concat(String.valueOf(barcodeFormat)));
+        }
+        if (i < 0 || i2 < 0) {
+            throw new IllegalArgumentException("Requested dimensions can't be negative: " + i + 'x' + i2);
+        }
+        SymbolShapeHint symbolShapeHint = SymbolShapeHint.FORCE_NONE;
+        Dimension dimension2 = null;
+        if (map != null) {
+            SymbolShapeHint symbolShapeHint2 = (SymbolShapeHint) map.get(EncodeHintType.DATA_MATRIX_SHAPE);
+            if (symbolShapeHint2 != null) {
+                symbolShapeHint = symbolShapeHint2;
+            }
+            dimension = (Dimension) map.get(EncodeHintType.MIN_SIZE);
+            if (dimension == null) {
+                dimension = null;
+            }
+            Dimension dimension3 = (Dimension) map.get(EncodeHintType.MAX_SIZE);
+            if (dimension3 != null) {
+                dimension2 = dimension3;
+            }
+        } else {
+            dimension = null;
+        }
+        String a = HighLevelEncoder.a(str, symbolShapeHint, dimension, dimension2);
+        SymbolInfo a2 = SymbolInfo.a(a.length(), symbolShapeHint, dimension, dimension2, true);
+        DefaultPlacement defaultPlacement = new DefaultPlacement(ErrorCorrection.a(a, a2), a2.e(), a2.d());
+        defaultPlacement.a();
+        return a(defaultPlacement, a2, i, i2);
+    }
+
+    private static BitMatrix a(DefaultPlacement defaultPlacement, SymbolInfo symbolInfo, int i, int i2) {
+        int e = symbolInfo.e();
+        int d = symbolInfo.d();
+        ByteMatrix byteMatrix = new ByteMatrix(symbolInfo.g(), symbolInfo.f());
+        int i3 = 0;
+        for (int i4 = 0; i4 < d; i4++) {
+            if (i4 % symbolInfo.e == 0) {
+                int i5 = 0;
+                for (int i6 = 0; i6 < symbolInfo.g(); i6++) {
+                    byteMatrix.a(i5, i3, i6 % 2 == 0);
+                    i5++;
+                }
+                i3++;
+            }
+            int i7 = 0;
+            for (int i8 = 0; i8 < e; i8++) {
+                if (i8 % symbolInfo.d == 0) {
+                    byteMatrix.a(i7, i3, true);
+                    i7++;
+                }
+                byteMatrix.a(i7, i3, defaultPlacement.a(i8, i4));
+                i7++;
+                int i9 = symbolInfo.d;
+                if (i8 % i9 == i9 - 1) {
+                    byteMatrix.a(i7, i3, i4 % 2 == 0);
+                    i7++;
+                }
+            }
+            i3++;
+            int i10 = symbolInfo.e;
+            if (i4 % i10 == i10 - 1) {
+                int i11 = 0;
+                for (int i12 = 0; i12 < symbolInfo.g(); i12++) {
+                    byteMatrix.a(i11, i3, true);
+                    i11++;
+                }
+                i3++;
+            }
+        }
+        return a(byteMatrix, i, i2);
+    }
+
+    private static BitMatrix a(ByteMatrix byteMatrix, int i, int i2) {
+        BitMatrix bitMatrix;
+        int c = byteMatrix.c();
+        int b = byteMatrix.b();
+        int max = Math.max(i, c);
+        int max2 = Math.max(i2, b);
+        int min = Math.min(max / c, max2 / b);
+        int i3 = (max - (c * min)) / 2;
+        int i4 = (max2 - (b * min)) / 2;
+        if (i2 >= b && i >= c) {
+            bitMatrix = new BitMatrix(i, i2);
+        } else {
+            bitMatrix = new BitMatrix(c, b);
+            i3 = 0;
+            i4 = 0;
+        }
+        bitMatrix.a();
+        int i5 = 0;
+        while (i5 < b) {
+            int i6 = i3;
+            int i7 = 0;
+            while (i7 < c) {
+                if (byteMatrix.a(i7, i5) == 1) {
+                    bitMatrix.a(i6, i4, min, min);
+                }
+                i7++;
+                i6 += min;
+            }
+            i5++;
+            i4 += min;
+        }
+        return bitMatrix;
+    }
+}