Android Camera系列（三）：GLSurfaceView+Camera

已于 2024-09-03 17:44:53 修改
阅读量986 收藏 30
点赞数 8
分类专栏： Android Camera 文章标签： android Camera GLSurfaceView
于 2024-09-03 17:44:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaozhiwz/article/details/141860162
版权

人类的悲欢并不相通—鲁迅

本系列主要讲述Android开发中Camera的相关操作、预览方式、视频录制等，项目结构代码耦合性低，旨在帮助大家能从中有所收获（方便copy :） ），对于个人来说也是一个总结的好机会

Alt

本章我们来讲解GLSurfaceView进行Camera预览，基于第一篇Android Camera系列（一）：SurfaceView+Camera的成果，我们已经对Camera进行了封装，CameraManager拿来直接使用就好

一.GLSurfaceView使用

GLSurfaceView实际上就是继承了SurfaceView，并在其内部封装了EGL环境管理和渲染线程，使得我们可以直接使用opengl的API接口对图像进行变换等操作，如：黑白滤镜、美颜等各种复杂的滤镜效果

  1. 自定义CameraGLSurfaceView继承GLSurfaceView
  2. 实现SurfaceTexture.OnFrameAvailableListener接口，并在onFrameAvailable回调中请求每一帧数据进行渲染，也就是说Camera的预览需要我们自己绘制完成
  3. GLSurfaceView提供了绘制接口Renderer,我们需要定义CameraSurfaceRenderer实现该接口，并在GLSurfaceView初始化时设置自定义的渲染类。在onSurfaceCreated回调中创建外部纹理SurfaceTexture，并设置OnFrameAvailableListener监听Camera数据回调
  4. 实现自定义CameraCallback接口，监听Camera状态
  5. 一定要实现onResume和onPause接口，并在对应的Activity生命周期中调用。这是所有使用Camera的bug的源头
public class CameraGLSurfaceView extends GLSurfaceView implements SurfaceTexture.OnFrameAvailableListener, CameraCallback {

    private static final String TAG = CameraGLSurfaceView.class.getSimpleName();

    private Context mContext;
    private SurfaceTexture mSurfaceTexture;
    private CameraHandler mCameraHandler;
    private boolean hasSurface; // 是否存在摄像头显示层
    private CameraManager mCameraManager;
    private int mRatioWidth = 0;
    private int mRatioHeight = 0;
    private int mGLSurfaceWidth;
    private int mGLSurfaceHeight;
    private CameraSurfaceRenderer mRenderer;

    public CameraGLSurfaceView(Context context) {
        super(context);
        init(context);
    }

