package com.example.datalibrary.deptrum;
|
|
import android.opengl.GLES20;
|
import android.opengl.GLSurfaceView;
|
import android.opengl.GLSurfaceView.Renderer;
|
|
import java.nio.ByteBuffer;
|
|
import javax.microedition.khronos.egl.EGLConfig;
|
import javax.microedition.khronos.opengles.GL10;
|
|
/**
|
* 渲染
|
*/
|
public class GLFrameRenderer implements Renderer {
|
private static final int SFPS = 25;
|
|
private ISimplePlayer mParentAct;
|
private GLSurfaceView mTargetSurface;
|
private RGB24GLProgram rgbProg = new RGB24GLProgram(0);
|
private YUV420PGLProgram yuvProg = new YUV420PGLProgram(0);
|
private int mScreenWidth;
|
private int mScreenHeight;
|
private int mVideoWidth;
|
private int mVideoHeight;
|
private ByteBuffer y;
|
private ByteBuffer u;
|
private ByteBuffer v;
|
private ByteBuffer blackUV;
|
private ByteBuffer rgb24;
|
|
private int mDisplayDegrees;
|
private boolean mNeedMirror = false;
|
private long mLastFrameTime = 0;
|
private long mStanderDelta;
|
private int dataType = 0; // 0:yuv420p 1:rgb24
|
|
public GLFrameRenderer(GLSurfaceView surface) {
|
// mParentAct = callback;
|
mTargetSurface = surface;
|
mDisplayDegrees = 0;
|
mNeedMirror = false;
|
mStanderDelta = 1000 / SFPS;
|
}
|
|
public void setResolution(int nWidth, int nHeight) {
|
mScreenWidth = nWidth;
|
mScreenHeight = nHeight;
|
}
|
|
@Override
|
public void onSurfaceCreated(GL10 gl, EGLConfig config) {
|
// Utils.LOGD("GLFrameRenderer :: onSurfaceCreated");
|
if (!rgbProg.isProgramBuilt()) {
|
rgbProg.buildProgram();
|
}
|
if (!yuvProg.isProgramBuilt()) {
|
yuvProg.buildProgram();
|
}
|
}
|
|
@Override
|
public void onSurfaceChanged(GL10 gl, int width, int height) {
|
// Utils.LOGD("GLFrameRenderer :: onSurfaceChanged");
|
GLES20.glViewport(0, 0, width, height);
|
}
|
|
@Override
|
public void onDrawFrame(GL10 gl) {
|
synchronized (this) {
|
if (mLastFrameTime == 0) {
|
mLastFrameTime = System.currentTimeMillis();
|
} else {
|
long currentTime = System.currentTimeMillis();
|
long delta = currentTime - mLastFrameTime;
|
if (delta < mStanderDelta) {
|
try {
|
Thread.sleep(mStanderDelta - delta);
|
} catch (InterruptedException e) {
|
e.printStackTrace();
|
}
|
}
|
mLastFrameTime = currentTime;
|
}
|
switch (dataType) {
|
case 0: {
|
// 绿帧则不渲染
|
if (y != null) {
|
if (isNullFrame(y, u, v)) {
|
return;
|
} else {
|
y.position(0);
|
u.position(0);
|
v.position(0);
|
yuvProg.buildTextures(y, u, v, mVideoWidth, mVideoHeight);
|
GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
|
GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);
|
yuvProg.drawFrame();
|
}
|
}
|
break;
|
}
|
case 1: {
|
if (rgb24 != null) {
|
rgb24.position(0);
|
rgbProg.buildTextures(rgb24, mVideoWidth, mVideoHeight, false);
|
GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);
|
GLES20.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
|
rgbProg.drawFrame();
|
}
|
break;
|
}
|
}
|
}
|
}
|
|
public void clear() {
|
switch (dataType) {
|
case 0: {
|
if (y == null || u == null || v == null) {
|
return;
|
}
|
int size = this.mVideoWidth * this.mVideoHeight;
|
byte[] b = new byte[size];
|
initBlackUV();
|
synchronized (this) {
|
y.clear();
|
u.clear();
|
v.clear();
|
y.put(b);
|
blackUV.position(0);
|
u.put(blackUV);
|
blackUV.position(0);
|
v.put(blackUV);
|
}
|
mTargetSurface.requestRender();
|
break;
|
}
|
case 1: {
|
rgb24.clear();
|
rgb24.put(new byte[rgb24.capacity()]);
|
mTargetSurface.requestRender();
|
break;
|
}
|
}
|
}
|
|
/**
|
* this method will be called from native code, it happens when the video is about to play or the
|
* video size changes.
|
*/
|
public void update(int w, int h, int dataType) {
|
this.dataType = dataType;
|
// Utils.LOGD("INIT E");
|
if (w > 0 && h > 0) {
|
|
if (mScreenWidth > 0 && mScreenHeight > 0) {
|
float f1 = 1f * mScreenHeight / mScreenWidth;
|
float f2 = 1f * h / w;
|
if (f1 == f2) {
|
rgbProg.createBuffers(RGB24GLProgram.squareVertices);
|
yuvProg.createBuffers(YUV420PGLProgram.squareVertices);
|
} else if (f1 < f2) {
|
float widScale = f1 / f2;
|
rgbProg.createBuffers(
|
new float[]{
|
-widScale, -1.0f, widScale, -1.0f, -widScale, 1.0f, widScale, 1.0f,
|
});
|
yuvProg.createBuffers(
|
new float[]{
|
-widScale, -1.0f, widScale, -1.0f, -widScale, 1.0f, widScale, 1.0f,
|
});
|
} else {
|
float heightScale = f2 / f1;
|
rgbProg.createBuffers(
|
new float[]{
|
-1.0f, -heightScale, 1.0f, -heightScale, -1.0f, heightScale, 1.0f, heightScale,
|
});
|
yuvProg.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;
|
if (dataType == 0) {
|
int uvarraySize = yarraySize / 4;
|
synchronized (this) {
|
y = ByteBuffer.allocate(yarraySize);
|
u = ByteBuffer.allocate(uvarraySize);
|
v = ByteBuffer.allocate(uvarraySize);
|
}
|
} else if (dataType == 1) {
|
synchronized (this) {
|
rgb24 = ByteBuffer.allocate(yarraySize * 3);
|
}
|
}
|
}
|
}
|
|
// mParentAct.onPlayStart();
|
// Utils.LOGD("INIT X");
|
}
|
|
/**
|
* 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);
|
}
|
// request to render
|
mTargetSurface.requestRender();
|
}
|
|
/**
|
* @param dataType 0:yuv420p 1:rgb24
|
*/
|
public void update(byte[] data, int dataType) {
|
this.dataType = dataType;
|
int size = this.mVideoWidth * this.mVideoHeight;
|
synchronized (this) {
|
switch (this.dataType) {
|
case 0: {
|
y.clear();
|
u.clear();
|
v.clear();
|
y.put(data, 0, size);
|
u.put(data, size, size / 4);
|
v.put(data, size * 5 / 4, size / 4);
|
break;
|
}
|
case 1: {
|
if (rgb24 == null) {
|
rgb24 = ByteBuffer.allocate(size * 3);
|
}
|
rgb24.clear();
|
rgb24.put(data, 0, size * 3);
|
break;
|
}
|
}
|
}
|
// request to render
|
mTargetSurface.requestRender();
|
}
|
|
/*
|
* 取图像四角与中心判定
|
* */
|
private boolean isNullFrame(ByteBuffer y, ByteBuffer u, ByteBuffer v) {
|
switch (dataType) {
|
case 0: {
|
int size = mVideoWidth * mVideoHeight;
|
if (y == null
|
|| u == null
|
|| v == null
|
|| y.capacity() < size
|
|| u.capacity() < size / 4
|
|| v.capacity() < size / 4) {
|
return true;
|
}
|
int ypos = y.position();
|
int upos = u.position();
|
int vpos = v.position();
|
int[] points = {0, mVideoWidth - 2, size / 2, size - mScreenWidth + 2, size - 2};
|
int flag = 2; // 最少两点为绿则判断为绿帧
|
|
for (int i = 0; i < 5; i++) {
|
if (y.get(points[i]) == 0 && u.get(points[i] / 4) == 0 && v.get(points[i] / 4) == 0) {
|
flag--;
|
if (flag <= 0) {
|
y.position(ypos);
|
u.position(upos);
|
v.position(vpos);
|
return true;
|
}
|
}
|
}
|
y.position(ypos);
|
u.position(upos);
|
v.position(vpos);
|
return false;
|
}
|
case 1: {
|
break;
|
}
|
}
|
return false;
|
}
|
|
private void initBlackUV() {
|
int size = mVideoWidth * mVideoHeight;
|
if (blackUV == null || blackUV.capacity() < size / 4) {
|
blackUV = ByteBuffer.allocate(size / 4);
|
blackUV.position(0);
|
for (int i = 0; i < size / 4; i++) {
|
blackUV.put((byte) 128);
|
}
|
blackUV.position(0);
|
} else {
|
blackUV.position(0);
|
}
|
}
|
|
/**
|
* this method will be called from native code, it's used for passing play state to activity.
|
*/
|
public void updateState(int state) {
|
// Utils.LOGD("updateState E = " + state);
|
if (mParentAct != null) {
|
mParentAct.onReceiveState(state);
|
}
|
// Utils.LOGD("updateState X");
|
}
|
|
public void setDisplayOrientation(int displayOrientation) {
|
mDisplayDegrees = displayOrientation;
|
rgbProg.setDisplayOrientation(displayOrientation, mNeedMirror);
|
yuvProg.setDisplayOrientation(displayOrientation, mNeedMirror);
|
}
|
|
public void displayMirror(boolean mirror) {
|
mNeedMirror = mirror;
|
rgbProg.setDisplayOrientation(mDisplayDegrees, mNeedMirror);
|
yuvProg.setDisplayOrientation(mDisplayDegrees, mNeedMirror);
|
}
|
|
public void release() {
|
rgbProg.releaseProgram();
|
yuvProg.releaseProgram();
|
}
|
}
|
