Media Module之Camera(四) 拍照 底层分析

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Media Module之Camera(四) 拍照 底层分析相关的知识,希望对你有一定的参考价值。

参考技术A 下面主要介绍拍照流程的底层实现。

当指定了Camera的预览类,并开始预览之后,就可以通过takePicture()方法进行拍照了。它将以异步的方式从Camera中获取图像,具有多个回调类作为参数,并且都可以为null,下面分别介绍这些参数的意义:
• shutter:在按下快门的时候回调,这里可以播放一段声音。
• raw:从Camera获取到未经处理的图像。
• postview:从Camera获取一个快速预览的图片,不是所有设备都支持。
• jpeg:从Camera获取到一个经过压缩的jpeg图片。
  虽然raw、postview、jpeg都是Camera.PictureCallback回调,但是一般我们只需要获取jpeg,其他传null即可,Camera.PictureCallback里需要实现一个方法onPictureTaken(byte[] data,Camera camera),data及为图像数据。值得注意的是,一般taskPicture()方法拍照完成之后,SurfaceView都会停留在拍照的瞬间,需要重新调用startPreview()才会继续预览。
  如果直接使用taskPicture()进行拍照的话,Camera是不会进行自动对焦的,这里需要使用Camera.autoFocus()方法进行对焦,它传递一个Camera.AutoFocusCallback参数,用于自动对焦完成后回调,一般会在它对焦完成在进行taskPicture()拍照。

首先拍照的流程直接从Camera.java的takePicture开始分析。

可以看出,在方法中对各种回调的值进行了赋值,继续看底层对调函数的处理。

在应用层注册回调。
packages\apps\SnapdragonCamera\src\com\android\camera\AndroidCameraManagerImpl.java

在应用层实现回调。

这里就是真正存储数据的地方了,在android系统有四个地方可以存储共同数据区,
ContentProvider,sharedpreference、file、sqlite这几种方式,这里利用的是file方式。

然后调用到JNI层相应方法。

根据之前分析的binder机制,Camera.cpp -> ICamera.cpp -> CameraClient.cpp(server端)

此处的takepicture是在CameraHardwareInterface.h定义的方法。

frameworks/av/services/camera/libcameraservice/device1/CameraHardwareInterface.h

在CameraClient.cpp开始调用到HAL层中进行处理,接下来主要分析在

hardware/qcom/camera/QCamera2/HAL/QCamera2HWI.cpp得具体实现。

在此方法中去更新状态机的状态。

hardware/qcom/camera/QCamera2/HAL/QCameraStateMachine.cpp

首先调用回QCamera2HWI.cpp的prepareHardwareForSnapshot方法。

接着调用到mm_camera_interface.c的mm_camera_intf_prepare_snapshot方法。

hardware/qcom/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_interface.c

接着调用mm_camera.c的mm_camera_prepare_snapshot方法,去与V4L2通信,准备拍照。

hardware/qcom/camera/QCamera2/stack/mm-camera-interface/src/mm_camera.c

当底层对拍照准备完成之后,会调用到QCamera2HWICallbacks.cpp里,处理metadata

数据的方法metadata_stream_cb_routine中。

hardware/qcom/camera/QCamera2/HAL/QCamera2HWICallbacks.cpp

之后返回到QCamera2HWI.cpp类里的take_picture方法,继续下面的操作。

此处又返回到QCamera2HWI.cpp类里的takePicture()方法中。

首先先停止并删除了preview的channel,然后调用addCaptureChannel()方法。

可以看出,在此方法中创建并初始化了channel,并且添加mediadata,postview,snapshot数据流到channel中。

返回到hardware/qcom/camera/QCamera2/HAL/QCamera2HWI.cpp的takePicture()方法中,继续调用到开启capture的channel。

channel的start方法在之前的preview流程中具体介绍过,在此不做分析。

之后又调用了QCameraChannel.cpp的startAdvancedCapture方法,然后是mm-camera-interface.c的process_advanced_capture方法,然后是mm-camera.c的mm_camera_channel_advanced_capture方法,这一系列方法设置了当前管道是拍照模式。

通过mm-jpeg-interface.c处理数据流,并且生成jpeg文件,然后在QCamera2HWI.cpp中处理从mm-jpeg-interface.c发出的jpeg相关事件。

此处更改了状态机的状态。

然后调用回QCamera2HWI.cpp的processJpegNotify方法

此处调用的是QCameraPostProc.cpp的processJpegEvt方法。

hardware/qcom/camera/QCamera2/HAL/QCameraPostProc.cpp

接着调用sendDataNotify方法。

可以看出此处在给回调的对象装填数据,并且发出通知notifyCallback回调。并且,类型为CAMERA_MSG_COMPRESSED_IMAGE。