    public CameraGLSurfaceView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context);
    }

    private void init(Context context) {
        mContext = context;
        mCameraHandler = new CameraHandler(this);

        mCameraManager = new CameraManager(context);
        mCameraManager.setCameraCallback(this);

        setEGLContextClientVersion(2);
        mRenderer = new CameraSurfaceRenderer(mCameraHandler);
        setRenderer(mRenderer);
        setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
    }

    public SurfaceTexture getSurfaceTexture() {
        return mSurfaceTexture;
    }

    private void setAspectRatio(int width, int height) {
        if (width < 0 || height < 0) {
            throw new IllegalArgumentException("Size cannot be negative.");
        }
        mRatioWidth = width;
        mRatioHeight = height;
        requestLayout();
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        int width = MeasureSpec.getSize(widthMeasureSpec);
        int height = MeasureSpec.getSize(heightMeasureSpec);
        if (0 == mRatioWidth || 0 == mRatioHeight) {
            setMeasuredDimension(width, height);
        } else {
            if (width < height * mRatioWidth / mRatioHeight) {
                setMeasuredDimension(width, width * mRatioHeight / mRatioWidth);
            } else {
                setMeasuredDimension(height * mRatioWidth / mRatioHeight, height);
            }
        }
    }

    @Override
    public void onFrameAvailable(SurfaceTexture surfaceTexture) {
        requestRender();
    }

    /**
     * Connects the SurfaceTexture to the Camera preview output, and starts the preview.
     */
    private void handleSetSurfaceTexture(SurfaceTexture st) {
        Logs.i(TAG, "handleSetSurfaceTexture.");
        mSurfaceTexture = st;
        hasSurface = true;
        mSurfaceTexture.setOnFrameAvailableListener(this);
        openCamera();
    }

    /**
     *
     * @param width
     * @param height
     */
    private void handleSurfaceChanged(int width, int height) {
        Logs.i(TAG, "handleSurfaceChanged.");
        mGLSurfaceWidth = width;
        mGLSurfaceHeight = height;
        setAspectRatio();
    }

    /**
     * 打开摄像头并预览
     */
    public void onResume() {
        super.onResume();
        if (hasSurface) {
            // 当activity暂停，但是并未停止的时候，surface仍然存在，所以 surfaceCreated()
            // 并不会调用，需要在此处初始化摄像头
            openCamera();
        }
    }

    /**
     * 停止预览并关闭摄像头
     */
    public void onPause() {
        super.onPause();
        closeCamera();
    }

    public void onDestroy() {
        mCameraHandler.invalidateHandler();
    }

    /**
     * 打开摄像头
     */
    private void openCamera() {
        if (mSurfaceTexture == null) {
            Logs.e(TAG, "mSurfaceTexture is null.");
            return;
        }
        if (mCameraManager.isOpen()) {
            Logs.w(TAG, "Camera is opened！");
            return;
        }
        mCameraManager.openCamera();
        if (mCameraManager.isOpen()) {
            mCameraManager.startPreview(mSurfaceTexture);
        }
    }

    private void closeCamera() {
        mCameraManager.releaseCamera();
        queueEvent(() -> mRenderer.notifyPausing());
        mSurfaceTexture = null;
    }

    @Override
    public void onOpen() {

    }

    @Override
    public void onOpenError(int error, String msg) {

    }

    @Override
    public void onPreview(int previewWidth, int previewHeight) {
        Logs.i(TAG, "onPreview " + previewWidth + " " + previewHeight);
        queueEvent(() -> mRenderer.setCameraPreviewSize(previewWidth, previewHeight));
        setAspectRatio();
    }

    @Override
    public void onPreviewError(int error, String msg) {

    }

    @Override
    public void onClose() {

    }

    private void setAspectRatio() {
        int previewWidth = mCameraManager.getPreviewWidth();
        int previewHeight = mCameraManager.getPreviewHeight();
        if (mGLSurfaceWidth > mGLSurfaceHeight) {
            setAspectRatio(previewWidth, previewHeight);
        } else {
            setAspectRatio(previewHeight, previewWidth);
        }
    }

    /**
     * Handles camera operation requests from other threads.  Necessary because the Camera
     * must only be accessed from one thread.
     * <p>
     * The object is created on the UI thread, and all handlers run there.  Messages are
     * sent from other threads, using sendMessage().
     */
    static class CameraHandler extends Handler {
        public static final int MSG_SET_SURFACE_TEXTURE = 0;

        public static final int MSG_SURFACE_CHANGED = 1;

        private WeakReference<CameraGLSurfaceView> mWeakGLSurfaceView;

        public CameraHandler(CameraGLSurfaceView view) {
            mWeakGLSurfaceView = new WeakReference<>(view);
        }

        /**
         * Drop the reference to the activity.  Useful as a paranoid measure to ensure that
         * attempts to access a stale Activity through a handler are caught.
         */
        public void invalidateHandler() {
            mWeakGLSurfaceView.clear();
        }

        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            int what = msg.what;

            CameraGLSurfaceView view = mWeakGLSurfaceView.get();
            if (view == null) {
                return;
            }

            switch (what) {
                case MSG_SET_SURFACE_TEXTURE:
                    view.handleSetSurfaceTexture((SurfaceTexture) msg.obj);
                    break;
                case MSG_SURFACE_CHANGED:
                    view.handleSurfaceChanged(msg.arg1, msg.arg2);
                    break;
                default:
                    throw new RuntimeException("unknown msg " + what);
            }
        }
    }

    /**
     * Renderer object for our GLSurfaceView.
     * <p>
     * Do not call any methods here directly from another thread -- use the
     * GLSurfaceView#queueEvent() call.
     */
    static class CameraSurfaceRenderer implements GLSurfaceView.Renderer {

        private CameraGLSurfaceView.CameraHandler mCameraHandler;

        private final float[] mSTMatrix = new float[16];
        private FullFrameRect mFullScreen;
        // width/height of the incoming camera preview frames
        private boolean mIncomingSizeUpdated;
        private int mIncomingWidth;
        private int mIncomingHeight;
        private int mTextureId = -1;
        private SurfaceTexture mSurfaceTexture;

        public CameraSurfaceRenderer(CameraGLSurfaceView.CameraHandler cameraHandler) {
            mCameraHandler = cameraHandler;

            mTextureId = -1;

            mIncomingSizeUpdated = false;
            mIncomingWidth = mIncomingHeight = -1;
        }

        /**
         * Notifies the renderer thread that the activity is pausing.
         * <p>
         * For best results, call this *after* disabling Camera preview.
         */
        public void notifyPausing() {
            if (mSurfaceTexture != null) {
                Logs.d(TAG, "renderer pausing -- releasing SurfaceTexture");
                mSurfaceTexture.release();
                mSurfaceTexture = null;
            }
            if (mFullScreen != null) {
                mFullScreen.release(false);     // assume the GLSurfaceView EGL context is about
                mFullScreen = null;             //  to be destroyed
            }
            mIncomingWidth = mIncomingHeight = -1;
        }

        @Override
        public void onSurfaceCreated(GL10 gl, EGLConfig config) {
            Logs.i(TAG, "onSurfaceCreated. " + Thread.currentThread().getName());
            // Set up the texture blitter that will be used for on-screen display.  This
            // is *not* applied to the recording, because that uses a separate shader.
            mFullScreen = new FullFrameRect(
                    new Texture2dProgram(Texture2dProgram.ProgramType.TEXTURE_EXT));

            mTextureId = mFullScreen.createTextureObject();

            // Create a SurfaceTexture, with an external texture, in this EGL context.  We don't
            // have a Looper in this thread -- GLSurfaceView doesn't create one -- so the frame
            // available messages will arrive on the main thread.
            mSurfaceTexture = new SurfaceTexture(mTextureId);

            mCameraHandler.sendMessage(mCameraHandler.obtainMessage(CameraHandler.MSG_SET_SURFACE_TEXTURE, mSurfaceTexture));
        }

        @Override
        public void onSurfaceChanged(GL10 gl, int width, int height) {
            gl.glViewport(0, 0, width, height);
            mCameraHandler.sendMessage(mCameraHandler.obtainMessage(CameraHandler.MSG_SURFACE_CHANGED, width, height));
        }

        @Override
        public void onDrawFrame(GL10 gl) {
            if (mSurfaceTexture == null) return;

            mSurfaceTexture.updateTexImage();

            if (mIncomingWidth <= 0 || mIncomingHeight <= 0) {
                return;
            }
            if (mIncomingSizeUpdated) {
                mFullScreen.getProgram().setTexSize(mIncomingWidth, mIncomingHeight);
                mIncomingSizeUpdated = false;
            }

            mSurfaceTexture.getTransformMatrix(mSTMatrix);
            mFullScreen.drawFrame(mTextureId, mSTMatrix);
        }

        public void setCameraPreviewSize(int width, int height) {
            mIncomingWidth = width;
            mIncomingHeight = height;
            mIncomingSizeUpdated = true;
        }
    }
}

