Android Camera開發:使用GLSurfaceView預覽Camera 基礎拍照

GLSurfaceView是OpenGL中的一個類，也是可以預覽Camera的，而且在預覽Camera上有其獨到之處。獨到之處在哪？當使用Surfaceview無能為力、痛不欲生時就只有使用GLSurfaceView了，它能夠真正做到讓Camera的數據和顯示分離，所以搞明白了這個，像Camera只開預覽不顯示這都是小菜，妥妥的。Android4.0的自帶Camera源碼是用SurfaceView預覽的，但到了4.2就換成了GLSurfaceView來預覽。如今到了4.4又用了自家的TextureView，所以從中可以窺探出新增TextureView的用意。

雖說Android4.2的Camera源碼是用GLSurfaceView預覽的，但是進行了大量的封裝又封裝的，由於是OpenGL小白，真是看的不知所雲。俺滴要求不高，只想弄個可拍照的摸清GLSurfaceView在預覽Camera上的使用流程。經過一番百度一無所獲，后來翻出去Google一大圈也沒發現可用的。倒是很多人都在用GLSurfaceView和Surfaceview同時預覽Camera，Surfaceview用來預覽數據，在上面又鋪了一層GLSurfaceView繪制一些信息。無奈自己摸索，整出來的是能拍照也能得到數據，但是界面上不是一塊白板就是一塊黑板啥都不顯示。后來在stackoverflow終於找到了一個可用的鏈接，，蒼天啊，終於柳暗花明了！參考此鏈接，自己又改改摸索了一天才徹底搞定。之所以費這么多時間是不明白OpenGL ES2.0的繪制基本流程，跟簡單的OpenGL的繪制還是稍有區別。下面上源碼:

一、CameraGLSurfaceView.java 此類繼承GLSurfaceView，並實現了兩個接口

 

package org.yanzi.camera.preview;

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

import org.yanzi.camera.CameraInterface;

import android.content.Context;
import android.graphics.SurfaceTexture;
import android.opengl.GLES11Ext;
import android.opengl.GLES20;
import android.opengl.GLSurfaceView;
import android.opengl.GLSurfaceView.Renderer;
import android.util.AttributeSet;
import android.util.Log;

public class CameraGLSurfaceView extends GLSurfaceView implements Renderer, SurfaceTexture.OnFrameAvailableListener {
    private static final String TAG = "yanzi";
    Context mContext;
    SurfaceTexture mSurface;
    int mTextureID = -1;
    DirectDrawer mDirectDrawer;
    public CameraGLSurfaceView(Context context, AttributeSet attrs) {
        super(context, attrs);
        // TODO Auto-generated constructor stub
        mContext = context;
        setEGLContextClientVersion(2);
        setRenderer(this);
        setRenderMode(RENDERMODE_WHEN_DIRTY);
    }
    @Override
    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
        // TODO Auto-generated method stub
        Log.i(TAG, "onSurfaceCreated...");
        mTextureID = createTextureID();
        mSurface = new SurfaceTexture(mTextureID);
        mSurface.setOnFrameAvailableListener(this);
        mDirectDrawer = new DirectDrawer(mTextureID);
        CameraInterface.getInstance().doOpenCamera(null);

    }
    @Override
    public void onSurfaceChanged(GL10 gl, int width, int height) {
        // TODO Auto-generated method stub
        Log.i(TAG, "onSurfaceChanged...");
        GLES20.glViewport(0, 0, width, height);
        if(!CameraInterface.getInstance().isPreviewing()){
            CameraInterface.getInstance().doStartPreview(mSurface, 1.33f);
        }
    

    }
    @Override
    public void onDrawFrame(GL10 gl) {
        // TODO Auto-generated method stub
        Log.i(TAG, "onDrawFrame...");
        GLES20.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);
        mSurface.updateTexImage();
        float[] mtx = new float[16];
        mSurface.getTransformMatrix(mtx);
        mDirectDrawer.draw(mtx);
    }
    
    @Override
    public void onPause() {
        // TODO Auto-generated method stub
        super.onPause();
        CameraInterface.getInstance().doStopCamera();
    }
    private int createTextureID()
    {
        int[] texture = new int[1];

        GLES20.glGenTextures(1, texture, 0);
        GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, texture[0]);
        GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
                GL10.GL_TEXTURE_MIN_FILTER,GL10.GL_LINEAR);        
        GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
                GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
        GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
                GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE);
        GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
                GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE);

        return texture[0];
    }
    public SurfaceTexture _getSurfaceTexture(){
        return mSurface;
    }
    @Override
    public void onFrameAvailable(SurfaceTexture surfaceTexture) {
        // TODO Auto-generated method stub
        Log.i(TAG, "onFrameAvailable...");
        this.requestRender();
    }

}

 