之后的流程与preview的流程相似,将数据向上层抛送,通过JNI返回到java层的回调函数中。

转玩转Android Camera开发:国内首发---使用GLSurfaceView预览Camera 基础拍照demo

http://blog.csdn.net/yanzi1225627/article/details/33339965

 

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,并实现了两个接口

 

[java] view plain copy
 
 print?技术分享技术分享
  1. <span style="font-family:Comic Sans MS;font-size:18px;">package org.yanzi.camera.preview;  
  2.   
  3. import javax.microedition.khronos.egl.EGLConfig;  
  4. import javax.microedition.khronos.opengles.GL10;  
  5.   
  6. import org.yanzi.camera.CameraInterface;  
  7.   
  8. import android.content.Context;  
  9. import android.graphics.SurfaceTexture;  
  10. import android.opengl.GLES11Ext;  
  11. import android.opengl.GLES20;  
  12. import android.opengl.GLSurfaceView;  
  13. import android.opengl.GLSurfaceView.Renderer;  
  14. import android.util.AttributeSet;  
  15. import android.util.Log;  
  16.   
  17. public class CameraGLSurfaceView extends GLSurfaceView implements Renderer, SurfaceTexture.OnFrameAvailableListener {  
  18.     private static final String TAG = "yanzi";  
  19.     Context mContext;  
  20.     SurfaceTexture mSurface;  
  21.     int mTextureID = -1;  
  22.     DirectDrawer mDirectDrawer;  
  23.     public CameraGLSurfaceView(Context context, AttributeSet attrs) {  
  24.         super(context, attrs);  
  25.         // TODO Auto-generated constructor stub  
  26.         mContext = context;  
  27.         setEGLContextClientVersion(2);  
  28.         setRenderer(this);  
  29.         setRenderMode(RENDERMODE_WHEN_DIRTY);  
  30.     }  
  31.     @Override  
  32.     public void onSurfaceCreated(GL10 gl, EGLConfig config) {  
  33.         // TODO Auto-generated method stub  
  34.         Log.i(TAG, "onSurfaceCreated...");  
  35.         mTextureID = createTextureID();  
  36.         mSurface = new SurfaceTexture(mTextureID);  
  37.         mSurface.setOnFrameAvailableListener(this);  
  38.         mDirectDrawer = new DirectDrawer(mTextureID);  
  39.         CameraInterface.getInstance().doOpenCamera(null);  
  40.   
  41.     }  
  42.     @Override  
  43.     public void onSurfaceChanged(GL10 gl, int width, int height) {  
  44.         // TODO Auto-generated method stub  
  45.         Log.i(TAG, "onSurfaceChanged...");  
  46.         GLES20.glViewport(0, 0, width, height);  
  47.         if(!CameraInterface.getInstance().isPreviewing()){  
  48.             CameraInterface.getInstance().doStartPreview(mSurface, 1.33f);  
  49.         }  
  50.       
  51.   
  52.     }  
  53.     @Override  
  54.     public void onDrawFrame(GL10 gl) {  
  55.         // TODO Auto-generated method stub  
  56.         Log.i(TAG, "onDrawFrame...");  
  57.         GLES20.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);  
  58.         GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);  
  59.         mSurface.updateTexImage();  
  60.         float[] mtx = new float[16];  
  61.         mSurface.getTransformMatrix(mtx);  
  62.         mDirectDrawer.draw(mtx);  
  63.     }  
  64.       
  65.     @Override  
  66.     public void onPause() {  
  67.         // TODO Auto-generated method stub  
  68.         super.onPause();  
  69.         CameraInterface.getInstance().doStopCamera();  
  70.     }  
  71.     private int createTextureID()  
  72.     {  
  73.         int[] texture = new int[1];  
  74.   
  75.         GLES20.glGenTextures(1, texture, 0);  
  76.         GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, texture[0]);  
  77.         GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,  
  78.                 GL10.GL_TEXTURE_MIN_FILTER,GL10.GL_LINEAR);          
  79.         GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,  
  80.                 GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);  
  81.         GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,  
  82.                 GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE);  
  83.         GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,  
  84.                 GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE);  
  85.   
  86.         return texture[0];  
  87.     }  
  88.     public SurfaceTexture _getSurfaceTexture(){  
  89.         return mSurface;  
  90.     }  
  91.     @Override  
  92.     public void onFrameAvailable(SurfaceTexture surfaceTexture) {  
  93.         // TODO Auto-generated method stub  
  94.         Log.i(TAG, "onFrameAvailable...");  
  95.         this.requestRender();  
  96.     }  
  97.   
  98. }  
  99. </span>  