1.Camera操作时机

与SurfaceView和TextureView不同，GLSurfaceView中并没有地方获取SurfaceTexture的地方，虽然Renderer接口有onSurfaceCreated回调但是并没有SurfaceTexture，而是要求我们自己创建外部纹理ID用于Camera预览数据的回调。至于这个外部纹理如何又显示到GLSurfaceView上的，这个章节就不先介绍了，后续我们进行完整的opengl环境搭建再进一步讨论。

Renderer中的所有回调接口都是运行在独立的线程中的，这也就是为什么我们要单独定义个类，而不是让CameraGLSurfaceView直接实现该接口，让他和别的接口方法隔离

GLSurfaceView中setRenderer接口源码可以看到会启动一个GLThread线程，Renderer接口都是运行在该线程中

    public void setRenderer(Renderer renderer) {
        ...
        mRenderer = renderer;
        mGLThread = new GLThread(mThisWeakRef);
        mGLThread.start();
    }

因此我们要把创建好的外部纹理通过Handler传递给UI线程，UI线程在获取到SurfaceTexture后打开摄像头，记得在onResume中也同样打开一次摄像头

        @Override
        public void onSurfaceCreated(GL10 gl, EGLConfig config) {
            mFullScreen = new FullFrameRect(
                    new Texture2dProgram(Texture2dProgram.ProgramType.TEXTURE_EXT));
            // 创建外部纹理ID
            mTextureId = mFullScreen.createTextureObject();
            // 在此EGL上下文中创建具有外部纹理的SurfaceTexture
            mSurfaceTexture = new SurfaceTexture(mTextureId);
            // 将SurfaceTexture传递给UI线程
            mCameraHandler.sendMessage(mCameraHandler.obtainMessage(CameraHandler.MSG_SET_SURFACE_TEXTURE, mSurfaceTexture));
        }