關於這個類進行簡單說明:

 

1、Renderer這個接口里有三個回調: onSurfaceCreated() onSurfaceChanged() onDrawFrame(),在onSurfaceCreated里設置了GLSurfaceView的版本: setEGLContextClientVersion(2); 如果沒這個設置是啥都畫不出來了，因為Android支持OpenGL ES1.1和2.0及最新的3.0，而且版本間差別很大。不告訴他版本他不知道用哪個版本的api渲染。在設置setRenderer(this);后，再設置它的模式為RENDERMODE_WHEN_DIRTY。這個也很關鍵，看api：

 

When renderMode is RENDERMODE_CONTINUOUSLY, the renderer is called repeatedly to re-render the scene. When renderMode is RENDERMODE_WHEN_DIRTY, the renderer only rendered when the surface is created, or when requestRender is called. Defaults to RENDERMODE_CONTINUOUSLY.

Using RENDERMODE_WHEN_DIRTY can improve battery life and overall system performance by allowing the GPU and CPU to idle when the view does not need to be updated. 

大意是RENDERMODE_CONTINUOUSLY模式就會一直Render，如果設置成RENDERMODE_WHEN_DIRTY，就是當有數據時才rendered或者主動調用了GLSurfaceView的requestRender.默認是連續模式，很顯然Camera適合臟模式，一秒30幀，當有數據來時再渲染。

2、正因是RENDERMODE_WHEN_DIRTY所以就要告訴GLSurfaceView什么時候Render，也就是啥時候進到onDrawFrame()這個函數里。SurfaceTexture.OnFrameAvailableListener這個接口就干了這么一件事，當有數據上來后會進到

public void onFrameAvailable(SurfaceTexture surfaceTexture) {
// TODO Auto-generated method stub
Log.i(TAG, "onFrameAvailable...");
this.requestRender();
}

 

這里，然后執行requestRender()。

3、網上有一些OpenGL ES的示例是在Activity里實現了SurfaceTexture.OnFrameAvailableListener此接口，其實這個無所謂。無論是被誰實現，關鍵看在回調里干了什么事。

4、與TextureView里對比可知，TextureView預覽時因為實現了SurfaceTextureListener會自動創建SurfaceTexture。但在GLSurfaceView里則要手動創建同時綁定一個紋理ID。

5、本文在onSurfaceCreated()里打開Camera，在onSurfaceChanged()里開啟預覽，默認1.33的比例。原因是相比前兩種預覽，此處SurfaceTexture創建需要一定時間。如果想要開預覽時由Activity發起，則要GLSurfaceView利用Handler將創建的SurfaceTexture傳遞給Activity。

 

二、DirectDrawer.java 此類非常關鍵，負責將SurfaceTexture內容繪制到屏幕上

 

package org.yanzi.camera.preview;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.nio.ShortBuffer;

import android.opengl.GLES11Ext;
import android.opengl.GLES20;
import android.opengl.Matrix;

public class DirectDrawer {
    private final String vertexShaderCode =
            "attribute vec4 vPosition;" +
            "attribute vec2 inputTextureCoordinate;" +
            "varying vec2 textureCoordinate;" +
            "void main()" +
            "{"+
                "gl_Position = vPosition;"+
                "textureCoordinate = inputTextureCoordinate;" +
            "}";

    private final String fragmentShaderCode =
            "#extension GL_OES_EGL_image_external : require\n"+
            "precision mediump float;" +
            "varying vec2 textureCoordinate;\n" +
            "uniform samplerExternalOES s_texture;\n" +
            "void main() {" +
            "  gl_FragColor = texture2D( s_texture, textureCoordinate );\n" +
            "}";