关于这个类进行简单说明:

 

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内容绘制到屏幕上

 

[java] view plain copy
 
 print?技术分享技术分享
  1. <span style="font-family:Comic Sans MS;font-size:18px;">package org.yanzi.camera.preview;  
  2.   
  3. import java.nio.ByteBuffer;  
  4. import java.nio.ByteOrder;  
  5. import java.nio.FloatBuffer;  
  6. import java.nio.ShortBuffer;  
  7.   
  8. import android.opengl.GLES11Ext;  
  9. import android.opengl.GLES20;  
  10. import android.opengl.Matrix;  
  11.   
  12. public class DirectDrawer {  
  13.     private final String vertexShaderCode =  
  14.             "attribute vec4 vPosition;" +  
  15.             "attribute vec2 inputTextureCoordinate;" +  
  16.             "varying vec2 textureCoordinate;" +  
  17.             "void main()" +  
  18.             "{"+  
  19.                 "gl_Position = vPosition;"+  
  20.                 "textureCoordinate = inputTextureCoordinate;" +  
  21.             "}";  
  22.   
  23.     private final String fragmentShaderCode =  
  24.             "#extension GL_OES_EGL_image_external : require\n"+  
  25.             "precision mediump float;" +  
  26.             "varying vec2 textureCoordinate;\n" +  
  27.             "uniform samplerExternalOES s_texture;\n" +  
  28.             "void main() {" +  
  29.             "  gl_FragColor = texture2D( s_texture, textureCoordinate );\n" +  
  30.             "}";  
  31.   
  32.     private FloatBuffer vertexBuffer, textureVerticesBuffer;  
  33.     private ShortBuffer drawListBuffer;  
  34.     private final int mProgram;  
  35.     private int mPositionHandle;  
  36.     private int mTextureCoordHandle;  
  37.   
  38.     private short drawOrder[] = { 0, 1, 2, 0, 2, 3 }; // order to draw vertices  
  39.   
  40.     // number of coordinates per vertex in this array  
  41.     private static final int COORDS_PER_VERTEX = 2;  
  42.   
  43.     private final int vertexStride = COORDS_PER_VERTEX * 4; // 4 bytes per vertex  
  44.   
  45.     static float squareCoords[] = {  
  46.        -1.0f,  1.0f,  
  47.        -1.0f, -1.0f,  
  48.         1.0f, -1.0f,  
  49.         1.0f,  1.0f,  
  50.     };  
  51.   
  52.     static float textureVertices[] = {  
  53.         0.0f, 1.0f,  
  54.         1.0f, 1.0f,  
  55.         1.0f, 0.0f,  
  56.         0.0f, 0.0f,  
  57.     };  
  58.   
  59.     private int texture;  
  60.   
  61.     public DirectDrawer(int texture)  
  62.     {  
  63.         this.texture = texture;  
  64.         // initialize vertex byte buffer for shape coordinates  
  65.         ByteBuffer bb = ByteBuffer.allocateDirect(squareCoords.length * 4);  
  66.         bb.order(ByteOrder.nativeOrder());  
  67.         vertexBuffer = bb.asFloatBuffer();  
  68.         vertexBuffer.put(squareCoords);  
  69.         vertexBuffer.position(0);  
  70.   
  71.         // initialize byte buffer for the draw list  
  72.         ByteBuffer dlb = ByteBuffer.allocateDirect(drawOrder.length * 2);  
  73.         dlb.order(ByteOrder.nativeOrder());  
  74.         drawListBuffer = dlb.asShortBuffer();  
  75.         drawListBuffer.put(drawOrder);  
  76.         drawListBuffer.position(0);  
  77.   
  78.         ByteBuffer bb2 = ByteBuffer.allocateDirect(textureVertices.length * 4);  
  79.         bb2.order(ByteOrder.nativeOrder());  
  80.         textureVerticesBuffer = bb2.asFloatBuffer();  
  81.         textureVerticesBuffer.put(textureVertices);  
  82.         textureVerticesBuffer.position(0);  
  83.   
  84.         int vertexShader    = loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);  
  85.         int fragmentShader  = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode);  
  86.   
  87.         mProgram = GLES20.glCreateProgram();             // create empty OpenGL ES Program  
  88.         GLES20.glAttachShader(mProgram, vertexShader);   // add the vertex shader to program  
  89.         GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment shader to program  
  90.         GLES20.glLinkProgram(mProgram);                  // creates OpenGL ES program executables  
  91.     }  
  92.   
  93.     public void draw(float[] mtx)  
  94.     {  
  95.         GLES20.glUseProgram(mProgram);  
  96.   
  97.         GLES20.glActiveTexture(GLES20.GL_TEXTURE0);  
  98.         GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, texture);  
  99.   
  100.         // get handle to vertex shader‘s vPosition member  
  101.         mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");  
  102.   
  103.         // Enable a handle to the triangle vertices  
  104.         GLES20.glEnableVertexAttribArray(mPositionHandle);  
  105.   
  106.         // Prepare the <insert shape here> coordinate data  
  107.         GLES20.glVertexAttribPointer(mPositionHandle, COORDS_PER_VERTEX, GLES20.GL_FLOAT, false, vertexStride, vertexBuffer);  
  108.   
  109.         mTextureCoordHandle = GLES20.glGetAttribLocation(mProgram, "inputTextureCoordinate");  
  110.         GLES20.glEnableVertexAttribArray(mTextureCoordHandle);  
  111.           
  112. //        textureVerticesBuffer.clear();  
  113. //        textureVerticesBuffer.put( transformTextureCoordinates( textureVertices, mtx ));  
  114. //        textureVerticesBuffer.position(0);  
  115.         GLES20.glVertexAttribPointer(mTextureCoordHandle, COORDS_PER_VERTEX, GLES20.GL_FLOAT, false, vertexStride, textureVerticesBuffer);  
  116.   
  117.         GLES20.glDrawElements(GLES20.GL_TRIANGLES, drawOrder.length, GLES20.GL_UNSIGNED_SHORT, drawListBuffer);  
  118.   
  119.         // Disable vertex array  
  120.         GLES20.glDisableVertexAttribArray(mPositionHandle);  
  121.         GLES20.glDisableVertexAttribArray(mTextureCoordHandle);  
  122.     }  
  123.       
  124.     private  int loadShader(int type, String shaderCode){  
  125.   
  126.         // create a vertex shader type (GLES20.GL_VERTEX_SHADER)  
  127.         // or a fragment shader type (GLES20.GL_FRAGMENT_SHADER)  
  128.         int shader = GLES20.glCreateShader(type);  
  129.   
  130.         // add the source code to the shader and compile it  
  131.         GLES20.glShaderSource(shader, shaderCode);  
  132.         GLES20.glCompileShader(shader);  
  133.   
  134.         return shader;  
  135.     }  
  136.     private float[] transformTextureCoordinates( float[] coords, float[] matrix)  
  137.     {            
  138.        float[] result = new float[ coords.length ];          
  139.        float[] vt = new float[4];        
  140.   
  141.        for ( int i = 0 ; i < coords.length ; i += 2 ) {  
  142.            float[] v = { coords[i], coords[i+1], 0 , 1  };  
  143.            Matrix.multiplyMV(vt, 0, matrix, 0, v, 0);  
  144.            result[i] = vt[0];  
  145.            result[i+1] = vt[1];  
  146.        }  
  147.        return result;  
  148.     }  
  149. }  
  150. </span>  


