SurfaceTexture与camera preview绑定

已于 2024-09-11 14:42:35 修改
阅读量1k 收藏 23
点赞数 30
文章标签： 图像处理 算法 android
于 2024-09-11 14:37:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LiggerBill/article/details/142136556
版权

1. 核心概念

SurfaceTexture 是 Android 中的一个类，它允许你从某些图像源（例如相机预览）捕获帧，并将这些帧作为纹理（Texture）渲染到 OpenGL ES 环境中。它通常用于需要在自定义渲染管道中显示摄像头预览的场景。

  • 纹理（Texture）：SurfaceTexture 将图像帧作为 OpenGL ES 纹理，方便与 OpenGL 进行高效的图像处理。
  • 帧缓冲区（Frame Buffer）：SurfaceTexture 内部维护着一个帧缓冲区，从源（如相机）接收帧。
  • OpenGL 与 SurfaceTexture 结合：通常，SurfaceTexture 会与 OpenGL 一起使用，以便更高效地渲染和处理图像帧。

2. 主要功能

  • 用于相机预览：常用于相机 API 中的自定义预览（比如将相机帧直接传输到 OpenGL 纹理中）。
  • 低延迟处理：与 OpenGL 结合时，它能够实现低延迟的图像流处理。
  • 同步处理：提供了对帧同步的支持，通过 updateTexImage() 同步纹理。

3. 关键方法

1. 构造方法
  • SurfaceTexture(int texName)：创建一个 SurfaceTexture，并将其与指定的 OpenGL ES 纹理 ID 绑定（texName 是纹理的句柄）。
2. 绑定 SurfaceTexture 与 Surface
  • Surface getSurface()：获取与此 SurfaceTexture 关联的 Surface 对象，可以将其传递给相机或视频解码器等，用于图像捕获。
  • setDefaultBufferSize(int width, int height)：设置 SurfaceTexture 的默认缓冲区大小，这通常是预览帧的大小。
3. 处理图像帧
  • updateTexImage()：从缓冲区中更新当前的纹理图像。这个方法通常在每一帧图像到来时调用，确保纹理内容被更新。
  • getTimestamp()：获取当前纹理图像的时间戳，通常用于同步图像帧和其他信号。
  • release()：释放 SurfaceTexture 占用的资源，通常在 SurfaceTexture 不再需要时调用。
4. 监听帧更新
  • setOnFrameAvailableListener(SurfaceTexture.OnFrameAvailableListener listener)：设置帧可用时的监听器。当新的图像帧可用时，系统会调用此监听器。
surfaceTexture.setOnFrameAvailableListener(new SurfaceTexture.OnFrameAvailableListener() {
    @Override
    public void onFrameAvailable(SurfaceTexture surfaceTexture) {
        // 在新的图像帧到达时回调
    }
});

4. 使用流程

1. 创建 SurfaceTexture 对象

首先，通过创建 SurfaceTexture 并传递一个 OpenGL 纹理 ID 来初始化它。

int[] texture = new int[1];
GLES20.glGenTextures(1, texture, 0); // 创建一个 OpenGL 纹理
SurfaceTexture surfaceTexture = new SurfaceTexture(texture[0]); // 绑定这个纹理
2. 设置默认缓冲区大小

接下来，通常会设置 SurfaceTexture 的默认缓冲区大小，通常是相机预览的分辨率大小。

surfaceTexture.setDefaultBufferSize(1920, 1080); // 设置为 1920x1080 的分辨率
3. 获取 Surface 对象

你可以通过 SurfaceTexture.getSurface() 获取 Surface 对象，并将其传递给相机进行图像流的捕获。

Surface surface = new Surface(surfaceTexture);
camera.setPreviewSurface(surface); // 将 Surface 传递给相机
4. 同步纹理图像

在每一帧到达时，你需要调用 updateTexImage() 来同步纹理，并将其更新到 OpenGL 的纹理缓冲区中。