    private FloatBuffer vertexBuffer, textureVerticesBuffer;
    private ShortBuffer drawListBuffer;
    private final int mProgram;
    private int mPositionHandle;
    private int mTextureCoordHandle;

    private short drawOrder[] = { 0, 1, 2, 0, 2, 3 }; // order to draw vertices

    // number of coordinates per vertex in this array
    private static final int COORDS_PER_VERTEX = 2;

    private final int vertexStride = COORDS_PER_VERTEX * 4; // 4 bytes per vertex

    static float squareCoords[] = {
       -1.0f,  1.0f,
       -1.0f, -1.0f,
        1.0f, -1.0f,
        1.0f,  1.0f,
    };

    static float textureVertices[] = {
        0.0f, 1.0f,
        1.0f, 1.0f,
        1.0f, 0.0f,
        0.0f, 0.0f,
    };

    private int texture;

    public DirectDrawer(int texture)
    {
        this.texture = texture;
        // initialize vertex byte buffer for shape coordinates
        ByteBuffer bb = ByteBuffer.allocateDirect(squareCoords.length * 4);
        bb.order(ByteOrder.nativeOrder());
        vertexBuffer = bb.asFloatBuffer();
        vertexBuffer.put(squareCoords);
        vertexBuffer.position(0);

        // initialize byte buffer for the draw list
        ByteBuffer dlb = ByteBuffer.allocateDirect(drawOrder.length * 2);
        dlb.order(ByteOrder.nativeOrder());
        drawListBuffer = dlb.asShortBuffer();
        drawListBuffer.put(drawOrder);
        drawListBuffer.position(0);

        ByteBuffer bb2 = ByteBuffer.allocateDirect(textureVertices.length * 4);
        bb2.order(ByteOrder.nativeOrder());
        textureVerticesBuffer = bb2.asFloatBuffer();
        textureVerticesBuffer.put(textureVertices);
        textureVerticesBuffer.position(0);

        int vertexShader    = loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);
        int fragmentShader  = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode);

        mProgram = GLES20.glCreateProgram();             // create empty OpenGL ES Program
        GLES20.glAttachShader(mProgram, vertexShader);   // add the vertex shader to program
        GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment shader to program
        GLES20.glLinkProgram(mProgram);                  // creates OpenGL ES program executables
    }

    public void draw(float[] mtx)
    {
        GLES20.glUseProgram(mProgram);

        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
        GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, texture);

        // get handle to vertex shader's vPosition member
        mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");

        // Enable a handle to the triangle vertices
        GLES20.glEnableVertexAttribArray(mPositionHandle);

        // Prepare the <insert shape here> coordinate data
        GLES20.glVertexAttribPointer(mPositionHandle, COORDS_PER_VERTEX, GLES20.GL_FLOAT, false, vertexStride, vertexBuffer);

        mTextureCoordHandle = GLES20.glGetAttribLocation(mProgram, "inputTextureCoordinate");
        GLES20.glEnableVertexAttribArray(mTextureCoordHandle);
        
//        textureVerticesBuffer.clear();
//        textureVerticesBuffer.put( transformTextureCoordinates( textureVertices, mtx ));
//        textureVerticesBuffer.position(0);
        GLES20.glVertexAttribPointer(mTextureCoordHandle, COORDS_PER_VERTEX, GLES20.GL_FLOAT, false, vertexStride, textureVerticesBuffer);

        GLES20.glDrawElements(GLES20.GL_TRIANGLES, drawOrder.length, GLES20.GL_UNSIGNED_SHORT, drawListBuffer);

        // Disable vertex array
        GLES20.glDisableVertexAttribArray(mPositionHandle);
        GLES20.glDisableVertexAttribArray(mTextureCoordHandle);
    }
    
    private  int loadShader(int type, String shaderCode){

        // create a vertex shader type (GLES20.GL_VERTEX_SHADER)
        // or a fragment shader type (GLES20.GL_FRAGMENT_SHADER)
        int shader = GLES20.glCreateShader(type);

        // add the source code to the shader and compile it
        GLES20.glShaderSource(shader, shaderCode);
        GLES20.glCompileShader(shader);

        return shader;
    }
    private float[] transformTextureCoordinates( float[] coords, float[] matrix)
    {          
       float[] result = new float[ coords.length ];        
       float[] vt = new float[4];      

       for ( int i = 0 ; i < coords.length ; i += 2 ) {
           float[] v = { coords[i], coords[i+1], 0 , 1  };
           Matrix.multiplyMV(vt, 0, matrix, 0, v, 0);
           result[i] = vt[0];
           result[i+1] = vt[1];
       }
       return result;
    }
}

 

