ScanSize.java 9.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260
  1. package com.epson.lib.escani2;
  2. import android.support.annotation.NonNull;
  3. import android.support.annotation.VisibleForTesting;
  4. import com.epson.lib.escani2.EscanI2Lib;
  5. import epson.scan.i2lib.I2ScanParamArbiter;
  6. import epson.scan.lib.ScanSizeHelper;
  7. import java.io.Serializable;
  8. public class ScanSize implements Serializable {
  9. private int mOffsetX;
  10. private int mOffsetY;
  11. private int mPixelHeight;
  12. private int mPixelWidth;
  13. private boolean mPortrait;
  14. private PaperSize mSizeType;
  15. public enum PaperSize {
  16. A4,
  17. LETTER,
  18. LEGAL,
  19. B5,
  20. B6,
  21. A5,
  22. A6,
  23. A8,
  24. MEISHI,
  25. PCARD,
  26. AUTO,
  27. A3,
  28. MAX,
  29. PIXEL
  30. }
  31. private static int getI2AlignmentValue(int i) {
  32. return i != 1 ? 2 : 1;
  33. }
  34. static int[] get300DpiPixelFromPaperSize(PaperSize paperSize) {
  35. switch (paperSize) {
  36. case A3:
  37. return new int[]{3507, 4959};
  38. case A4:
  39. return new int[]{2480, 3507};
  40. case LETTER:
  41. return new int[]{2550, 3300};
  42. case LEGAL:
  43. return new int[]{2550, 4200};
  44. case B5:
  45. return new int[]{2149, 3035};
  46. case B6:
  47. return new int[]{1512, 2150};
  48. case A5:
  49. return new int[]{1748, 2480};
  50. case A6:
  51. return new int[]{1240, 1748};
  52. case A8:
  53. return new int[]{615, 874};
  54. case MEISHI:
  55. return new int[]{1051, 650};
  56. case PCARD:
  57. return new int[]{1011, 638};
  58. case AUTO:
  59. return new int[]{2550, 4200};
  60. default:
  61. return new int[]{-1, -1};
  62. }
  63. }
  64. public ScanSize(PaperSize paperSize, boolean z) {
  65. this.mSizeType = paperSize;
  66. this.mPortrait = z;
  67. }
  68. public ScanSize(int i, int i2, int i3, int i4) {
  69. this.mSizeType = PaperSize.PIXEL;
  70. this.mPixelWidth = i;
  71. this.mPixelHeight = i2;
  72. this.mOffsetX = i3;
  73. this.mOffsetY = i4;
  74. this.mPortrait = true;
  75. }
  76. public boolean equals(Object obj) {
  77. if (obj == null || !(obj instanceof ScanSize)) {
  78. return false;
  79. }
  80. ScanSize scanSize = (ScanSize) obj;
  81. if (!this.mSizeType.equals(scanSize.mSizeType)) {
  82. return false;
  83. }
  84. switch (this.mSizeType) {
  85. case PIXEL:
  86. if (this.mPixelWidth == scanSize.mPixelWidth && this.mPixelHeight == scanSize.mPixelHeight && this.mOffsetX == scanSize.mOffsetX && this.mOffsetY == scanSize.mOffsetY) {
  87. return true;
  88. }
  89. return false;
  90. case MAX:
  91. return true;
  92. default:
  93. return this.mPortrait;
  94. }
  95. }
  96. public int hashCode() {
  97. if (this.mSizeType == PaperSize.PIXEL) {
  98. return (((((((this.mSizeType.hashCode() * 31) + this.mPixelWidth) * 31) + this.mPixelHeight) * 31) + this.mOffsetX) * 31) + this.mOffsetY;
  99. }
  100. return this.mSizeType.hashCode();
  101. }
  102. public PaperSize getSize() {
  103. return this.mSizeType;
  104. }
  105. public boolean isPixelSize() {
  106. return this.mSizeType == PaperSize.PIXEL;
  107. }
  108. public int[] getValidScanSize(ScannerI2Info scannerI2Info, ScanI2Params scanI2Params) {
  109. int[] validScanSizeInternal = getValidScanSizeInternal(scannerI2Info, scanI2Params);
  110. if (validScanSizeInternal == null) {
  111. return null;
  112. }
  113. return adjustSizeFromScannerInfo(validScanSizeInternal, scannerI2Info, scanI2Params);
  114. }
  115. /* access modifiers changed from: package-private */
  116. @VisibleForTesting
  117. public int[] adjustSizeFromScannerInfo(@NonNull int[] iArr, @NonNull ScannerI2Info scannerI2Info, @NonNull ScanI2Params scanI2Params) {
  118. int[] sensorPixelSize = scannerI2Info.getSensorPixelSize(scanI2Params.inputUnit, scanI2Params.resolutionMain, scanI2Params.resolutionSub);
  119. if (iArr[0] > sensorPixelSize[0]) {
  120. iArr[0] = sensorPixelSize[0];
  121. }
  122. int i = (iArr[0] + iArr[2]) - sensorPixelSize[0];
  123. if (i > 0) {
  124. iArr[2] = iArr[2] - i;
  125. }
  126. if (iArr[1] > sensorPixelSize[1]) {
  127. iArr[1] = sensorPixelSize[1];
  128. }
  129. int i2 = (iArr[1] + iArr[3]) - sensorPixelSize[1];
  130. if (i2 > 0) {
  131. iArr[3] = iArr[3] - i2;
  132. }
  133. return iArr;
  134. }
  135. /* access modifiers changed from: package-private */
  136. @VisibleForTesting
  137. public int[] getValidScanSizeInternal(ScannerI2Info scannerI2Info, ScanI2Params scanI2Params) {
  138. if (scannerI2Info.isAdfAlignmentInvalid()) {
  139. scannerI2Info.adfAlignment = getI2AlignmentValue(scanI2Params.manualAdfAlignment);
  140. }
  141. if (!isPixelSize()) {
  142. return getSize(scannerI2Info, scanI2Params);
  143. }
  144. if (scanI2Params.inputUnit != EscanI2Lib.InputUnit.ADF) {
  145. return getLeftAlignPixelSizeValidScanSize(scannerI2Info, scanI2Params);
  146. }
  147. if (scannerI2Info.adfAlignment == 1) {
  148. return getCenterAlignPixelSizeValidScanSize(scannerI2Info, scanI2Params);
  149. }
  150. return getLeftAlignPixelSizeValidScanSize(scannerI2Info, scanI2Params);
  151. }
  152. private int[] getCenterAlignPixelSizeValidScanSize(ScannerI2Info scannerI2Info, ScanI2Params scanI2Params) {
  153. int[] size = getSize(scannerI2Info, scanI2Params);
  154. size[2] = 0;
  155. size[3] = 0;
  156. int[] sensorPixelSize = scannerI2Info.getSensorPixelSize(scanI2Params.inputUnit, scanI2Params.resolutionMain, scanI2Params.resolutionSub);
  157. if (size[0] > sensorPixelSize[0]) {
  158. size[0] = sensorPixelSize[0];
  159. } else {
  160. size[2] = (sensorPixelSize[0] - size[0]) / 2;
  161. }
  162. if (size[1] > sensorPixelSize[1]) {
  163. size[1] = sensorPixelSize[1];
  164. }
  165. return size;
  166. }
  167. private int[] getLeftAlignPixelSizeValidScanSize(ScannerI2Info scannerI2Info, ScanI2Params scanI2Params) {
  168. int[] size = getSize(scannerI2Info, scanI2Params);
  169. int[] sensorPixelSize = scannerI2Info.getSensorPixelSize(scanI2Params.inputUnit, scanI2Params.resolutionMain, scanI2Params.resolutionSub);
  170. if (size[0] + size[2] <= 0 || size[1] + size[3] <= 0 || size[2] >= sensorPixelSize[0] || size[3] >= sensorPixelSize[1]) {
  171. return null;
  172. }
  173. if (size[2] < 0) {
  174. size[0] = size[2] + size[0];
  175. size[2] = 0;
  176. }
  177. size[0] = size[0] + size[2] >= sensorPixelSize[0] ? sensorPixelSize[0] - size[2] : size[0];
  178. if (size[3] < 0) {
  179. size[1] = size[3] + size[1];
  180. size[3] = 0;
  181. }
  182. size[1] = size[1] + size[3] >= sensorPixelSize[1] ? sensorPixelSize[1] - size[3] : size[1];
  183. return size;
  184. }
  185. public int[] getSize(ScannerI2Info scannerI2Info, ScanI2Params scanI2Params) {
  186. return getSize(scannerI2Info, scanI2Params.inputUnit, scanI2Params.resolutionMain, scanI2Params.resolutionSub);
  187. }
  188. private int[] getSize(ScannerI2Info scannerI2Info, EscanI2Lib.InputUnit inputUnit, int i, int i2) {
  189. int[] pixel = getPixel(scannerI2Info, inputUnit, i, i2);
  190. int[] offset = getOffset(scannerI2Info, inputUnit, i, i2);
  191. return new int[]{pixel[0], pixel[1], offset[0], offset[1]};
  192. }
  193. private int[] getPixel(ScannerI2Info scannerI2Info, EscanI2Lib.InputUnit inputUnit, int i, int i2) {
  194. if (this.mSizeType == PaperSize.MAX) {
  195. return scannerI2Info.getSensorPixelSize(inputUnit, i, i2);
  196. }
  197. if (this.mSizeType == PaperSize.PIXEL) {
  198. return new int[]{this.mPixelWidth, this.mPixelHeight};
  199. }
  200. int[] iArr = get300DpiPixelFromPaperSize(this.mSizeType);
  201. if (!this.mPortrait) {
  202. int i3 = iArr[0];
  203. iArr[0] = iArr[1];
  204. iArr[1] = i3;
  205. }
  206. if (i != 300) {
  207. iArr[0] = (int) ((((double) iArr[0]) * ((double) i)) / ((double) 300));
  208. }
  209. if (i2 != 300) {
  210. iArr[1] = (int) ((((double) iArr[1]) * ((double) i2)) / ((double) 300));
  211. }
  212. return iArr;
  213. }
  214. private int[] getOffset(ScannerI2Info scannerI2Info, EscanI2Lib.InputUnit inputUnit, int i, int i2) {
  215. if (this.mSizeType == PaperSize.PIXEL) {
  216. return new int[]{this.mOffsetX, this.mOffsetY};
  217. } else if (this.mSizeType == PaperSize.MAX) {
  218. return new int[]{0, 0};
  219. } else {
  220. int[] iArr = {0, 0};
  221. iArr[0] = calcOffset(scannerI2Info.getAlignment(inputUnit), getPixel(scannerI2Info, inputUnit, i, i2)[0], (int) Math.round((((double) scannerI2Info.getSensorSize(inputUnit)[0]) * ((double) i)) / ((double) scannerI2Info.getSensorSizeBaseResolution())));
  222. return iArr;
  223. }
  224. }
  225. private int calcOffset(int i, int i2, int i3) {
  226. switch (i) {
  227. case 1:
  228. return (i3 - i2) / 2;
  229. case 2:
  230. return i3 - i2;
  231. default:
  232. return 0;
  233. }
  234. }
  235. public static ScanSize getLocaleDefaultSize() {
  236. return I2ScanParamArbiter.getI2ScanSize(ScanSizeHelper.getDefaultScanSize());
  237. }
  238. }