package com.basic.security.opengles;
|
|
import android.opengl.GLES20;
|
import android.opengl.GLSurfaceView;
|
import android.util.Log;
|
|
import com.basic.security.opengles.VideoRenderer.I420Frame;
|
|
import java.nio.ByteBuffer;
|
import java.nio.ByteOrder;
|
import java.nio.FloatBuffer;
|
import java.util.ArrayList;
|
import java.util.concurrent.CountDownLatch;
|
import java.util.concurrent.LinkedBlockingQueue;
|
|
import javax.microedition.khronos.egl.EGLConfig;
|
import javax.microedition.khronos.opengles.GL10;
|
|
/**
|
* Efficiently renders YUV frames using the GPU for CSC.
|
* Clients will want first to call setView() to pass GLSurfaceView
|
* and then for each video stream either create instance of VideoRenderer using
|
* createGui() call or VideoRenderer.Callbacks interface using create() call.
|
* Only one instance of the class can be created.
|
*/
|
public class VideoRendererGui implements GLSurfaceView.Renderer {
|
private static final String TAG = "VideoRendererGui";
|
private static VideoRendererGui instance = null;
|
private final String VERTEX_SHADER_STRING =
|
"varying vec2 interp_tc;\n" +
|
"attribute vec4 in_pos;\n" +
|
"attribute vec2 in_tc;\n" +
|
"\n" +
|
"void main() {\n" +
|
" gl_Position = in_pos;\n" +
|
" interp_tc = in_tc;\n" +
|
"}\n";
|
private final String FRAGMENT_SHADER_STRING =
|
"precision mediump float;\n" +
|
"varying vec2 interp_tc;\n" +
|
"\n" +
|
"uniform sampler2D y_tex;\n" +
|
"uniform sampler2D u_tex;\n" +
|
"uniform sampler2D v_tex;\n" +
|
"\n" +
|
"void main() {\n" +
|
// CSC according to http://www.fourcc.org/fccyvrgb.php
|
" float y = texture2D(y_tex, interp_tc).r;\n" +
|
" float u = texture2D(u_tex, interp_tc).r - 0.5;\n" +
|
" float v = texture2D(v_tex, interp_tc).r - 0.5;\n" +
|
" gl_FragColor = vec4(y + 1.403 * v, " +
|
" y - 0.344 * u - 0.714 * v, " +
|
" y + 1.77 * u, 1);\n" +
|
"}\n";
|
private GLSurfaceView surface;
|
|
|
private boolean onSurfaceCreatedCalled;
|
|
private ArrayList<YuvImageRenderer> yuvImageRenderers;
|
private int program;
|
|
private VideoRendererGui(GLSurfaceView surface) {
|
this.surface = surface;
|
|
surface.setPreserveEGLContextOnPause(true);
|
surface.setEGLContextClientVersion(2);
|
surface.setRenderer(this);
|
surface.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
|
yuvImageRenderers = new ArrayList<YuvImageRenderer>();
|
}
|
|
private static void abortUnless(boolean condition, String msg) {
|
if (!condition) {
|
throw new RuntimeException(msg);
|
}
|
}
|
|
private static void checkNoGLES2Error() {
|
int error = GLES20.glGetError();
|
abortUnless(error == GLES20.GL_NO_ERROR, "GLES20 error: " + error);
|
}
|
|
private static FloatBuffer directNativeFloatBuffer(float[] array) {
|
FloatBuffer buffer = ByteBuffer.allocateDirect(array.length * 4).order(
|
ByteOrder.nativeOrder()).asFloatBuffer();
|
buffer.put(array);
|
buffer.flip();
|
return buffer;
|
}
|
|
private static void addShaderTo(
|
int type, String source, int program) {
|
int[] result = new int[]{
|
GLES20.GL_FALSE
|
};
|
int shader = GLES20.glCreateShader(type);
|
GLES20.glShaderSource(shader, source);
|
GLES20.glCompileShader(shader);
|
GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, result, 0);
|
abortUnless(result[0] == GLES20.GL_TRUE,
|
GLES20.glGetShaderInfoLog(shader) + ", source: " + source);
|
GLES20.glAttachShader(program, shader);
|
GLES20.glDeleteShader(shader);
|
checkNoGLES2Error();
|
}
|
|
/**
|
* Passes GLSurfaceView to video renderer.
|
*/
|
public static void setView(GLSurfaceView surface) {
|
Log.v(TAG, "VideoRendererGui.setView");
|
instance = new VideoRendererGui(surface);
|
}
|
|
/**
|
* Creates VideoRenderer.Callbacks with top left corner at (x, y) and
|
* resolution (width, height). All parameters are in percentage of
|
* screen resolution.
|
*/
|
public static YuvImageRenderer create(
|
int x, int y, int width, int height) {
|
|
if (x < 0 || x > 100 || y < 0 || y > 100 ||
|
width < 0 || width > 100 || height < 0 || height > 100 ||
|
x + width > 100 || y + height > 100) {
|
throw new RuntimeException("Incorrect window parameters.");
|
}
|
if (instance == null) {
|
throw new RuntimeException(
|
"Attempt to create yuv renderer before setting GLSurfaceView");
|
}
|
final YuvImageRenderer yuvImageRenderer = new YuvImageRenderer(
|
instance.surface, x, y, width, height);
|
synchronized (instance.yuvImageRenderers) {
|
if (instance.onSurfaceCreatedCalled) {
|
|
|
final CountDownLatch countDownLatch = new CountDownLatch(1);
|
instance.surface.queueEvent(new Runnable() {
|
public void run() {
|
yuvImageRenderer.createTextures(instance.program);
|
countDownLatch.countDown();
|
}
|
});
|
|
try {
|
countDownLatch.await();
|
} catch (InterruptedException e) {
|
throw new RuntimeException(e);
|
}
|
}
|
|
instance.yuvImageRenderers.add(yuvImageRenderer);
|
}
|
return yuvImageRenderer;
|
}
|
|
/**
|
* Creates VideoRenderer with top left corner at (x, y) and resolution
|
* (width, height). All parameters are in percentage of screen resolution.
|
*/
|
@Override
|
public void onSurfaceCreated(GL10 unused, EGLConfig config) {
|
Log.v(TAG, "VideoRendererGui.onSurfaceCreated");
|
|
program = GLES20.glCreateProgram();
|
addShaderTo(GLES20.GL_VERTEX_SHADER, VERTEX_SHADER_STRING, program);
|
addShaderTo(GLES20.GL_FRAGMENT_SHADER, FRAGMENT_SHADER_STRING, program);
|
GLES20.glLinkProgram(program);
|
int[] result = new int[]{
|
GLES20.GL_FALSE
|
};
|
result[0] = GLES20.GL_FALSE;
|
GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, result, 0);
|
abortUnless(result[0] == GLES20.GL_TRUE,
|
GLES20.glGetProgramInfoLog(program));
|
GLES20.glUseProgram(program);
|
GLES20.glUniform1i(GLES20.glGetUniformLocation(program, "y_tex"), 0);
|
GLES20.glUniform1i(GLES20.glGetUniformLocation(program, "u_tex"), 1);
|
GLES20.glUniform1i(GLES20.glGetUniformLocation(program, "v_tex"), 2);
|
synchronized (yuvImageRenderers) {
|
|
for (YuvImageRenderer yuvImageRenderer : yuvImageRenderers) {
|
yuvImageRenderer.createTextures(program);
|
}
|
onSurfaceCreatedCalled = true;
|
}
|
checkNoGLES2Error();
|
GLES20.glClearColor(0.0f, 0.0f, 0.3f, 1.0f);
|
}
|
|
@Override
|
public void onSurfaceChanged(GL10 unused, int width, int height) {
|
Log.v(TAG, "VideoRendererGui.onSurfaceChanged: " +
|
width + " x " + height + " ");
|
GLES20.glViewport(0, 0, width, height);
|
}
|
|
@Override
|
public void onDrawFrame(GL10 unused) {
|
GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
|
synchronized (yuvImageRenderers) {
|
for (YuvImageRenderer yuvImageRenderer : yuvImageRenderers) {
|
yuvImageRenderer.draw();
|
}
|
}
|
}
|
|
/**
|
* Class used to display stream of YUV420 frames at particular location
|
* on a screen. New video frames are sent to display using renderFrame()
|
* call.
|
*/
|
public static class YuvImageRenderer implements VideoRenderer.Callbacks {
|
|
private final FloatBuffer textureCoords = directNativeFloatBuffer(
|
new float[]{
|
0, 0, 0, 1, 1, 0, 1, 1
|
});
|
|
|
LinkedBlockingQueue<I420Frame> frameToRenderQueue;
|
|
boolean seenFrame;
|
private GLSurfaceView surface;
|
private int program;
|
private FloatBuffer textureVertices;
|
private int[] yuvTextures = {-1, -1, -1};
|
|
private I420Frame frameToRender;
|
|
private int framesReceived;
|
|
|
private int framesDropped;
|
|
private int framesRendered;
|
|
private long startTimeNs = -1;
|
|
private long drawTimeNs;
|
|
|
private long copyTimeNs;
|
|
private YuvImageRenderer(
|
GLSurfaceView surface,
|
int x, int y, int width, int height) {
|
Log.v(TAG, "YuvImageRenderer.Create");
|
this.surface = surface;
|
frameToRenderQueue = new LinkedBlockingQueue<I420Frame>(1);
|
|
float xLeft = (x - 50) / 50.0f;
|
float yTop = (50 - y) / 50.0f;
|
float xRight = Math.min(1.0f, (x + width - 50) / 50.0f);
|
float yBottom = Math.max(-1.0f, (50 - y - height) / 50.0f);
|
float textureVeticesFloat[] = new float[]{
|
xLeft, yTop,
|
xLeft, yBottom,
|
xRight, yTop,
|
xRight, yBottom
|
};
|
textureVertices = directNativeFloatBuffer(textureVeticesFloat);
|
}
|
|
private void createTextures(int program) {
|
Log.v(TAG, " YuvImageRenderer.createTextures");
|
this.program = program;
|
|
GLES20.glGenTextures(3, yuvTextures, 0);
|
for (int i = 0; i < 3; i++) {
|
GLES20.glActiveTexture(GLES20.GL_TEXTURE0 + i);
|
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, yuvTextures[i]);
|
GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_LUMINANCE,
|
128, 128, 0, GLES20.GL_LUMINANCE, GLES20.GL_UNSIGNED_BYTE, null);
|
GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D,
|
GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
|
GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D,
|
GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
|
GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D,
|
GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
|
GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D,
|
GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
|
}
|
checkNoGLES2Error();
|
}
|
|
private void draw() {
|
long now = System.nanoTime();
|
if (!seenFrame) {
|
|
return;
|
}
|
I420Frame frameFromQueue;
|
synchronized (frameToRenderQueue) {
|
frameFromQueue = frameToRenderQueue.peek();
|
if (frameFromQueue != null && startTimeNs == -1) {
|
startTimeNs = now;
|
}
|
for (int i = 0; i < 3; ++i) {
|
int w = (i == 0) ? frameToRender.width : frameToRender.width / 2;
|
int h = (i == 0) ? frameToRender.height : frameToRender.height / 2;
|
GLES20.glActiveTexture(GLES20.GL_TEXTURE0 + i);
|
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, yuvTextures[i]);
|
if (frameFromQueue != null) {
|
GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_LUMINANCE,
|
w, h, 0, GLES20.GL_LUMINANCE, GLES20.GL_UNSIGNED_BYTE,
|
frameFromQueue.yuvPlanes[i]);
|
}
|
}
|
if (frameFromQueue != null) {
|
frameToRenderQueue.poll();
|
}
|
}
|
int posLocation = GLES20.glGetAttribLocation(program, "in_pos");
|
GLES20.glEnableVertexAttribArray(posLocation);
|
GLES20.glVertexAttribPointer(
|
posLocation, 2, GLES20.GL_FLOAT, false, 0, textureVertices);
|
int texLocation = GLES20.glGetAttribLocation(program, "in_tc");
|
GLES20.glEnableVertexAttribArray(texLocation);
|
GLES20.glVertexAttribPointer(
|
texLocation, 2, GLES20.GL_FLOAT, false, 0, textureCoords);
|
GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
|
GLES20.glDisableVertexAttribArray(posLocation);
|
GLES20.glDisableVertexAttribArray(texLocation);
|
checkNoGLES2Error();
|
if (frameFromQueue != null) {
|
framesRendered++;
|
drawTimeNs += (System.nanoTime() - now);
|
if ((framesRendered % 150) == 0) {
|
logStatistics();
|
}
|
}
|
}
|
|
private void logStatistics() {
|
long timeSinceFirstFrameNs = System.nanoTime() - startTimeNs;
|
Log.v(TAG, "Frames received: " + framesReceived + ". Dropped: " +
|
framesDropped + ". Rendered: " + framesRendered);
|
if (framesReceived > 0 && framesRendered > 0) {
|
Log.v(TAG, "Duration: " + (int) (timeSinceFirstFrameNs / 1e6) +
|
" ms. FPS: " + (float) framesRendered * 1e9 / timeSinceFirstFrameNs);
|
Log.v(TAG, "Draw time: " +
|
(int) (drawTimeNs / (1000 * framesRendered)) + " us. Copy time: " +
|
(int) (copyTimeNs / (1000 * framesReceived)) + " us");
|
}
|
}
|
|
@Override
|
public void setSize(final int width, final int height) {
|
Log.v(TAG, "YuvImageRenderer.setSize: " + width + " x " + height);
|
int[] strides = {width, width / 2, width / 2};
|
|
|
synchronized (frameToRenderQueue) {
|
|
frameToRenderQueue.poll();
|
|
frameToRender = new I420Frame(width, height, strides, null);
|
}
|
}
|
|
@Override
|
public synchronized void renderFrame(I420Frame frame) {
|
long now = System.nanoTime();
|
framesReceived++;
|
if (!(frame.yuvStrides[0] == frame.width &&
|
frame.yuvStrides[1] == frame.width / 2 &&
|
frame.yuvStrides[2] == frame.width / 2)) {
|
Log.e(TAG, "Incorrect strides " + frame.yuvStrides[0] + ", " +
|
frame.yuvStrides[1] + ", " + frame.yuvStrides[2]);
|
return;
|
}
|
if (frameToRender == null) {
|
framesDropped++;
|
return;
|
}
|
|
if (frame.width != frameToRender.width ||
|
frame.height != frameToRender.height) {
|
throw new RuntimeException("Wrong frame size " +
|
frame.width + " x " + frame.height);
|
}
|
if (frameToRenderQueue.size() > 0) {
|
|
framesDropped++;
|
return;
|
}
|
frameToRender.copyFrom(frame);
|
copyTimeNs += (System.nanoTime() - now);
|
frameToRenderQueue.offer(frameToRender);
|
seenFrame = true;
|
surface.requestRender();
|
}
|
}
|
}
|