surfaceTexture.updateTexImage(); // 更新纹理图像
5. 释放资源

在不需要 SurfaceTexture 时，调用 release() 方法来释放它占用的资源。

surfaceTexture.release(); // 释放资源

5. 完整的示例代码

下面是一个完整的示例，展示如何使用 SurfaceTexture 来处理相机预览，并将其作为 OpenGL 纹理渲染。

public class MyGLRenderer implements GLSurfaceView.Renderer {

    private SurfaceTexture surfaceTexture;
    private int[] textures;

    @Override
    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
        // 创建 OpenGL 纹理
        textures = new int[1];
        GLES20.glGenTextures(1, textures, 0);
        
        // 创建 SurfaceTexture 并绑定到 OpenGL 纹理
        surfaceTexture = new SurfaceTexture(textures[0]);
        
        // 设置帧可用监听器
        surfaceTexture.setOnFrameAvailableListener(new SurfaceTexture.OnFrameAvailableListener() {
            @Override
            public void onFrameAvailable(SurfaceTexture surfaceTexture) {
                // 当新的帧可用时处理
            }
        });

        // 设置默认缓冲区大小
        surfaceTexture.setDefaultBufferSize(1920, 1080);
    }

    @Override
    public void onDrawFrame(GL10 gl) {
        // 更新纹理内容
        surfaceTexture.updateTexImage();
        
        // 继续绘制
        // GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textures[0]);
        // 渲染代码
    }

    @Override
    public void onSurfaceChanged(GL10 gl, int width, int height) {
        GLES20.glViewport(0, 0, width, height);
    }
}

6. 典型应用场景

  • 相机预览：可以将相机预览直接显示到 GLSurfaceView 上。
  • 视频解码：可以用 SurfaceTexture 来渲染解码后的视频帧到自定义 OpenGL 表面。
  • 图像处理：通过将图像帧渲染到 OpenGL 中，进行高效的图像处理和特效渲染。

总结

SurfaceTexture 提供了从视频源（如相机）到 OpenGL 纹理的高效转换，使得图像流可以被更灵活地处理和渲染。在使用 OpenGL 进行渲染时，它是处理视频流的核心工具之一。

TexturePreview与预览绑定：

    @NonNull
    private OutputConfiguration getOutputConfiguration(SurfaceTexture surfaceTexture, Size previewSize) {
        OutputConfiguration texPreviewReader = null;
        if (surfaceTexture == null) {
            texPreviewReader = new OutputConfiguration(previewSize, SurfaceTexture.class);
        } else {
            final Surface surface = new Surface(surfaceTexture);
            texPreviewReader = new OutputConfiguration(surface);
            if (mSurface != null) {
                mSurface.release();
            }
            mSurface = surface;
        }
        return texPreviewReader;
    }



public Surface configPreview(CameraCaptureSession captureSession,
                                 CaptureRequest.Builder previewRequestBuilder,
                                 List<OutputConfiguration> outputConfigs,
                                 SurfaceTexture surfaceTexture) {
        LogUtil.v(TAG, "configPreview: ");
        Surface texturePreviewSurface = null;

        try {
            if (captureSession ==null || outputConfigs == null || surfaceTexture == null) {
                return null;
            }

            boolean needFinalizeOutputConfig = false;
            for (OutputConfiguration outputConfig : outputConfigs) {
                Surface surface = outputConfig.getSurface();
                if (surface == null) {
                    texturePreviewSurface = new Surface(surfaceTexture);
                    outputConfig.addSurface(texturePreviewSurface);
                    needFinalizeOutputConfig = true;
                    break;
                }
            }

            if (needFinalizeOutputConfig) {
                captureSession.finalizeOutputConfigurations(outputConfigs);
            }
        } catch (CameraAccessException | IllegalStateException e) {
            LogUtil.e(TAG, "finalizePreviewOutputConfigs", e);
        }

        if (texturePreviewSurface != null) {
            if (mSurface != null) {
                mSurface.release();
            }
            mSurface = texturePreviewSurface;

        }
        previewRequestBuilder.addTarget(mSurface);
        return mSurface;
    }