我们重写surfaceDestroyed，在该回调和onPause中关闭摄像头

注意surfaceDestroyed是SurfaceHolder.Callback的方法，该方法是运行在UI线程中的

2. GLSurfaceView计算大小

  1. 和SurfaceView和TextureView一样，我们在onPreview回调中设置TextureView的大小和比例
  2. 在onSurfaceChanged回调中设置GL画布大小，偶发预览变形大多是没有在此调用glViewport方法导致
        @Override
        public void onSurfaceChanged(GL10 gl, int width, int height) {
            gl.glViewport(0, 0, width, height);
            mCameraHandler.sendMessage(mCameraHandler.obtainMessage(CameraHandler.MSG_SURFACE_CHANGED, width, height));
        }

二.最后

本文介绍了Camera+GLSurfaceView的基本操作及关键代码。本章内容也不是很多，介绍了如何用GLSurfaceView预览Camera数据的流程。我们没有对opengl的API进行过多的讲解，以及Renderer接口是如何将数据渲染到GLSurfaceView中的。在后续的章节我会讲解opengl在Android中的使用，希望聪明的你在回看该章会有种醍醐灌顶的感觉吧。

lib-camera库包结构如下：

包说明
cameracamera相关操作功能包，包括Camera和Camera2。以及各种预览视图
encoderMediaCdoec录制视频相关，包括对ByteBuffer和Surface的录制
glesopengles操作相关
permission权限相关
util工具类

每个包都可独立使用做到最低的耦合，方便白嫖

github地址：https://github.com/xiaozhi003/AndroidCamera，https://gitee.com/xiaozhi003/android-camera

参考：

  1. https://github.com/afei-cn/CameraDemo
  2. https://github.com/saki4510t/UVCCamera
  3. https://github.com/google/grafika