三、有了上面兩個類就完成95%的工作，可以將GLSurfaceView看成是有生命周期的。在onPause里進行關閉Camera，在Activity里復寫兩個方法:

       @Override
    protected void onResume() {
        // TODO Auto-generated method stub
        super.onResume();
        glSurfaceView.bringToFront();
    }

    @Override
    protected void onPause() {
        // TODO Auto-generated method stub
        super.onPause();
        glSurfaceView.onPause();
    }    

 

這個glSurfaceView.bringToFront();其實不寫也中。在布局里寫入自定義的GLSurfaceView就ok了:

    <FrameLayout

        android:layout_width="wrap_content"
        android:layout_height="wrap_content" >
        <org.yanzi.camera.preview.CameraGLSurfaceView
            android:id="@+id/camera_textureview"
            android:layout_width="0dip"
            android:layout_height="0dip" />
    </FrameLayout>

 

CameraActivity里只負責UI部分，CameraGLSurfaceView負責開Camera、預覽，並調用DirectDrawer里的draw()進行繪制。其他代碼就不上了。

 

注意事項:

1、在onDrawFrame()里，如果不調用mDirectDrawer.draw(mtx);是啥都顯示不出來的！！！這是GLSurfaceView的特別之處。為啥呢？因為GLSurfaceView不是Android親生的，而Surfaceview和TextureView是。所以得自己按照OpenGL ES的流程畫。

2、究竟mDirectDrawer.draw(mtx)里在哪獲取的Buffer目前雜家還么看太明白，貌似么有請求buffer，而是根據GLSurfaceView里創建的SurfaceTexture之前，生成的有個紋理ID。這個紋理ID一方面跟SurfaceTexture是綁定在一起的，另一方面跟DirectDrawer綁定，而SurfaceTexture作渲染載體。

3、參考鏈接里有,有人為了解決問題，給出了下面三段代碼:

 

@Override
public void onDrawFrame(GL10 gl)
{
    float[] mtx = new float[16];
    mSurface.updateTexImage();
    mSurface.getTransformMatrix(mtx);    

    mDirectVideo.draw(mtx);
}
 private float[] transformTextureCoordinates( float[] coords, float[] matrix)
 {          
    float[] result = new float[ coords.length ];        
    float[] vt = new float[4];      

    for ( int i = 0 ; i < coords.length ; i += 2 ) {
        float[] v = { coords[i], coords[i+1], 0 , 1  };
        Matrix.multiplyMV(vt, 0, matrix, 0, v, 0);
        result[i] = vt[0];
        result[i+1] = vt[1];
    }
    return result;
 }
textureVerticesBuffer.clear();
textureVerticesBuffer.put( transformTextureCoordinates( textureVertices, mtx ));
textureVerticesBuffer.position(0);

 

我已經把代碼都融入到了此demo，只不過在draw()方法里么有使用。原因是使用之后，得到的預覽畫面反而是變形的，而不用的話是ok的。上面的代碼是得到SurfaceTexture的變換矩陣：mSurface.getTransformMatrix

 

然后將此矩陣傳遞給draw()，在draw的時候對textureVerticesBuffer作一個變化，然后再畫。

下圖是未加這個矩陣變換效果時:

下圖為使用了變換矩陣，划片扭曲的還真說不上來咋扭曲的，但足以說明OpenGL ES在渲染效果上的強大，就是設置了個矩陣，不用一幀幀處理，就能得到不一樣顯示效果。

 

 

 

-----------------------------本文系原創，轉載請注明作者yanzi1225627

版本號:PlayCamera_V3.0.0[2014-6-22].zip

CSDN下載鏈接:http://download.csdn.net/detail/yanzi1225627/7547263

百度雲盤:

附個OpenGL ES簡明教程：http://www.apkbus.com/android-20427-1-1.html