package com.example.datalibrary.deptrum.openglhelper;
|
|
import android.app.Activity;
|
import android.app.ActivityManager;
|
import android.app.AlertDialog;
|
import android.app.Dialog;
|
import android.content.Context;
|
import android.content.DialogInterface;
|
import android.content.pm.ConfigurationInfo;
|
import android.opengl.GLES20;
|
import android.util.Log;
|
import android.view.SurfaceHolder;
|
import android.view.SurfaceView;
|
|
import java.nio.Buffer;
|
import java.nio.ByteBuffer;
|
import java.nio.ByteOrder;
|
import java.util.Arrays;
|
|
/**
|
*
|
*/
|
public class YUVRendThread extends BaseOpenglRenderThread {
|
private GLFrameRenderer glFrameRenderer;
|
|
public YUVRendThread(String name, SurfaceView mSurfaceView) {
|
super(name, mSurfaceView);
|
tAG = YUVRendThread.class.getSimpleName();
|
glFrameRenderer = new GLFrameRenderer();
|
mSurfaceView.getHolder().addCallback(glFrameRenderer);
|
glFrameRenderer.setResolution(640, 480);
|
glFrameRenderer.setDisplayOrientation(0);
|
glFrameRenderer.displayMirror(false);
|
glFrameRenderer.creatBuffer(640, 480);
|
}
|
|
@Override
|
protected void creatProgram() {
|
if (glFrameRenderer != null) {
|
glFrameRenderer.creatProgram();
|
}
|
}
|
|
@Override
|
protected void draw() {
|
if (glFrameRenderer != null) {
|
glFrameRenderer.onDrawFrame();
|
}
|
}
|
|
public void update(byte[] yuv420p) {
|
if (glFrameRenderer != null) {
|
glFrameRenderer.update(yuv420p);
|
notifyDraw();
|
}
|
}
|
|
public static class GLProgram {
|
private static final String VERTEX_SHADER =
|
"uniform mat4 uMVPMatrix;\n"
|
+ "attribute vec4 vPosition;\n"
|
+ "attribute vec2 a_texCoord;\n"
|
+ "varying vec2 tc;\n"
|
+ "void main() {\n"
|
+ "gl_Position = uMVPMatrix * vPosition;\n"
|
+ "tc = a_texCoord;\n"
|
+ "}\n";
|
private static final String FRAGMENT_SHADER =
|
"precision mediump float;\n"
|
+ "uniform sampler2D tex_y;\n"
|
+ "uniform sampler2D tex_u;\n"
|
+ "uniform sampler2D tex_v;\n"
|
+ "varying vec2 tc;\n"
|
+ "void main() {\n"
|
+ "vec4 c = vec4((texture2D(tex_y, tc).r - 16./255.) * 1.164);\n"
|
+ "vec4 U = vec4(texture2D(tex_u, tc).r - 128./255.);\n"
|
+ "vec4 V = vec4(texture2D(tex_v, tc).r - 128./255.);\n"
|
+ "c += V * vec4(1.596, -0.813, 0, 0);\n"
|
+ "c += U * vec4(0, -0.392, 2.017, 0);\n"
|
+ "c.a = 1.0;\n"
|
+ "gl_FragColor = c;\n"
|
+ "}\n";
|
|
private float[] mViewMatrix = new float[16];
|
private int mVPMatrixHandle = -1;
|
|
static float[] s0Matrix = {
|
1.0f, 0.0f, 0f, 0.0f,
|
0.0f, 1.0f, 0.0f, 0.0f,
|
0.0f, 0.0f, 1.0f, 0.0f,
|
0.0f, 0.0f, 0.0f, 1.0f,
|
};
|
|
static float[] s0MirrorMatrix = {
|
-1.0f, 0.0f, 0f, 0.0f,
|
0.0f, 1.0f, 0.0f, 0.0f,
|
0.0f, 0.0f, 1.0f, 0.0f,
|
0.0f, 0.0f, 0.0f, 1.0f,
|
};
|
|
static float[] s90Matrix = {
|
0.0f, -1.0f, 0f, 0.0f,
|
1.0f, 0.0f, 0.0f, 0.0f,
|
0.0f, 0.0f, 1.0f, 0.0f,
|
0.0f, 0.0f, 0.0f, 1.0f,
|
};
|
static float[] s90MirrorMatrix = {
|
0.0f, -1.0f, 0f, 0.0f,
|
-1.0f, 0.0f, 0.0f, 0.0f,
|
0.0f, 0.0f, 1.0f, 0.0f,
|
0.0f, 0.0f, 0.0f, 1.0f,
|
};
|
static float[] s180Matrix = {
|
-1.0f, 0.0f, 0f, 0.0f,
|
0.0f, -1.0f, 0.0f, 0.0f,
|
0.0f, 0.0f, 1.0f, 0.0f,
|
0.0f, 0.0f, 0.0f, 1.0f,
|
};
|
static float[] s180MirrorMatrix = {
|
1.0f, 0.0f, 0f, 0.0f,
|
0.0f, -1.0f, 0.0f, 0.0f,
|
0.0f, 0.0f, 1.0f, 0.0f,
|
0.0f, 0.0f, 0.0f, 1.0f,
|
};
|
static float[] s270Matrix = {
|
0.0f, 1.0f, 0f, 0.0f,
|
-1.0f, 0.0f, 0.0f, 0.0f,
|
0.0f, 0.0f, 1.0f, 0.0f,
|
0.0f, 0.0f, 0.0f, 1.0f,
|
};
|
static float[] s270MirrorMatrix = {
|
0.0f, 1.0f, 0f, 0.0f,
|
1.0f, 0.0f, 0.0f, 0.0f,
|
0.0f, 0.0f, 1.0f, 0.0f,
|
0.0f, 0.0f, 0.0f, 1.0f,
|
};
|
|
static float[] squareVertices = {
|
-1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 1.0f,
|
}; /*fullscreen*/
|
static float[] squareVertices1 = {
|
-1.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, 1.0f,
|
}; /*left-top*/
|
static float[] squareVertices2 = {
|
0.0f, -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
|
}; /*right-bottom*/
|
static float[] squareVertices3 = {
|
-1.0f, -1.0f, 0.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
|
}; /*left-bottom*/
|
static float[] squareVertices4 = {
|
0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
|
}; /*right-top*/
|
private static float[] coordVertices = {
|
0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
|
}; /*whole-texture*/
|
|
public final int mWinPosition;
|
private int mGLProgram;
|
|
private int mGLTextureI;
|
private int mGLTextureII;
|
private int mGLTextureIII;
|
|
private int mGLIndexI;
|
private int mGLIndexII;
|
private int mGLTIndexIII;
|
|
private float[] mGLVertices;
|
|
private int mPositionHandle = -1;
|
private int mCoordHandle = -1;
|
private int mYhandle = -1;
|
private int mUhandle = -1;
|
private int mVhandle = -1;
|
private int mYtid = -1;
|
private int mUtid = -1;
|
private int mVtid = -1;
|
|
private ByteBuffer mVerticeBuffer;
|
private ByteBuffer mCoordBuffer;
|
|
private int mVideoWidth = -1;
|
private int mVideoHeight = -1;
|
|
private boolean isProgBuilt = false;
|
|
/**
|
* position can only be 0~4:<br>
|
* fullscreen => 0<br>
|
* left-top => 1<br>
|
* right-top => 2<br>
|
* left-bottom => 3<br>
|
* right-bottom => 4
|
*/
|
public GLProgram(int position) {
|
if (position < 0 || position > 4) {
|
throw new RuntimeException("Index can only be 0 to 4");
|
}
|
mWinPosition = position;
|
setup();
|
}
|
|
/**
|
* prepared for later use
|
*/
|
private void setup() {
|
switch (mWinPosition) {
|
case 1:
|
mGLVertices = squareVertices1;
|
mGLTextureI = GLES20.GL_TEXTURE0;
|
mGLTextureII = GLES20.GL_TEXTURE1;
|
mGLTextureIII = GLES20.GL_TEXTURE2;
|
mGLIndexI = 0;
|
mGLIndexII = 1;
|
mGLTIndexIII = 2;
|
break;
|
case 2:
|
mGLVertices = squareVertices2;
|
mGLTextureI = GLES20.GL_TEXTURE3;
|
mGLTextureII = GLES20.GL_TEXTURE4;
|
mGLTextureIII = GLES20.GL_TEXTURE5;
|
mGLIndexI = 3;
|
mGLIndexII = 4;
|
mGLTIndexIII = 5;
|
break;
|
case 3:
|
mGLVertices = squareVertices3;
|
mGLTextureI = GLES20.GL_TEXTURE6;
|
mGLTextureII = GLES20.GL_TEXTURE7;
|
mGLTextureIII = GLES20.GL_TEXTURE8;
|
mGLIndexI = 6;
|
mGLIndexII = 7;
|
mGLTIndexIII = 8;
|
break;
|
case 4:
|
mGLVertices = squareVertices4;
|
mGLTextureI = GLES20.GL_TEXTURE9;
|
mGLTextureII = GLES20.GL_TEXTURE10;
|
mGLTextureIII = GLES20.GL_TEXTURE11;
|
mGLIndexI = 9;
|
mGLIndexII = 10;
|
mGLTIndexIII = 11;
|
break;
|
case 0:
|
default:
|
mGLVertices = squareVertices;
|
mGLTextureI = GLES20.GL_TEXTURE0;
|
mGLTextureII = GLES20.GL_TEXTURE1;
|
mGLTextureIII = GLES20.GL_TEXTURE2;
|
mGLIndexI = 0;
|
mGLIndexII = 1;
|
mGLTIndexIII = 2;
|
break;
|
}
|
}
|
|
public boolean isProgramBuilt() {
|
return isProgBuilt;
|
}
|
|
public void buildProgram() {
|
if (mGLProgram <= 0) {
|
mGLProgram = createProgram(VERTEX_SHADER, FRAGMENT_SHADER);
|
}
|
/*
|
* get handle for "vPosition" and "a_texCoord"
|
*/
|
try {
|
mPositionHandle = GLES20.glGetAttribLocation(mGLProgram, "vPosition");
|
checkGlError("glGetAttribLocation vPosition");
|
if (mPositionHandle == -1) {
|
throw new RuntimeException("Could not get attribute location for vPosition");
|
}
|
mCoordHandle = GLES20.glGetAttribLocation(mGLProgram, "a_texCoord");
|
checkGlError("glGetAttribLocation a_texCoord");
|
if (mCoordHandle == -1) {
|
throw new RuntimeException("Could not get attribute location for a_texCoord");
|
}
|
/*
|
* get uniform location for y/u/v, we pass data through these uniforms
|
*/
|
mYhandle = GLES20.glGetUniformLocation(mGLProgram, "tex_y");
|
checkGlError("glGetUniformLocation tex_y");
|
if (mYhandle == -1) {
|
throw new RuntimeException("Could not get uniform location for tex_y");
|
}
|
mUhandle = GLES20.glGetUniformLocation(mGLProgram, "tex_u");
|
checkGlError("glGetUniformLocation tex_u");
|
if (mUhandle == -1) {
|
throw new RuntimeException("Could not get uniform location for tex_u");
|
}
|
mVhandle = GLES20.glGetUniformLocation(mGLProgram, "tex_v");
|
checkGlError("glGetUniformLocation tex_v");
|
if (mVhandle == -1) {
|
throw new RuntimeException("Could not get uniform location for tex_v");
|
}
|
mVPMatrixHandle = GLES20.glGetUniformLocation(mGLProgram, "uMVPMatrix");
|
isProgBuilt = true;
|
} catch (RuntimeException e) {
|
e.printStackTrace();
|
}
|
}
|
|
public void releaseProgram() {
|
GLES20.glUseProgram(0);
|
if (mGLProgram >= 0) {
|
GLES20.glDeleteProgram(mGLProgram);
|
}
|
mGLProgram = -1;
|
isProgBuilt = false;
|
}
|
|
/**
|
* build a set of textures, one for R, one for G, and one for B.
|
*/
|
public void buildTextures(Buffer y, Buffer u, Buffer v, int width, int height) {
|
boolean videoSizeChanged = (width != mVideoWidth || height != mVideoHeight);
|
if (videoSizeChanged) {
|
mVideoWidth = width;
|
mVideoHeight = height;
|
}
|
|
// building texture for Y data
|
if (mYtid < 0 || videoSizeChanged) {
|
if (mYtid >= 0) {
|
GLES20.glDeleteTextures(1, new int[]{mYtid}, 0);
|
checkGlError("glDeleteTextures");
|
}
|
// GLES20.glPixelStorei(GLES20.GL_UNPACK_ALIGNMENT, 1);
|
int[] textures = new int[1];
|
GLES20.glGenTextures(1, textures, 0);
|
checkGlError("glGenTextures");
|
mYtid = textures[0];
|
}
|
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mYtid);
|
checkGlError("glBindTexture");
|
GLES20.glTexImage2D(
|
GLES20.GL_TEXTURE_2D,
|
0,
|
GLES20.GL_LUMINANCE,
|
mVideoWidth,
|
mVideoHeight,
|
0,
|
GLES20.GL_LUMINANCE,
|
GLES20.GL_UNSIGNED_BYTE,
|
y);
|
checkGlError("glTexImage2D");
|
GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST);
|
GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
|
GLES20.glTexParameteri(
|
GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
|
GLES20.glTexParameteri(
|
GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
|
|
// building texture for U data
|
if (mUtid < 0 || videoSizeChanged) {
|
if (mUtid >= 0) {
|
GLES20.glDeleteTextures(1, new int[]{mUtid}, 0);
|
checkGlError("glDeleteTextures");
|
}
|
int[] textures = new int[1];
|
GLES20.glGenTextures(1, textures, 0);
|
checkGlError("glGenTextures");
|
mUtid = textures[0];
|
}
|
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mUtid);
|
GLES20.glTexImage2D(
|
GLES20.GL_TEXTURE_2D,
|
0,
|
GLES20.GL_LUMINANCE,
|
mVideoWidth / 2,
|
mVideoHeight / 2,
|
0,
|
GLES20.GL_LUMINANCE,
|
GLES20.GL_UNSIGNED_BYTE,
|
u);
|
GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST);
|
GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
|
GLES20.glTexParameteri(
|
GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
|
GLES20.glTexParameteri(
|
GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
|
|
// building texture for V data
|
if (mVtid < 0 || videoSizeChanged) {
|
if (mVtid >= 0) {
|
GLES20.glDeleteTextures(1, new int[]{mVtid}, 0);
|
checkGlError("glDeleteTextures");
|
}
|
int[] textures = new int[1];
|
GLES20.glGenTextures(1, textures, 0);
|
checkGlError("glGenTextures");
|
mVtid = textures[0];
|
}
|
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mVtid);
|
GLES20.glTexImage2D(
|
GLES20.GL_TEXTURE_2D,
|
0,
|
GLES20.GL_LUMINANCE,
|
mVideoWidth / 2,
|
mVideoHeight / 2,
|
0,
|
GLES20.GL_LUMINANCE,
|
GLES20.GL_UNSIGNED_BYTE,
|
v);
|
GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST);
|
GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
|
GLES20.glTexParameteri(
|
GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
|
GLES20.glTexParameteri(
|
GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
|
}
|
|
public void setDisplayOrientation(int degrees, boolean needMirror) {
|
if (degrees == 0) {
|
if (needMirror) {
|
mViewMatrix = s0MirrorMatrix;
|
} else {
|
mViewMatrix = s0Matrix;
|
}
|
} else if (degrees == 90) {
|
if (needMirror) {
|
mViewMatrix = s90MirrorMatrix;
|
} else {
|
mViewMatrix = s90Matrix;
|
}
|
} else if (degrees == 180) {
|
if (needMirror) {
|
mViewMatrix = s180MirrorMatrix;
|
} else {
|
mViewMatrix = s180Matrix;
|
}
|
} else if (degrees == 270) {
|
if (needMirror) {
|
mViewMatrix = s270MirrorMatrix;
|
} else {
|
mViewMatrix = s270Matrix;
|
}
|
} else {
|
}
|
}
|
|
/**
|
* render the frame the YUV data will be converted to RGB by shader.
|
*/
|
public void drawFrame() {
|
if (null == mVerticeBuffer){
|
return;
|
}
|
|
GLES20.glUseProgram(mGLProgram);
|
checkGlError("glUseProgram");
|
|
GLES20.glUniformMatrix4fv(mVPMatrixHandle, 1, false, mViewMatrix, 0);
|
|
GLES20.glVertexAttribPointer(mPositionHandle, 2, GLES20.GL_FLOAT, false, 8, mVerticeBuffer);
|
checkGlError("glVertexAttribPointer mPositionHandle");
|
GLES20.glEnableVertexAttribArray(mPositionHandle);
|
|
GLES20.glVertexAttribPointer(mCoordHandle, 2, GLES20.GL_FLOAT, false, 8, mCoordBuffer);
|
checkGlError("glVertexAttribPointer maTextureHandle");
|
GLES20.glEnableVertexAttribArray(mCoordHandle);
|
|
// bind textures
|
GLES20.glActiveTexture(mGLTextureI);
|
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mYtid);
|
GLES20.glUniform1i(mYhandle, mGLIndexI);
|
|
GLES20.glActiveTexture(mGLTextureII);
|
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mUtid);
|
GLES20.glUniform1i(mUhandle, mGLIndexII);
|
|
GLES20.glActiveTexture(mGLTextureIII);
|
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mVtid);
|
GLES20.glUniform1i(mVhandle, mGLTIndexIII);
|
|
GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
|
GLES20.glFinish();
|
|
GLES20.glDisableVertexAttribArray(mPositionHandle);
|
GLES20.glDisableVertexAttribArray(mCoordHandle);
|
}
|
|
/**
|
* create program and load shaders, fragment shader is very important.
|
*/
|
public int createProgram(String vertexSource, String fragmentSource) {
|
// create shaders
|
int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource);
|
int pixelShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource);
|
// just check
|
|
int program = GLES20.glCreateProgram();
|
if (program != 0) {
|
GLES20.glAttachShader(program, vertexShader);
|
checkGlError("glAttachShader");
|
GLES20.glAttachShader(program, pixelShader);
|
checkGlError("glAttachShader");
|
GLES20.glLinkProgram(program);
|
int[] linkStatus = new int[1];
|
GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0);
|
if (linkStatus[0] != GLES20.GL_TRUE) {
|
GLES20.glDeleteProgram(program);
|
program = 0;
|
}
|
}
|
return program;
|
}
|
|
/**
|
* create shader with given source.
|
*/
|
private int loadShader(int shaderType, String source) {
|
int shader = GLES20.glCreateShader(shaderType);
|
if (shader != 0) {
|
GLES20.glShaderSource(shader, source);
|
GLES20.glCompileShader(shader);
|
int[] compiled = new int[1];
|
GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0);
|
if (compiled[0] == 0) {
|
GLES20.glDeleteShader(shader);
|
shader = 0;
|
}
|
}
|
return shader;
|
}
|
|
/**
|
* these two buffers are used for holding vertices, screen vertices and texture vertices.
|
*/
|
void createBuffers(float[] vert) {
|
mVerticeBuffer = ByteBuffer.allocateDirect(vert.length * 4);
|
mVerticeBuffer.order(ByteOrder.nativeOrder());
|
mVerticeBuffer.asFloatBuffer().put(vert);
|
mVerticeBuffer.position(0);
|
|
if (mCoordBuffer == null) {
|
mCoordBuffer = ByteBuffer.allocateDirect(coordVertices.length * 4);
|
mCoordBuffer.order(ByteOrder.nativeOrder());
|
mCoordBuffer.asFloatBuffer().put(coordVertices);
|
mCoordBuffer.position(0);
|
}
|
}
|
|
private void checkGlError(String op) {
|
int error;
|
while ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR) {
|
// throw new RuntimeException(op + ": glError " + error);
|
}
|
}
|
}
|
|
public static class GLFrameRenderer implements SurfaceHolder.Callback {
|
private static final String TAG = GLFrameRenderer.class.getSimpleName();
|
private static final int SFPS = 25;
|
|
private GLProgram prog = new GLProgram(0);
|
private int mScreenWidth;
|
private int mScreenHeight;
|
private int mVideoWidth;
|
private int mVideoHeight;
|
private ByteBuffer y;
|
private ByteBuffer u;
|
private ByteBuffer v;
|
|
private int mDisplayDegrees;
|
private boolean mNeedMirror = false;
|
private long mLastFrameTime = 0;
|
private long mStanderDelta;
|
|
public GLFrameRenderer() {
|
// mParentAct = callback;
|
mDisplayDegrees = 0;
|
mNeedMirror = false;
|
mStanderDelta = 1000 / SFPS;
|
}
|
|
public void setResolution(int nWidth, int nHeight) {
|
mScreenWidth = nWidth;
|
mScreenHeight = nHeight;
|
}
|
|
public void onDrawFrame() {
|
synchronized (this) {
|
if (mLastFrameTime == 0) {
|
mLastFrameTime = System.currentTimeMillis();
|
} else {
|
long currentTime = System.currentTimeMillis();
|
long delta = currentTime - mLastFrameTime;
|
if (delta < mStanderDelta) {
|
try {
|
sleep(mStanderDelta - delta);
|
} catch (InterruptedException e) {
|
e.printStackTrace();
|
}
|
}
|
mLastFrameTime = currentTime;
|
}
|
|
if (y != null) {
|
// reset position, have to be done
|
y.position(0);
|
u.position(0);
|
v.position(0);
|
prog.buildTextures(y, u, v, mVideoWidth, mVideoHeight);
|
GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
|
GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
|
prog.drawFrame();
|
}
|
}
|
}
|
|
/**
|
* this method will be called from native code, it happens when the video is about to play or
|
* the video size changes.
|
*/
|
public void creatBuffer(int w, int h) {
|
if (mScreenWidth > 0 && mScreenHeight > 0) {
|
float f1 = 1f * mScreenHeight / mScreenWidth;
|
float f2 = 1f * h / w;
|
if (f1 == f2) {
|
prog.createBuffers(GLProgram.squareVertices);
|
} else if (f1 < f2) {
|
float widScale = f1 / f2;
|
prog.createBuffers(
|
new float[]{
|
-widScale, -1.0f, widScale, -1.0f, -widScale, 1.0f, widScale, 1.0f,
|
});
|
} else {
|
float heightScale = f2 / f1;
|
prog.createBuffers(
|
new float[]{
|
-1.0f, -heightScale, 1.0f, -heightScale, -1.0f, heightScale, 1.0f, heightScale,
|
});
|
}
|
}
|
|
if (w != mVideoWidth && h != mVideoHeight) {
|
this.mVideoWidth = w;
|
this.mVideoHeight = h;
|
int yarraySize = w * h;
|
int uvarraySize = yarraySize / 4;
|
synchronized (this) {
|
y = ByteBuffer.allocate(yarraySize);
|
byte[] yInit = new byte[yarraySize];
|
Arrays.fill(yInit, (byte) 0);
|
y.put(yInit);
|
|
byte[] uvInit = new byte[uvarraySize];
|
Arrays.fill(uvInit, (byte) 128);
|
|
u = ByteBuffer.allocate(uvarraySize);
|
u.put(uvInit);
|
|
v = ByteBuffer.allocate(uvarraySize);
|
v.put(uvInit);
|
}
|
}
|
}
|
|
/**
|
* this method will be called from native code, it's used for passing yuv data to me.
|
*/
|
public void update(byte[] ydata, byte[] udata, byte[] vdata) {
|
synchronized (this) {
|
y.clear();
|
u.clear();
|
v.clear();
|
y.put(ydata, 0, ydata.length);
|
u.put(udata, 0, udata.length);
|
v.put(vdata, 0, vdata.length);
|
}
|
}
|
|
public void update(byte[] yuv420p) {
|
synchronized (this) {
|
y.clear();
|
u.clear();
|
v.clear();
|
int size = this.mVideoWidth * this.mVideoHeight;
|
y.put(yuv420p, 0, size);
|
u.put(yuv420p, size, size / 4);
|
v.put(yuv420p, size * 5 / 4, size / 4);
|
}
|
}
|
|
public void setDisplayOrientation(int displayOrientation) {
|
mDisplayDegrees = displayOrientation;
|
prog.setDisplayOrientation(displayOrientation, mNeedMirror);
|
}
|
|
public void displayMirror(boolean mirror) {
|
mNeedMirror = mirror;
|
prog.setDisplayOrientation(mDisplayDegrees, mNeedMirror);
|
}
|
|
public void release() {
|
prog.releaseProgram();
|
}
|
|
public void creatProgram() {
|
Log.e(TAG, "GLFrameRenderer :: onSurfaceCreated");
|
if (!prog.isProgramBuilt()) {
|
prog.buildProgram();
|
}
|
}
|
|
@Override
|
public void surfaceCreated(SurfaceHolder holder) {
|
}
|
|
@Override
|
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
|
GLES20.glViewport(0, 0, width, height);
|
}
|
|
@Override
|
public void surfaceDestroyed(SurfaceHolder holder) {
|
}
|
}
|
|
public static class GLES20Support {
|
|
public static boolean detectOpenGLES20(Context context) {
|
ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
|
ConfigurationInfo info = am.getDeviceConfigurationInfo();
|
return (info.reqGlEsVersion >= 0x20000);
|
}
|
|
public static Dialog getNoSupportGLES20Dialog(final Activity activity) {
|
AlertDialog.Builder b = new AlertDialog.Builder(activity);
|
b.setCancelable(false);
|
b.setTitle("no opengl");
|
b.setMessage("not support opengl");
|
b.setNegativeButton(
|
"exit",
|
new DialogInterface.OnClickListener() {
|
|
@Override
|
public void onClick(DialogInterface dialog, int which) {
|
activity.finish();
|
}
|
});
|
return b.create();
|
}
|
}
|
}
|