如果可以003
关注
  • 8
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenGLES：GLSurfaceView实现Android Camera预览
肖云鹤的博客
05-23 3145
本篇博文主题：使用OpenGLES和GLSurfaceView实现在Android相机预览
自定义Camera系列之：GLSurfaceView + Camera2
阿飞的博客
02-14 5734
一、前言 假如你要使用 OpenGL ES 来渲染相机的话，使用 GLSurfaceView 将是一个很常用的选择。 这里介绍 GLSurfaceView + Camera2 的组合。 如果你对 Camera2 的相关类和接口还不熟悉，可以先看看下面这些介绍： CameraManager详解 CameraDevice详解 CameraCharacteristics详解 CameraCapture...
Android摄像头数据采集实时处理渲染实验
cpongo5
11-02 686
因为有的图片处理在glsl里面不好搞，需要opencv这种一些比较优秀的处理库，所以有了这一次的实验。 实验目的：为了寻找一种比较好的不在glsl里面实时处理摄像头数据的方式。 数据采集 camera通过SurfaceTexture采集数据 处理渲染 1.将NV21数据(yuv420sp)通过opencv转为bitmap，通过Cavas绘制，30fps左右...
android环境下摄像头数据采集及显示
grafx的专栏
05-01 4590
以前项目涉及些摄像头预览及数据处理操作，当时的需求是除了做摄像头预览外，还要显示文字、个性图像等，当初在查找资料实现相关模块时，发现很多资料讲的比较繁琐，不够简洁，这里将自己的实现方式分享出来，希望能够为正在做相关工作的同学提供些思路。不过这里先顺便提一下，如果单纯的做摄像头预览，不在预览数据时做添加文字、图像等额外操作，可以用surfaceview方式，性能上会更好些。
【Android】使用GLSurfaceView+Canera预览+保存帧Bitmap
01-19
在Android平台上，开发一款涉及到摄像头预览和图像处理的应用时，`GLSurfaceView`和`Camera`的结合使用是常见的技术方案。`GLSurfaceView`是Android提供的一个用于渲染OpenGL ES图形的视图组件，而`Camera`则负责...
自定义原生相机+拍照+GLSurfaceView+Camera
qq_45542899的博客
04-13 297
自定义相机著有通过 GLSurfaceView视图和Camera相机进行实现 。由于GLSurfaceView进行视图的渲染 Camera进行拍照即回调处理 首先添加需要的权限 否则会报打不开相机服务的异常 需要添加动态权限的自己加一下 首先自定义相机view public class CameraPreview extends GLSurfaceView implements GLSurfaceView.Renderer, SurfaceTexture.OnFrameAvailableListene
OpenGLCamera2:Android OpenGL Camera 2.0 实现 30 种滤镜和抖音特效
05-02
Android OpenGL Camera 2.0 项目使用 OpenGL ES 3.0 实现 30 种相机滤镜和特效，支持相机预览和拍照，左右滑动切换滤镜。 对 OpenGL ES 3.0 不熟悉的同学可以移步 音视频录制可以参考项目，该项目基于 FFmpeg 和 ...
Android OpenGLES + Camera1 相机预览，android插件化
m0_64382743的博客
12-05 447
有三个方法，需要我们实现 onSurfaceCreated(GL10 gl, EGLConfig config) 此处进行一些初始化工作，比如加载着色器、加载纹理、初始化顶点和纹理坐标等 onSurfaceChanged(GL10 gl, int width, int height) 此处进行窗口大小的设置 onDrawFrame(GL10 gl) 此处进行一些渲染工作，比如绑定纹理、传入顶点和纹理坐标、矩阵等 这里只做个简单的介绍，笔者是默认您会OpenGLES基本渲染步骤，如果还不太了解，相
glsurfaceview +camera2 Api
05-26
不过，我猜测你可能想问如何在 Android 应用中使用 GLSurfaceView 和 Camera2 API 进行图像渲染和处理。如果是这样，以下是一些简单的步骤： 1. 在你的 Android 项目中添加 GLSurfaceView 控件，并在应用程序中初始...
高德地图SDK Android版开发 10 InfoWindow
程序喵D的博客
09-06 1684
前文介绍高德地图添加Marker覆盖物的使用方法，Marker结合InfoWindow可展示更详尽的信息。本文将介绍以下内容：1. 使用SDK默认样式显示InfoWindow的方法；2. 自定义InfoWindow样式的方法。
攻防世界 Web_php_unserialize
最新发布
beiweixiaotian66的博客
09-07 313
因为GET传参还要经过一个Base64的解码，所以对这个表达式还要经过base64的加密。因为前面还有个正则表达式，所以我们还需要绕过这个正则表达式，使用。然后我们知道怎么绕过了，可不可以直接自己手动绕过，base加密捏。如果表示对象属性个数的值大于真实的属性个数时，就可以绕过。代表着后面的变量名长度应是10，但好像只有八位？表示空字符，但是还是占用一个字符位置。但是这样的base和上面不一样。，这样base出来就是一样的了。方法，写一个反序列化的脚本。这道题我们需要的文件是。,所以我们主要需要绕过。
安卓model转鸿蒙ets
琼小资的专栏
09-03 372
现在的android studio提供了java自动转kotlin的实现，非常方便。那android的java和kotlin有没有可能转成鸿蒙artts呢。先从最简单的model转换开始，把kotlin的model转成ets。本质上都是字符串文件，讲道理应该是可行的。
RK3566/RK3568 Android 11 动态禁止/启用APP
qq_23921815的博客
09-04 321
RK3566/RK3568 Android 11 定制大全在系统服务中增加动态禁止/启用应用。
不小心删除了 Android 手机上的短信？3 步流程恢复误删除的短信以及图片、视频、联系人
Geeker55的博客
09-03 1685
不小心删除了 Android 手机上的短信？别担心，Android 版奇客数据恢复工具可以帮助您通过简单的 3 步流程恢复已删除的短信以及图片、视频、联系人等。如何在 Android 上恢复已删除的短信不小心删除了 Android 手机上的短信？Android 版奇客数据恢复只需 3 步即可帮助您恢复已删除的短信以及照片、视频、联系人等。最近，我发现很多安卓用户在互联网论坛上寻求帮助，以恢复他们已删除的短信。对于一些从未丢失过手机短信的人来说，很难想象一个人会如何删除他想保留的短信。
Unity 对接 Android 第三方广告，App 切换到后台后，再次打开时，第三方广告被销毁导致无法触发回调逻辑的问题
艾沃尼斯の飞空庭
09-03 550
该问题是由发行进行游戏测试时遇到并反馈的。虽然接第三方广告也接了很长一段时间了，但这个问题头一次遇到，因为不是专业 Android 开发人员，所以也一脸懵逼。
【Sceneform-EQR】通过sceneform-eqr实现一个视频播放器（使用安卓MediaPlayer实现视频播放）
一个AR程序猿的博客
09-07 877
在前一篇文档中介绍了如何在AR\三维场景创建几种背景，本文将侧重介绍如何使用安卓MediaPlayer实现视频播放。
Android11 MTK 安装apk时进行密码验证
韩家老大的博客
09-04 424
Android11 MTK apk安装
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值