texturePreviewSurface = new Surface(surfaceTexture);
outputConfig.addSurface(texturePreviewSurface);
mSurface = texturePreviewSurface;
previewRequestBuilder.addTarget(mSurface);

两者用通过surfaceTexture 进行绑定，相机获取到的图像直接传送到SurfaceTexture 内部维护着一个帧缓冲区。

然后在每一帧到达后需要用updateTexImage() 来同步纹理，并将其更新到 OpenGL 的纹理缓冲区中。

protected void updateSurfaceTextureImage() {
    try {
        mSurfaceTexture.updateTexImage();
    } catch (RuntimeException e) {
        LogUtil.e(TAG, "updateTexImage failed, e = ", e);
    }
}
进阶：预览图像算法处理后在显示

要是我们需要将图片处理一遍后在显示。那么就不能直接将surfaceTexture获得的surface与相机输出流进行绑定了。
不然我们就无法拿到image 来操作image，只能在这里处理纹理，不是我们想要的。（简单的滤镜可以在这里渲染）

    @Override
    public void onDrawFrame(GL10 gl) {
        // 更新纹理内容
        surfaceTexture.updateTexImage();
        
        // 继续绘制
        // GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textures[0]);
        // 渲染代码
    }

所以我们应该需要怎么操作，此时有个关键的类ImageWriter(之前的文章有过介绍，这里就不过多的解释了)中的queueInputImage方法：

public void queueInputImage(Image image) {}

mImageWriter.queueInputImage(image);

queueInputImage(image) 的作用是将一个 Image 对象传递给 ImageWriter，并将其插入到 ImageWriter 的缓冲队列中。这个方法会将 Image 添加到队列里，等待将图像写入到它关联的 Surface 上。

上面方法可以将处理后的image 添加到suerface中的帧缓存区中，那么我们在使用ImageWriter.newInstance 使之与surfaceTexture进行绑定

public static @NonNull ImageWriter newInstance(@NonNull Surface surface,
            @IntRange(from = 1) int maxImages, @Format int format);
    
mImageWriter = ImageWriter.newInstance(surfaceTexture, mYuvPreview.getMaxImage(), ImageFormat.YUV_420_888);
示例：（假设已经有了yuvpreview）
        final Surface surface = new Surface(surfaceTexture);
mImageWriter = ImageWriter.newInstance(surface, mYuvPreview.getMaxImage(), ImageFormat.YUV_420_888);

mYuvPreview.configPreview(previewRequestBuilder, new ImageReader.OnImageAvailableListener() {
            @Override
            public void onImageAvailable(ImageReader reader) {
                final Image image = reader.acquireLatestImage();
                if (image != null) {
                    if (mImageWriter != null) {
                        int orientation = mModuleReference.getSettingProxy().getDisplayOrientation();
                        if (isFrontCam()) {
                            switch (orientation % 360) {
                                case 0: orientation = 270; break;
                                case 90: orientation = 180; break;
                                case 180: orientation = 90; break;
                                case 270: orientation = 0; break;
                            }
                        } else {
                            orientation += 90;
                        }

                        int imageSize = image.getPlanes()[0].getRowStride() * image.getHeight();
                        int yuvSize = imageSize * 3 / 2;
                        BeautyShotUtil.ProcessPreview(image.getPlanes()[0].getBuffer(),
                                image.getPlanes()[1].getBuffer(), image.getPlanes()[2].getBuffer(),
                                null, false, image.getWidth(), image.getHeight(),
                                image.getPlanes()[0].getRowStride(), image.getPlanes()[1].getRowStride(),
                                image.getPlanes()[1].getPixelStride(), orientation);
                        mImageWriter.queueInputImage(image);
                    } else {
                        image.close();
                    }
                }
            }
        }, mPreviewHandler);