三、有了上面两个类就完成95%的工作,可以将GLSurfaceView看成是有生命周期的。在onPause里进行关闭Camera,在Activity里复写两个方法:

 

 

[java] view plain copy
 
 print?技术分享技术分享
  1. <span style="font-family:Comic Sans MS;font-size:18px;">    @Override  
  2.     protected void onResume() {  
  3.         // TODO Auto-generated method stub  
  4.         super.onResume();  
  5.         glSurfaceView.bringToFront();  
  6.     }  
  7.   
  8.     @Override  
  9.     protected void onPause() {  
  10.         // TODO Auto-generated method stub  
  11.         super.onPause();  
  12.         glSurfaceView.onPause();  
  13.     }</span>  

这个glSurfaceView.bringToFront();其实不写也中。在布局里写入自定义的GLSurfaceView就ok了:

 

 

[html] view plain copy
 
 print?技术分享技术分享
  1. <span style="font-family:Comic Sans MS;font-size:18px;">    <FrameLayout  
  2.         android:layout_width="wrap_content"  
  3.         android:layout_height="wrap_content" >  
  4.         <org.yanzi.camera.preview.CameraGLSurfaceView  
  5.             android:id="@+id/camera_textureview"  
  6.             android:layout_width="0dip"  
  7.             android:layout_height="0dip" />  
  8.     </FrameLayout></span>  

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

 

以上是关于Media Module之Camera(四) 拍照 底层分析的主要内容,如果未能解决你的问题,请参考以下文章

Android Camera2 拍照——对焦模式

linux之media video分析

React Native开发之expo中camera的基本使用

玩转Android Camera开发:国内首发---使用GLSurfaceView预览Camera 基础拍照demo

自定义Camera之简单介绍

转玩转Android Camera开发:国内首发---使用GLSurfaceView预览Camera 基础拍照demo