564 lines
23 KiB
Java
564 lines
23 KiB
Java
|
package com.kofax.kmc.ken.engines.gpu;
|
||
|
|
|
||
|
|
import android.opengl.GLES20;
|
||
|
|
import com.google.android.gms.maps.model.BitmapDescriptorFactory;
|
||
|
|
import com.kofax.kmc.ken.engines.data.DocumentDetectionSettings;
|
||
|
|
import com.kofax.kmc.ken.engines.gpu.shaders.ColorPassThroughShader;
|
||
|
|
import com.kofax.kmc.ken.engines.gpu.shaders.GrayGaussianBlur3x3Shader;
|
||
|
|
import com.kofax.kmc.ken.engines.gpu.shaders.PassThroughShader;
|
||
|
|
import com.kofax.kmc.ken.engines.gpu.shaders.RgbGaussianBlur3x3Shader;
|
||
|
|
import com.kofax.kmc.ken.engines.gpu.shaders.YuvToRgbShader;
|
||
|
|
import java.nio.Buffer;
|
||
|
|
import java.nio.ByteBuffer;
|
||
|
|
import java.nio.ByteOrder;
|
||
|
|
import java.nio.FloatBuffer;
|
||
|
|
import java.util.LinkedList;
|
||
|
|
import java.util.Queue;
|
||
|
|
import javax.microedition.khronos.egl.EGLConfig;
|
||
|
|
import javax.microedition.khronos.opengles.GL10;
|
||
|
|
|
||
|
|
/* loaded from: classes3.dex */
|
||
|
|
class f implements IGPUImageRenderer {
|
||
|
|
public static final int fC = -1;
|
||
|
|
static final float[] fH = {-1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 1.0f};
|
||
|
|
static final float[] fJ = {-1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 1.0f};
|
||
|
|
protected OpenGLESContextManager fD;
|
||
|
|
private final FloatBuffer fG;
|
||
|
|
private final FloatBuffer fI;
|
||
|
|
private final FloatBuffer fK;
|
||
|
|
private final FloatBuffer fL;
|
||
|
|
private int fM;
|
||
|
|
private int fN;
|
||
|
|
private int fO;
|
||
|
|
private int fP;
|
||
|
|
protected float fQ;
|
||
|
|
protected float fR;
|
||
|
|
private Rotation fU;
|
||
|
|
private final FloatBuffer gG;
|
||
|
|
private ByteBuffer gO;
|
||
|
|
protected ColorPassThroughShader gS;
|
||
|
|
protected GrayGaussianBlur3x3Shader gT;
|
||
|
|
protected RgbGaussianBlur3x3Shader gU;
|
||
|
|
protected YuvToRgbShader gV;
|
||
|
|
protected ImageProcessor gW;
|
||
|
|
protected boolean gX;
|
||
|
|
private ByteBuffer gb;
|
||
|
|
protected PassThroughShader gg;
|
||
|
|
public final Object fE = new Object();
|
||
|
|
private int gf = -1;
|
||
|
|
private ScaleType fV = ScaleType.CENTER_CROP;
|
||
|
|
private FrameBufferTexture fW = null;
|
||
|
|
private FrameBufferTexture gH = null;
|
||
|
|
private FrameBufferTexture fX = null;
|
||
|
|
private float[] gF = null;
|
||
|
|
private int fZ = 0;
|
||
|
|
private int ga = 0;
|
||
|
|
private long gI = 0;
|
||
|
|
private int gJ = 0;
|
||
|
|
private int gK = 0;
|
||
|
|
private double gL = 0.0d;
|
||
|
|
private int gM = 0;
|
||
|
|
long gN = 0;
|
||
|
|
private int ge = -1;
|
||
|
|
private int gP = -1;
|
||
|
|
private boolean gQ = false;
|
||
|
|
private boolean gR = false;
|
||
|
|
private boolean fF = false;
|
||
|
|
private final Queue<Runnable> fS = new LinkedList();
|
||
|
|
private final Queue<Runnable> fT = new LinkedList();
|
||
|
|
|
||
|
|
private float a(float f, float f2) {
|
||
|
|
return f != BitmapDescriptorFactory.HUE_RED ? 1.0f - f2 : f2;
|
||
|
|
}
|
||
|
|
|
||
|
|
public f(ImageProcessor imageProcessor) {
|
||
|
|
this.gW = null;
|
||
|
|
this.gX = false;
|
||
|
|
float[] fArr = fH;
|
||
|
|
FloatBuffer asFloatBuffer = ByteBuffer.allocateDirect(fArr.length << 2).order(ByteOrder.nativeOrder()).asFloatBuffer();
|
||
|
|
this.fG = asFloatBuffer;
|
||
|
|
asFloatBuffer.put(fArr).position(0);
|
||
|
|
float[] fArr2 = fJ;
|
||
|
|
FloatBuffer asFloatBuffer2 = ByteBuffer.allocateDirect(fArr2.length << 2).order(ByteOrder.nativeOrder()).asFloatBuffer();
|
||
|
|
this.fI = asFloatBuffer2;
|
||
|
|
asFloatBuffer2.put(fArr2).position(0);
|
||
|
|
FloatBuffer asFloatBuffer3 = ByteBuffer.allocateDirect(fArr.length << 2).order(ByteOrder.nativeOrder()).asFloatBuffer();
|
||
|
|
this.gG = asFloatBuffer3;
|
||
|
|
asFloatBuffer3.put(fArr).position(0);
|
||
|
|
this.fK = ByteBuffer.allocateDirect(TextureRotationUtil.TEXTURE_NO_ROTATION.length << 2).order(ByteOrder.nativeOrder()).asFloatBuffer();
|
||
|
|
FloatBuffer asFloatBuffer4 = ByteBuffer.allocateDirect(TextureRotationUtil.TEXTURE_ROTATED_270.length << 2).order(ByteOrder.nativeOrder()).asFloatBuffer();
|
||
|
|
this.fL = asFloatBuffer4;
|
||
|
|
asFloatBuffer4.clear();
|
||
|
|
asFloatBuffer4.put(TextureRotationUtil.TEXTURE_ROTATED_270).position(0);
|
||
|
|
setRotation(Rotation.NORMAL);
|
||
|
|
this.gX = true;
|
||
|
|
this.gW = imageProcessor;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // android.opengl.GLSurfaceView.Renderer
|
||
|
|
public void onSurfaceCreated(GL10 gl10, EGLConfig eGLConfig) {
|
||
|
|
GLES20.glClearColor(BitmapDescriptorFactory.HUE_RED, BitmapDescriptorFactory.HUE_RED, BitmapDescriptorFactory.HUE_RED, 1.0f);
|
||
|
|
GLES20.glDisable(2929);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // android.opengl.GLSurfaceView.Renderer
|
||
|
|
public void onSurfaceChanged(GL10 gl10, int i, int i2) {
|
||
|
|
this.fM = i;
|
||
|
|
this.fN = i2;
|
||
|
|
GLES20.glViewport(0, 0, i, i2);
|
||
|
|
P();
|
||
|
|
synchronized (this.fE) {
|
||
|
|
this.fE.notifyAll();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // android.opengl.GLSurfaceView.Renderer
|
||
|
|
public void onDrawFrame(GL10 gl10) {
|
||
|
|
synchronized (this) {
|
||
|
|
long currentTimeMillis = System.currentTimeMillis();
|
||
|
|
a(this.fS);
|
||
|
|
M();
|
||
|
|
if (this.fF) {
|
||
|
|
if (this.gI == 0) {
|
||
|
|
this.gI = currentTimeMillis;
|
||
|
|
}
|
||
|
|
if (this.ge != -1 && this.fW != null) {
|
||
|
|
N();
|
||
|
|
}
|
||
|
|
this.gF = null;
|
||
|
|
this.fX = null;
|
||
|
|
if (this.fW != null && this.gW != null) {
|
||
|
|
if (this.gX) {
|
||
|
|
int[] iArr = new int[1];
|
||
|
|
int[] iArr2 = new int[4];
|
||
|
|
GLES20.glGetIntegerv(36006, iArr, 0);
|
||
|
|
GLES20.glGetIntegerv(2978, iArr2, 0);
|
||
|
|
this.gW.processTexture(this.fW, this.gH);
|
||
|
|
GLES20.glBindFramebuffer(36160, iArr[0]);
|
||
|
|
GLES20.glViewport(iArr2[0], iArr2[1], iArr2[2], iArr2[3]);
|
||
|
|
}
|
||
|
|
if (GPUSettings.getSettings().showProcessedImageAndBounds) {
|
||
|
|
this.fX = this.gW.getProcessedTexture();
|
||
|
|
}
|
||
|
|
this.gF = this.gW.getBounds();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
long currentTimeMillis2 = System.currentTimeMillis();
|
||
|
|
if (GPUSettings.getSettings().showProcessedImageAndBounds) {
|
||
|
|
if (this.fX == null) {
|
||
|
|
this.fX = this.gQ ? this.gH : this.fW;
|
||
|
|
}
|
||
|
|
e(this.fX);
|
||
|
|
a(this.gF);
|
||
|
|
}
|
||
|
|
a(this.fT);
|
||
|
|
if (this.fF && this.fW != null) {
|
||
|
|
this.gK++;
|
||
|
|
int i = this.gM + 1;
|
||
|
|
this.gM = i;
|
||
|
|
long j = this.gN + (currentTimeMillis2 - currentTimeMillis);
|
||
|
|
this.gN = j;
|
||
|
|
if (i % 50 == 0) {
|
||
|
|
this.gL = j / i;
|
||
|
|
this.gN = 0L;
|
||
|
|
this.gM = 0;
|
||
|
|
}
|
||
|
|
long currentTimeMillis3 = System.currentTimeMillis();
|
||
|
|
long j2 = currentTimeMillis3 - this.gI;
|
||
|
|
if (j2 >= 1000) {
|
||
|
|
this.gI = currentTimeMillis3;
|
||
|
|
this.gJ = (int) ((this.gK * 1000.0f) / ((float) j2));
|
||
|
|
this.gK = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void M() {
|
||
|
|
if (this.fD == null) {
|
||
|
|
OpenGLESContextManager openGLESContextManager = new OpenGLESContextManager();
|
||
|
|
this.fD = openGLESContextManager;
|
||
|
|
this.gg = new PassThroughShader(openGLESContextManager);
|
||
|
|
this.gS = new ColorPassThroughShader(this.fD);
|
||
|
|
this.gT = new GrayGaussianBlur3x3Shader(this.fD);
|
||
|
|
this.gU = new RgbGaussianBlur3x3Shader(this.fD);
|
||
|
|
this.gV = new YuvToRgbShader(this.fD);
|
||
|
|
}
|
||
|
|
if (this.fW != null || this.fO == 0 || this.fP == 0) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
float f = GPUSettings.getSettings().scaleFactor;
|
||
|
|
int i = (int) (this.fO * f);
|
||
|
|
this.fZ = i;
|
||
|
|
if (i % 2 != 0) {
|
||
|
|
this.fZ = i + 1;
|
||
|
|
}
|
||
|
|
int i2 = (int) (f * this.fP);
|
||
|
|
this.ga = i2;
|
||
|
|
if (i2 % 2 != 0) {
|
||
|
|
this.ga = i2 + 1;
|
||
|
|
}
|
||
|
|
ImageProcessor imageProcessor = this.gW;
|
||
|
|
if (imageProcessor != null) {
|
||
|
|
imageProcessor.setResizedResolution(this.fZ, this.ga);
|
||
|
|
}
|
||
|
|
this.fW = new FrameBufferTexture(this.fZ, this.ga);
|
||
|
|
if (this.gH == null) {
|
||
|
|
this.gH = new FrameBufferTexture(this.fZ, this.ga);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void N() {
|
||
|
|
int[] iArr = new int[1];
|
||
|
|
int[] iArr2 = new int[4];
|
||
|
|
GLES20.glGetIntegerv(36006, iArr, 0);
|
||
|
|
GLES20.glGetIntegerv(2978, iArr2, 0);
|
||
|
|
if (this.gQ) {
|
||
|
|
GLES20.glBindFramebuffer(36160, this.fW.mFrameBuffer);
|
||
|
|
GLES20.glViewport(0, 0, this.fW.mWidth, this.fW.mHeight);
|
||
|
|
W();
|
||
|
|
h(this.fW, this.gH);
|
||
|
|
}
|
||
|
|
if (this.gR) {
|
||
|
|
GLES20.glBindFramebuffer(36160, this.fW.mFrameBuffer);
|
||
|
|
GLES20.glViewport(0, 0, this.fW.mWidth, this.fW.mHeight);
|
||
|
|
X();
|
||
|
|
}
|
||
|
|
GLES20.glBindFramebuffer(36160, iArr[0]);
|
||
|
|
GLES20.glViewport(iArr2[0], iArr2[1], iArr2[2], iArr2[3]);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void W() {
|
||
|
|
YuvToRgbShader yuvToRgbShader = this.gV;
|
||
|
|
GLES20.glUseProgram(yuvToRgbShader.getProgram());
|
||
|
|
GLES20.glVertexAttribPointer(0, 2, 5126, false, 0, (Buffer) this.fI);
|
||
|
|
GLES20.glEnableVertexAttribArray(0);
|
||
|
|
GLES20.glVertexAttribPointer(1, 2, 5126, false, 0, (Buffer) this.fL);
|
||
|
|
GLES20.glEnableVertexAttribArray(1);
|
||
|
|
GLES20.glActiveTexture(33984);
|
||
|
|
GLES20.glBindTexture(3553, this.ge);
|
||
|
|
GLES20.glUniform1i(yuvToRgbShader.getYTextureUniform(), 0);
|
||
|
|
GLES20.glActiveTexture(33985);
|
||
|
|
GLES20.glBindTexture(3553, this.gP);
|
||
|
|
GLES20.glUniform1i(yuvToRgbShader.getUVTextureUniform(), 1);
|
||
|
|
GLES20.glDrawArrays(5, 0, 4);
|
||
|
|
GLES20.glActiveTexture(33985);
|
||
|
|
GLES20.glBindTexture(3553, 0);
|
||
|
|
GLES20.glActiveTexture(33984);
|
||
|
|
GLES20.glBindTexture(3553, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void X() {
|
||
|
|
GrayGaussianBlur3x3Shader grayGaussianBlur3x3Shader = this.gT;
|
||
|
|
GLES20.glUseProgram(grayGaussianBlur3x3Shader.getProgram());
|
||
|
|
GLES20.glVertexAttribPointer(0, 2, 5126, false, 0, (Buffer) this.fI);
|
||
|
|
GLES20.glEnableVertexAttribArray(0);
|
||
|
|
GLES20.glVertexAttribPointer(1, 2, 5126, false, 0, (Buffer) this.fL);
|
||
|
|
GLES20.glEnableVertexAttribArray(1);
|
||
|
|
GLES20.glBindTexture(3553, this.ge);
|
||
|
|
GLES20.glUniform1f(grayGaussianBlur3x3Shader.getTexelWidthUniform(), 1.0f / this.fO);
|
||
|
|
GLES20.glUniform1f(grayGaussianBlur3x3Shader.getTexelHeightUniform(), 1.0f / this.fP);
|
||
|
|
GLES20.glDrawArrays(5, 0, 4);
|
||
|
|
GLES20.glBindTexture(3553, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void h(FrameBufferTexture frameBufferTexture, FrameBufferTexture frameBufferTexture2) {
|
||
|
|
GLES20.glBindFramebuffer(36160, frameBufferTexture2.mFrameBuffer);
|
||
|
|
GLES20.glViewport(0, 0, frameBufferTexture2.mWidth, frameBufferTexture2.mHeight);
|
||
|
|
RgbGaussianBlur3x3Shader rgbGaussianBlur3x3Shader = this.gU;
|
||
|
|
GLES20.glUseProgram(rgbGaussianBlur3x3Shader.getProgram());
|
||
|
|
GLES20.glVertexAttribPointer(0, 2, 5126, false, 0, (Buffer) this.fI);
|
||
|
|
GLES20.glEnableVertexAttribArray(0);
|
||
|
|
GLES20.glVertexAttribPointer(1, 2, 5126, false, 0, (Buffer) this.fL);
|
||
|
|
GLES20.glEnableVertexAttribArray(1);
|
||
|
|
GLES20.glBindTexture(3553, frameBufferTexture.mTexture);
|
||
|
|
GLES20.glUniform1f(rgbGaussianBlur3x3Shader.getTexelWidthUniform(), 1.0f / frameBufferTexture.mWidth);
|
||
|
|
GLES20.glUniform1f(rgbGaussianBlur3x3Shader.getTexelHeightUniform(), 1.0f / frameBufferTexture.mHeight);
|
||
|
|
GLES20.glDrawArrays(5, 0, 4);
|
||
|
|
GLES20.glBindTexture(3553, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void e(FrameBufferTexture frameBufferTexture) {
|
||
|
|
if (frameBufferTexture == null) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
GLES20.glUseProgram(this.gg.getProgram());
|
||
|
|
GLES20.glClearColor(0.3f, 0.3f, 0.3f, 1.0f);
|
||
|
|
GLES20.glClear(16640);
|
||
|
|
GLES20.glVertexAttribPointer(0, 2, 5126, false, 0, (Buffer) this.fG);
|
||
|
|
GLES20.glEnableVertexAttribArray(0);
|
||
|
|
GLES20.glVertexAttribPointer(1, 2, 5126, false, 0, (Buffer) this.fK);
|
||
|
|
GLES20.glEnableVertexAttribArray(1);
|
||
|
|
GLES20.glBindTexture(3553, frameBufferTexture.mTexture);
|
||
|
|
GLES20.glDrawArrays(5, 0, 4);
|
||
|
|
GLES20.glBindTexture(3553, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void a(float[] fArr) {
|
||
|
|
if (fArr == null) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
ColorPassThroughShader colorPassThroughShader = this.gS;
|
||
|
|
GLES20.glUseProgram(colorPassThroughShader.getProgram());
|
||
|
|
float f = (float) (this.fM * this.fN * 4.0E-6d);
|
||
|
|
if (f < 2.0f) {
|
||
|
|
f = 2.0f;
|
||
|
|
}
|
||
|
|
GLES20.glLineWidth(f);
|
||
|
|
GLES20.glUniform4f(colorPassThroughShader.getColorUniform(), 1.0f, BitmapDescriptorFactory.HUE_RED, BitmapDescriptorFactory.HUE_RED, 1.0f);
|
||
|
|
float f2 = fArr[0];
|
||
|
|
float f3 = this.fO;
|
||
|
|
float f4 = fArr[1];
|
||
|
|
float f5 = this.fP;
|
||
|
|
float f6 = (f4 * 2.0f) / f5;
|
||
|
|
float f7 = (fArr[2] * 2.0f) / f3;
|
||
|
|
float f8 = (fArr[3] * 2.0f) / f5;
|
||
|
|
float f9 = (fArr[4] * 2.0f) / f3;
|
||
|
|
float f10 = (fArr[5] * 2.0f) / f5;
|
||
|
|
float f11 = (fArr[6] * 2.0f) / f3;
|
||
|
|
float f12 = (fArr[7] * 2.0f) / f5;
|
||
|
|
float f13 = this.fQ;
|
||
|
|
float f14 = this.fR;
|
||
|
|
this.gG.clear();
|
||
|
|
this.gG.put(new float[]{(((f2 * 2.0f) / f3) - 1.0f) * f13, (1.0f - f6) * f14, (f7 - 1.0f) * f13, (1.0f - f8) * f14, (f9 - 1.0f) * f13, (1.0f - f10) * f14, f13 * (f11 - 1.0f), f14 * (1.0f - f12)}).position(0);
|
||
|
|
GLES20.glVertexAttribPointer(0, 2, 5126, false, 0, (Buffer) this.gG);
|
||
|
|
GLES20.glEnableVertexAttribArray(0);
|
||
|
|
GLES20.glDrawArrays(2, 0, 4);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void a(Queue<Runnable> queue) {
|
||
|
|
synchronized (queue) {
|
||
|
|
while (!queue.isEmpty()) {
|
||
|
|
queue.poll().run();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // com.kofax.kmc.ken.engines.gpu.IGPUImageRenderer
|
||
|
|
public void onPreviewFrame(byte[] bArr, int i, int i2) {
|
||
|
|
if (this.gb == null) {
|
||
|
|
ByteBuffer allocateDirect = ByteBuffer.allocateDirect(i * i2);
|
||
|
|
this.gb = allocateDirect;
|
||
|
|
allocateDirect.order(ByteOrder.nativeOrder());
|
||
|
|
}
|
||
|
|
if (this.gO == null) {
|
||
|
|
ByteBuffer allocateDirect2 = ByteBuffer.allocateDirect((i * i2) / 2);
|
||
|
|
this.gO = allocateDirect2;
|
||
|
|
allocateDirect2.order(ByteOrder.nativeOrder());
|
||
|
|
}
|
||
|
|
if (this.fS.isEmpty()) {
|
||
|
|
a(new Runnable(this, i, i2, bArr) { // from class: com.kofax.kmc.ken.engines.gpu.f.1
|
||
|
|
final f gY;
|
||
|
|
final byte[] gn;
|
||
|
|
final int h;
|
||
|
|
final int i;
|
||
|
|
|
||
|
|
{
|
||
|
|
this.gY = this;
|
||
|
|
this.h = i;
|
||
|
|
this.i = i2;
|
||
|
|
this.gn = bArr;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // java.lang.Runnable
|
||
|
|
public void run() {
|
||
|
|
this.gY.gb.clear();
|
||
|
|
int remaining = this.gY.gb.remaining();
|
||
|
|
int i3 = this.h * this.i;
|
||
|
|
if (remaining < i3) {
|
||
|
|
this.gY.gb = ByteBuffer.allocateDirect(i3);
|
||
|
|
this.gY.gb.order(ByteOrder.nativeOrder());
|
||
|
|
}
|
||
|
|
this.gY.gb.put(this.gn, 0, this.h * this.i);
|
||
|
|
this.gY.gb.position(0);
|
||
|
|
if (this.gY.ge != -1) {
|
||
|
|
GLES20.glBindTexture(3553, this.gY.ge);
|
||
|
|
GLES20.glTexSubImage2D(3553, 0, 0, 0, this.h, this.i, 6409, 5121, this.gY.gb);
|
||
|
|
} else {
|
||
|
|
int[] iArr = new int[1];
|
||
|
|
GLES20.glGenTextures(1, iArr, 0);
|
||
|
|
GLES20.glBindTexture(3553, iArr[0]);
|
||
|
|
GLES20.glTexParameterf(3553, 10240, 9729.0f);
|
||
|
|
GLES20.glTexParameterf(3553, 10241, 9729.0f);
|
||
|
|
GLES20.glTexParameterf(3553, 10242, 33071.0f);
|
||
|
|
GLES20.glTexParameterf(3553, 10243, 33071.0f);
|
||
|
|
GLES20.glTexImage2D(3553, 0, 6409, this.h, this.i, 0, 6409, 5121, this.gY.gb);
|
||
|
|
this.gY.ge = iArr[0];
|
||
|
|
}
|
||
|
|
f fVar = this.gY;
|
||
|
|
fVar.gR = fVar.gW.isGrayScaleInputTextureRequired();
|
||
|
|
f fVar2 = this.gY;
|
||
|
|
fVar2.gQ = fVar2.gW.isRGBInputTextureRequired();
|
||
|
|
if (this.gY.gQ) {
|
||
|
|
this.gY.gO.clear();
|
||
|
|
int remaining2 = this.gY.gO.remaining();
|
||
|
|
int i4 = (this.h * this.i) / 2;
|
||
|
|
if (remaining2 < i4) {
|
||
|
|
this.gY.gO = ByteBuffer.allocateDirect(i4);
|
||
|
|
this.gY.gO.order(ByteOrder.nativeOrder());
|
||
|
|
}
|
||
|
|
ByteBuffer byteBuffer = this.gY.gO;
|
||
|
|
byte[] bArr2 = this.gn;
|
||
|
|
int i5 = this.h * this.i;
|
||
|
|
byteBuffer.put(bArr2, i5, i5 / 2);
|
||
|
|
this.gY.gO.position(0);
|
||
|
|
if (this.gY.gP != -1) {
|
||
|
|
GLES20.glBindTexture(3553, this.gY.gP);
|
||
|
|
GLES20.glTexSubImage2D(3553, 0, 0, 0, this.h / 2, this.i / 2, 6410, 5121, this.gY.gO);
|
||
|
|
} else {
|
||
|
|
int[] iArr2 = new int[1];
|
||
|
|
GLES20.glGenTextures(1, iArr2, 0);
|
||
|
|
GLES20.glBindTexture(3553, iArr2[0]);
|
||
|
|
GLES20.glTexParameterf(3553, 10240, 9729.0f);
|
||
|
|
GLES20.glTexParameterf(3553, 10241, 9729.0f);
|
||
|
|
GLES20.glTexParameterf(3553, 10242, 33071.0f);
|
||
|
|
GLES20.glTexParameterf(3553, 10243, 33071.0f);
|
||
|
|
GLES20.glTexImage2D(3553, 0, 6410, this.h / 2, this.i / 2, 0, 6410, 5121, this.gY.gO);
|
||
|
|
this.gY.gP = iArr2[0];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
this.gY.fF = true;
|
||
|
|
if (this.gY.gW != null && !this.gY.gX) {
|
||
|
|
this.gY.gW.processByteData(this.gn, this.h, this.i);
|
||
|
|
}
|
||
|
|
int i6 = this.gY.fO;
|
||
|
|
int i7 = this.h;
|
||
|
|
if (i6 != i7) {
|
||
|
|
this.gY.fO = i7;
|
||
|
|
this.gY.fP = this.i;
|
||
|
|
if (this.gY.gW != null) {
|
||
|
|
this.gY.gW.setPreviewResoution(this.gY.fO, this.gY.fP);
|
||
|
|
}
|
||
|
|
this.gY.P();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // com.kofax.kmc.ken.engines.gpu.IGPUImageRenderer
|
||
|
|
public final void destroy() {
|
||
|
|
synchronized (this) {
|
||
|
|
FrameBufferTexture frameBufferTexture = this.fW;
|
||
|
|
if (frameBufferTexture != null) {
|
||
|
|
frameBufferTexture.destroy();
|
||
|
|
this.fW = null;
|
||
|
|
}
|
||
|
|
FrameBufferTexture frameBufferTexture2 = this.gH;
|
||
|
|
if (frameBufferTexture2 != null) {
|
||
|
|
frameBufferTexture2.destroy();
|
||
|
|
this.gH = null;
|
||
|
|
}
|
||
|
|
int i = this.gf;
|
||
|
|
if (i != -1) {
|
||
|
|
GLES20.glDeleteTextures(1, new int[]{i}, 0);
|
||
|
|
this.gf = -1;
|
||
|
|
}
|
||
|
|
int i2 = this.ge;
|
||
|
|
if (i2 != -1) {
|
||
|
|
GLES20.glDeleteTextures(1, new int[]{i2}, 0);
|
||
|
|
this.ge = -1;
|
||
|
|
}
|
||
|
|
int i3 = this.gP;
|
||
|
|
if (i3 != -1) {
|
||
|
|
GLES20.glDeleteTextures(1, new int[]{i3}, 0);
|
||
|
|
this.gP = -1;
|
||
|
|
}
|
||
|
|
ImageProcessor imageProcessor = this.gW;
|
||
|
|
if (imageProcessor != null) {
|
||
|
|
imageProcessor.destroy();
|
||
|
|
this.gW = null;
|
||
|
|
}
|
||
|
|
PassThroughShader passThroughShader = this.gg;
|
||
|
|
if (passThroughShader != null) {
|
||
|
|
passThroughShader.destroy();
|
||
|
|
this.gg = null;
|
||
|
|
}
|
||
|
|
ColorPassThroughShader colorPassThroughShader = this.gS;
|
||
|
|
if (colorPassThroughShader != null) {
|
||
|
|
colorPassThroughShader.destroy();
|
||
|
|
this.gS = null;
|
||
|
|
}
|
||
|
|
GrayGaussianBlur3x3Shader grayGaussianBlur3x3Shader = this.gT;
|
||
|
|
if (grayGaussianBlur3x3Shader != null) {
|
||
|
|
grayGaussianBlur3x3Shader.destroy();
|
||
|
|
this.gT = null;
|
||
|
|
}
|
||
|
|
RgbGaussianBlur3x3Shader rgbGaussianBlur3x3Shader = this.gU;
|
||
|
|
if (rgbGaussianBlur3x3Shader != null) {
|
||
|
|
rgbGaussianBlur3x3Shader.destroy();
|
||
|
|
this.gU = null;
|
||
|
|
}
|
||
|
|
YuvToRgbShader yuvToRgbShader = this.gV;
|
||
|
|
if (yuvToRgbShader != null) {
|
||
|
|
yuvToRgbShader.destroy();
|
||
|
|
this.gV = null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* JADX INFO: Access modifiers changed from: private */
|
||
|
|
public void P() {
|
||
|
|
float f = this.fM;
|
||
|
|
float f2 = this.fN;
|
||
|
|
if (this.fU == Rotation.ROTATION_270 || this.fU == Rotation.ROTATION_90) {
|
||
|
|
f = this.fN;
|
||
|
|
f2 = this.fM;
|
||
|
|
}
|
||
|
|
float max = Math.max(f / this.fO, f2 / this.fP);
|
||
|
|
int round = Math.round(this.fO * max);
|
||
|
|
int round2 = Math.round(this.fP * max);
|
||
|
|
this.fQ = round / f;
|
||
|
|
this.fR = round2 / f2;
|
||
|
|
float[] fArr = fH;
|
||
|
|
float[] rotation = TextureRotationUtil.getRotation(this.fU, false, false);
|
||
|
|
if (this.fV == ScaleType.CENTER_CROP) {
|
||
|
|
float f3 = (1.0f - (1.0f / this.fQ)) / 2.0f;
|
||
|
|
float f4 = (1.0f - (1.0f / this.fR)) / 2.0f;
|
||
|
|
rotation = new float[]{a(rotation[0], f3), a(rotation[1], f4), a(rotation[2], f3), a(rotation[3], f4), a(rotation[4], f3), a(rotation[5], f4), a(rotation[6], f3), a(rotation[7], f4)};
|
||
|
|
} else {
|
||
|
|
float f5 = fArr[0];
|
||
|
|
float f6 = this.fR;
|
||
|
|
float f7 = fArr[1];
|
||
|
|
float f8 = this.fQ;
|
||
|
|
fArr = new float[]{f5 / f6, f7 / f8, fArr[2] / f6, fArr[3] / f8, fArr[4] / f6, fArr[5] / f8, fArr[6] / f6, fArr[7] / f8};
|
||
|
|
}
|
||
|
|
this.fG.clear();
|
||
|
|
this.fG.put(fArr).position(0);
|
||
|
|
this.fK.clear();
|
||
|
|
this.fK.put(rotation).position(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // com.kofax.kmc.ken.engines.gpu.IGPUImageRenderer
|
||
|
|
public void setRotation(Rotation rotation) {
|
||
|
|
this.fU = rotation;
|
||
|
|
P();
|
||
|
|
}
|
||
|
|
|
||
|
|
protected void a(Runnable runnable) {
|
||
|
|
synchronized (this.fS) {
|
||
|
|
this.fS.add(runnable);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public void setSettings(DocumentDetectionSettings documentDetectionSettings) {
|
||
|
|
ImageProcessor imageProcessor = this.gW;
|
||
|
|
if (imageProcessor != null) {
|
||
|
|
imageProcessor.setSettings(documentDetectionSettings);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override // com.kofax.kmc.ken.engines.gpu.IGPUImageRenderer
|
||
|
|
public void setScaleType(ScaleType scaleType) {
|
||
|
|
this.fV = scaleType;
|
||
|
|
}
|
||
|
|
|
||
|
|
public Rotation getRotation() {
|
||
|
|
return this.fU;
|
||
|
|
}
|
||
|
|
|
||
|
|
public float[] getBounds() {
|
||
|
|
return this.gF;
|
||
|
|
}
|
||
|
|
}
|