Min_小明
关注
Android Camera开发实践(4) SurfaceTexture与特效
2401_84149557的博客
04-09 715
分享一份工作1到5年以上的Android程序员架构进阶学习路线体系，希望能对那些还在从事Android开发却还不知道如何去提升自己的，还处于迷茫的朋友！阿里P7级Android架构师技术脑图；查漏补缺，体系化深入学习提升**全套体系化高级架构视频；**七大主流技术模块，视频+源码+笔记有任何问题，欢迎广大网友一起来交流《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！有任何问题，欢迎广大网友一起来交流。
使用SurfaceTexture作为Camera输出「第一章，Android音视频编码那点破事」
weixin_42277689的博客
05-22 2513
第一章，使用SurfaceTexture作为Camera输出   在Android系统中，使用GPU对摄像头画面进行高效可控的渲染，几乎是必须的。说到GPU就不得不提OpenGL，一组GPU暴露给应用层使用的接口。 Tip：OpenGL是一组基于状态的系统，在这里没有对象，只有一系列的状态。包括申请的Texture、FBO和PBO都是以状态的形式存在的。当我们向系统申请一个Texture，系统...
surfacetexture与camera结合基本流程
09-08 7075
一，构造一个view 继承自TextureView 因为camera里面接收这种数据，同时要实现TextureView.SurfaceTextureListener ，如此在有texture的时候才能及时处理 二，Camera.setPreviewTexture(surface) 设定预览的数据来源 三， public void cameraHasOpened() {  
Android Camera开发:使用TextureView和SurfaceTexture预览Camera 基础拍照demo
djh10000的博客
10-15 248
Google自Android4.0出了TextureView，为什么推出呢？就是为了弥补Surfaceview的不足，另外一方面也是为了平衡GlSurfaceView，当然这是本人揣度的。关于TextureView、Surfaceview、SurfaceTexture、GLSurfaceView的关系，待咱家推出GLSurfaceview预览Camera后再专门分析。本文主要介绍使用Te...
SurfaceView，TextureView，SurfaceTexture相关
Flying snow
09-14 1962
首先我们知道View类如果需要更新视图，必须我们主动的去调用invalidate()或者postInvalidate()方法来再走一次onDraw()完成更新。但是呢，Android系统规定屏幕的刷新间隔为16ms，如果这个View在16ms内更新完毕了，就不会卡顿，但是如果逻辑操作太多，16ms内没有更新完毕，剩下的操作就会丢到下一个16ms里去完成，这样就会造成UI线程的阻塞，造成View的运动过程掉帧，自然就会卡顿了。 所以这些原因也就促使了SurfaceView的存在。比如一个Camera，它有可能
TextureView, SurfaceTexture与Surface的关系
guanguanboy的专栏
06-18 7762
在TextureView中存在一个 private SurfaceTexture mSurface; 成员变量。 可以使用这个SurfaceTexture来构造一个Surface。然后在Surface上可以显示从camera中获取到的流。 Aandroid.view.Surfacecreated from a SurfaceTexture can be used as an outp...
Android SurfaceTexture和GLSurfaceView做Camera预览
热门推荐
huiguixian的专栏
07-04 2万+
GLSurfaceView是OpenGL中的一个类，也是可以预览Camera的，而且在预览Camera上有其独到之处。独到之处在哪？当使用Surfaceview无能为力、痛不欲生时就只有使用GLSurfaceView了，它能够真正做到让Camera的数据和显示分离，所以搞明白了这个，像Camera只开预览不显示这都是小菜，妥妥的。Android4.0的自带Camera源码是用SurfaceView
SurfaceTexture源码分析
YuQing_Cat的博客
11-02 1941
概述 SurfaceTexture，是Android3.0以后引入的，它对图像流的处理并不直接显示，而是转换为GL外部纹理，因此可用于图像流数据的二次处理，比如Camera滤镜、特效等。 分析源码 SurfaceTexture java.lang.Object ↳ android.graphics.SurfaceTexture public class SurfaceTexture { } ...
SurfaceView, TextureView, SurfaceTexture等的区别
maxmusy_0的专栏
06-12 5226
转自：https://www.cnblogs.com/wytiger/p/5693569.html SurfaceView, GLSurfaceView, SurfaceTexture以及TextureView是Android当中名字比较绕，关系又比较密切的几个类。本文基于Android 5.0(Lollipop)的代码理一下它们的基本原理，联系与区别。 SurfaceView 从An...
camera2 preview video
01-06
Size previewSize = map.getOutputSizes(SurfaceTexture.class)[0]; ``` 6. **录制视频**: 若要将预览流转换为视频，可以使用`MediaRecorder`。先设置源（来自`ImageReader`的Surface），编码格式，输出文件路径等...
如何用surfacetexture 相机预览
06-07
2.创建一个 SurfaceTexture 对象，并将其绑定到相机的输出 Surface 上。 ```java // 创建一个 SurfaceTexture 对象 SurfaceTexture surfaceTexture = new SurfaceTexture(0); // 将 SurfaceTexture 对象设置为相机...
2024.9.14 Python与图像处理新国大EE5731课程大作业，马尔可夫随机场和二值图割，校正立体图像的深度
RaidenMessi的博客
09-14 1019
现在通过更改lmd的值可以看到不同的效果，lmd小的时候，噪声很大，lmd大的时候，深度信息就看不清了，对比相同lambda，不同dpeth的深度图，在dmin和dmax不变的情况下，深度层数越少，深度图中的噪声越小。生成图像匹配的能量（unary）矩阵，每个像素点有多个视差候选值（基于不同的深度），该函数计算每个像素与可能的匹配点之间的差异并归一化为能量值。作用: 这个步骤通过遍历图像中的每一个像素点，计算它在不同视差下的匹配质量，输出的 unary 是图像的视差匹配成本图，后续会用于图割算法。
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
qq_61936886的博客
09-12 440
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1136
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 285
试除法求约数、约数个数、约数之和、最大公约数
深度优先算法，广度优先算法，hill climbing，贪心搜索，A*算法，启发式搜索算法是什么，比起一般搜索法算法有什么区别
mimo_mimo的博客
09-10 1164
A算法通过维护一个优先队列（通常是最小堆），并根据启发式函数（如g(n) + h(n)，其中g(n)是从起点到当前点的实际距离，h(n)是从当前点到目标点的估计距离）来评估节点的优先级。它从图的某个顶点V0开始，依次访问V0的各个未被访问过的邻接点，然后从这些邻接点出发，再依次访问它们的未被访问过的邻接点，直到图中所有已被访问过的顶点的邻接点都被访问到。它从当前的节点开始，和周围的邻居节点的值进行比较，如果当前节点不是最大的，就用最高的邻居节点来替换当前节点，从而实现向“山峰”的高处攀爬的目的。
C语言程序设计-练习篇
最新发布
2402_85207276的博客
09-14 937
·三角形的判断 ·使用指针打印数组内容 ·字符串逆序 ·计算求和 ·打印水仙花数
Codeforces Round 969 (Div. 2) C. Dora and C++ （裴蜀定理）
2302_79440616的博客
09-10 460
取模，这样就能够得到所有数的最简形式（可以当成是让所有数尽可能消去。所以在这时候我们就可以让输入的所有数都去对。那么在取模之后我们现在排序，得到的极差就是。可以想到使用同样是需要给出两个定值的。由于这里给出了a和b两个数，我们。的判断，因为不排除有这种情况存在。，那么这里我们还要进行一次。，这样我们会取到最优解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值