UVCCamera OpenGL 添加时间戳水印

已于 2023-04-17 17:14:42 修改
阅读量781 收藏 2
点赞数
分类专栏： Android之朝花夕拾 文章标签： android 音视频
于 2023-04-17 17:12:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TyearLin/article/details/130196706
版权

视频流添加水印方式较多 本文只从渲染角度修改 

修改  CameraViewInterface 预览视图 自定义 CameraSurfaceView 将相机预览数据输出到外部纹理 通过fbo 混合水印纹理及Camera纹理 最终输出到 SurfaceView 上

打开相机输出到外部纹理

mHandlerL.startPreview(mUVCCameraViewL.getSurfaceTexture());

private final OnDeviceConnectListener mOnDeviceConnectListener = new OnDeviceConnectListener() {
		@Override
		public void onAttach(final UsbDevice device) {
			if (DEBUG) Log.v(TAG, "onAttach:" + device);
			Toast.makeText(MainActivity.this, "USB_DEVICE_ATTACHED", Toast.LENGTH_SHORT).show();
		}

		@Override
		public void onConnect(final UsbDevice device, final UsbControlBlock ctrlBlock, final boolean createNew) {
			if (DEBUG) Log.v(TAG, "onConnect:" + device);
			if (!mHandlerL.isOpened()) {
				if (DEBUG) Log.v(TAG, "mHandlerL not opend:");
				mHandlerL.open(ctrlBlock);
				mHandlerL.startPreview(mUVCCameraViewL.getSurfaceTexture());
				runOnUiThread(new Runnable() {
					@Override
					public void run() {
						mCaptureButtonL.setVisibility(View.VISIBLE);
					}
				});
			} else if (!mHandlerR.isOpened()) {
				if (DEBUG) Log.v(TAG, "mHandlerR not opend:");
				mHandlerR.open(ctrlBlock);
				mHandlerR.startPreview(mUVCCameraViewR.getSurfaceTexture());
				runOnUiThread(new Runnable() {
					@Override
					public void run() {
						mCaptureButtonR.setVisibility(View.VISIBLE);
					}
				});
			}
		}

创建外部纹理 及  SurfaceTexture 

     cameraTexture = GlUtil.createRecordCameraTextureID();
        surfaceTexture = new SurfaceTexture(cameraTexture);

RenderThread 中绑定EGL上下文 绑定显示窗口缓冲区  

   private final void init() {
                if (DEBUG) Log.v(TAG, "RenderThread#init:");
                try {
                    glRenderManager.setCameraRotate(180);
                    glRenderManager = new GlRenderManager(appContext, mTexId, mDispSurface, mPreviewSurface);
                    glRenderManager.onInputSizeChanged(640, 480);
                    glRenderManager.onDisplaySizeChanged(mViewWidth, mViewHeight);


                    // notify to caller thread that previewSurface is ready
                } catch (GlUtil.OpenGlException e) {
                    e.printStackTrace();
                }
            }

 public GlRenderManager(Context context, int texture, Surface disPlaySurface, SurfaceTexture surfaceTexture) throws GlUtil.OpenGlException {
        this.context = context;
        this.texture = texture;
        this.surfaceTexture = surfaceTexture;
        mEglCore = new EglCore(null, EglCore.FLAG_TRY_GLES3);
        setDisPlaySurface(disPlaySurface);
        mDisplaySurface.makeCurrent();
        //关闭深度测试和绘制背面
        GLES20.glDisable(GL10.GL_DEPTH_TEST);
        GLES20.glDisable(GL10.GL_CULL_FACE);
        init();
    }


/**
     * Prepares EGL display and context.
     * <p>
     *
     * @param sharedContext The context to share, or null if sharing is not desired.
     * @param flags         Configuration bit flags, e.g. FLAG_RECORDABLE.
     */
    public EglCore(EGLContext sharedContext, int flags) throws GlUtil.OpenGlException {
        if (mEGLDisplay != EGL14.EGL_NO_DISPLAY) {
            throw new RuntimeException("EGL already set up");
        }

        if (sharedContext == null) {
            sharedContext = EGL14.EGL_NO_CONTEXT;
        }

        mEGLDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
        if (mEGLDisplay == EGL14.EGL_NO_DISPLAY) {
            throw new RuntimeException("unable to get EGL14 display");
        }
        int[] version = new int[2];
        if (!EGL14.eglInitialize(mEGLDisplay, version, 0, version, 1)) {
            mEGLDisplay = null;
            throw new RuntimeException("unable to initialize EGL14");
        }

        // Try to get a GLES3 context, if requested.
        if ((flags & FLAG_TRY_GLES3) != 0) {
            //Log.d(TAG, "Trying GLES 3");
            EGLConfig config = getConfig(flags, 3);
            if (config != null) {
                int[] attrib3_list = {
                        EGL14.EGL_CONTEXT_CLIENT_VERSION, 3,
                        EGL14.EGL_NONE
                };
                EGLContext context = EGL14.eglCreateContext(mEGLDisplay, config, sharedContext,
                        attrib3_list, 0);

                if (EGL14.eglGetError() == EGL14.EGL_SUCCESS) {
                    //Log.d(TAG, "Got GLES 3 config");
                    mEGLConfig = config;
                    mEGLContext = context;
                    mGlVersion = 3;
                }
            }
        }
        if (mEGLContext == EGL14.EGL_NO_CONTEXT) {  // GLES 2 only, or GLES 3 attempt failed
            //Log.d(TAG, "Trying GLES 2");
            EGLConfig config = getConfig(flags, 2);
            if (config == null) {
                throw new RuntimeException("Unable to find a suitable EGLConfig");
            }
            int[] attrib2_list = {
                    EGL14.EGL_CONTEXT_CLIENT_VERSION, 2,
                    EGL14.EGL_NONE
            };
            EGLContext context = EGL14.eglCreateContext(mEGLDisplay, config, sharedContext,
                    attrib2_list, 0);
            checkEglError("eglCreateContext");
            mEGLConfig = config;
            mEGLContext = context;
            mGlVersion = 2;
        }

        // Confirm with query.
        int[] values = new int[1];
        EGL14.eglQueryContext(mEGLDisplay, mEGLContext, EGL14.EGL_CONTEXT_CLIENT_VERSION,
                values, 0);
        Log.d(TAG, "EGLContext created, client version " + values[0]);
    }

RenderThread WHEN_DIRTY渲染

    mPreviewSurface.setOnFrameAvailableListener(new SurfaceTexture.OnFrameAvailableListener() {
                    @Override
                    public void onFrameAvailable(SurfaceTexture surfaceTexture) {
                        mHandler.post(new Runnable() {
                            @Override
                            public void run() {
                                callDrawFrame();
                            }
                        });
                    }
                });

FBO渲染   NDK OpenGL ES 3.0 开发（五）：FBO 离屏渲染_字节流动的博客-CSDN博客

1 创建FBO 关联 frameBuffferTex

    /**
     * 创建Sampler2D的Framebuffer 和 Texture
     *
     * @param frameBuffer
     * @param frameBufferTex
     * @param width
     * @param height
     */
    public static void createSampler2DFrameBuff(int[] frameBuffer, int[] frameBufferTex,
                                                int width, int height, int position) throws GlUtil.OpenGlException {
        GLES30.glGenFramebuffers(1, frameBuffer, position);
        GLES30.glGenTextures(1, frameBufferTex, position);
        GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, frameBufferTex[position]);
        GLES30.glTexImage2D(GLES30.GL_TEXTURE_2D, 0, GLES30.GL_RGBA, width, height, 0,
                GLES30.GL_RGBA, GLES30.GL_UNSIGNED_BYTE, null);
        GLES30.glTexParameterf(GLES30.GL_TEXTURE_2D,
                GLES30.GL_TEXTURE_MAG_FILTER, GLES30.GL_LINEAR);
        GLES30.glTexParameterf(GLES30.GL_TEXTURE_2D,
                GLES30.GL_TEXTURE_MIN_FILTER, GLES30.GL_LINEAR);
        GLES30.glTexParameterf(GLES30.GL_TEXTURE_2D,
                GLES30.GL_TEXTURE_WRAP_S, GLES30.GL_CLAMP_TO_EDGE);
        GLES30.glTexParameterf(GLES30.GL_TEXTURE_2D,
                GLES30.GL_TEXTURE_WRAP_T, GLES30.GL_CLAMP_TO_EDGE);
        GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, frameBuffer[position]);
        GLES30.glFramebufferTexture2D(GLES30.GL_FRAMEBUFFER, GLES30.GL_COLOR_ATTACHMENT0,
                GLES30.GL_TEXTURE_2D, frameBufferTex[position], 0);
        GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, 0);
        GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, 0);
        checkGlError("createCamFrameBuff");
    }

2 drwFrame （opengl render thread）

//.....    
 mDisplaySurface.makeCurrent();
        GLES20.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);
        //刷新
        try {
            surfaceTexture.updateTexImage();
        } catch (Exception e) {
            e.printStackTrace();
            return;
        }
    //....
        //绘制相机输出流 及滤镜等 FBO

        if (displayRenderGroup != null) {
            displayRenderGroup.setMirroring(mirroring);
            currentTexture = displayRenderGroup.drawFrame(currentTexture);
        }
        //后续操作 FBO切换到 currentTexture（可见窗口） 上处理
      //....
        //添加水印
        drawWaterSign();
          //送显
        mDisplaySurface.swapBuffers();

绑定FBO

GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, mFramebuffers[0]);

FBO处理完后切换到正常显示窗口 

GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, 0);

水印绘制

拆分动态部分 防止闪烁 这里可以进一步优化缓存 bitmap 

 //初始化文字转图片所需的对象，避免多次生成新对象消耗过多内存
        //将字符图片与纹理绑定，返回纹理id
        for (int i = 0; i < 12; i++) {
            if (i == 10) {
                mWaterTexId[i] = TextureHelper.loadTexture(BitmapUtils.textToBitmap("-"), textureObjectIds);
            } else if (i == 11) {
                mWaterTexId[i] = TextureHelper.loadTexture(BitmapUtils.textToBitmap(":"), textureObjectIds);
            } else {
                mWaterTexId[i] = TextureHelper.loadTexture(BitmapUtils.textToBitmap(i + ""), textureObjectIds);
            }
        }

动态绘制时间纹理 

private void drawWaterSign() {
        String time = formatter.format(new Date());
        int x = waterMaskStartX;
        int y = waterMaskStartY;
        if ("".equals(time)) {
            return;
        }
        GLES20.glEnable(GLES20.GL_BLEND);
        //开启GL的混合模式，即图像叠加
        GLES20.glBlendFunc(GLES20.GL_ONE, GLES20.GL_ONE_MINUS_SRC_ALPHA);
        //画水印
        GLES20.glViewport(x, y, waterMaskWidth, waterMaskHeight);//60
        mWaterSign.drawFrame(mWaterTexId[Integer.parseInt(time.substring(0, 1))]);
        GLES20.glViewport(x + 15, y, waterMaskWidth, waterMaskHeight);
        mWaterSign.drawFrame(mWaterTexId[Integer.parseInt(time.substring(1, 2))]);
        GLES20.glViewport(x + 15 * 2, y, waterMaskWidth, waterMaskHeight);
        mWaterSign.drawFrame(mWaterTexId[Integer.parseInt(time.substring(2, 3))]);
        GLES20.glViewport(x + 15 * 3, y, waterMaskWidth, waterMaskHeight);
        mWaterSign.drawFrame(mWaterTexId[Integer.parseInt(time.substring(3, 4))]);
        GLES20.glViewport(x + 15 * 4, y, waterMaskWidth, waterMaskHeight);
        mWaterSign.drawFrame(mWaterTexId[10]); // -
        GLES20.glViewport(x + 15 * 5, y, waterMaskWidth, waterMaskHeight);
        mWaterSign.drawFrame(mWaterTexId[Integer.parseInt(time.substring(5, 6))]);
        GLES20.glViewport(x + 15 * 6, y, waterMaskWidth, waterMaskHeight);
        mWaterSign.drawFrame(mWaterTexId[Integer.parseInt(time.substring(6, 7))]);
        GLES20.glViewport(x + 15 * 7, y, waterMaskWidth, waterMaskHeight);
        mWaterSign.drawFrame(mWaterTexId[10]); // -
        GLES20.glViewport(x + 15 * 8, y, waterMaskWidth, waterMaskHeight);
        mWaterSign.drawFrame(mWaterTexId[Integer.parseInt(time.substring(8, 9))]);
        GLES20.glViewport(x + 15 * 9, y, waterMaskWidth, waterMaskHeight);
        mWaterSign.drawFrame(mWaterTexId[Integer.parseInt(time.substring(9, 10))]);
        GLES20.glViewport(x + 15 * 11, y, waterMaskWidth, waterMaskHeight);
        mWaterSign.drawFrame(mWaterTexId[Integer.parseInt(time.substring(11, 12))]);
        GLES20.glViewport(x + 15 * 12, y, waterMaskWidth, waterMaskHeight);
        mWaterSign.drawFrame(mWaterTexId[Integer.parseInt(time.substring(12, 13))]);
        GLES20.glViewport(x + 15 * 13, y, waterMaskWidth, waterMaskHeight);
        mWaterSign.drawFrame(mWaterTexId[11]); // :
        GLES20.glViewport(x + 15 * 14, y, waterMaskWidth, waterMaskHeight);
        mWaterSign.drawFrame(mWaterTexId[Integer.parseInt(time.substring(14, 15))]);
        GLES20.glViewport(x + 15 * 15, y, waterMaskWidth, waterMaskHeight);
        mWaterSign.drawFrame(mWaterTexId[Integer.parseInt(time.substring(15, 16))]);
        GLES20.glViewport(x + 15 * 16, y, waterMaskWidth, waterMaskHeight);
        mWaterSign.drawFrame(mWaterTexId[11]); // :
        GLES20.glViewport(x + 15 * 17, y, waterMaskWidth, waterMaskHeight);
        mWaterSign.drawFrame(mWaterTexId[Integer.parseInt(time.substring(17, 18))]);
        GLES20.glViewport(x + 15 * 18, y, waterMaskWidth, waterMaskHeight);
        mWaterSign.drawFrame(mWaterTexId[Integer.parseInt(time.substring(18, 19))]);
        //GLES30.glDisable(GLES30.GL_BLEND);
    }

OPENGL 滤镜水印可参照GPUIMAGE库 https://link.csdn.net/?target=https%3A%2F%2Fgithub.com%2FBradLarson%2FGPUImage.git

在此基础上采集修改定制  这里也是用的他人的 渲染部分整合而来 实际项目中一般在底层 通过ffmpeg filter 实现 更加灵活 在推流端处理视频帧 

QtyearLin/UVCCamera_Water · GitHub  

江太翁
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用 CameraX 拍照并添加水印并保存到相册
Dev Blog
07-05 1079
CameraXCameraX 是一个用于简化相机开发的 Jetpack 组件，它提供了一组易于使用且一致的API，使开发者能够轻松地实现相机功能，而无需处理底层的相机硬件和 API。
AM335X——USB摄像头
hceng_linux
06-24 4385
CSDN仅用于增加百度收录权重，排版未优化，日常不维护。请访问：www.hceng.cn 查看、评论。 本博文对应地址: https://hceng.cn/2019/06/23/AM335X——USB摄像头/#more 记录使用AM335X，在LCD和Web上显示USB摄像头图像。 之前在Tiny4412上学习了UVC，并在Tiny4412的LCD上显示了USB摄像头图像。 最近需要在AM335X...
HI3518EV300配置成USB摄像头 既UVC/UAC功能
qq_32896111的博客
04-11 7677
现在用的是3518EV300，SDK版本是LINUX版本的Hi3516E V200R001C01SPC011，不过在开发过程中发现这个版本没有UVC配置的相关文档说明，UVC摄像头是有人已经做出来的，说明这个芯片应该支持UVC功能，没有文档说明就很奇怪，于是到更高版本的SDK的设备驱动开发说明文档找到了配置过程说明。 首先编译SDK中的UVC例程，按照里面的说明步骤把音频选上，交叉编译ALSA库，...
Android 实现openGL录像添加静态图片水印
feipu1988的博客
07-18 1046
Android 水印
拍照时增加时间戳到照片右下角
jimbo的专栏
03-19 3440
方法1：使用rawdata数据生成bitmap文件，增加时间戳到bitmap，把新的bitmap数据保存到jpeg文件中 方法2： 保存文件成功后  打开文件生成bitmap文件，删除源文件，增加时间戳，覆盖源文件 方法1：修改文件 packages/apps/Camera/src/com/mediatek/camera/mode/PhotoMode.java diff --git
OpenGLES：多纹理贴图，文字水印
最新发布
肖云鹤的博客
09-24 352
本篇博客讲解如何通过多纹理贴图实现图片和文本水印效果
最通俗的安卓OpenGL教学09——添加水印
york2017的博客
12-21 2967
添加水印的原理主要是利用OpenGL ES绘制多次，把不同的纹理如图片、文本等绘制到纹理或窗口上，达到添加水印的效果，需要注意的地方就是要确定好需要在屏幕上绘制的位置坐标。 添加水印的原理： 利用OpenGL ES绘制多次，把不同的纹理如图片、文本等绘制到纹理或窗口上，达到添加水印的效果。 图片水印，直接绑定bitmap到纹理； 文字水印，先将文字转为bitmap，再绑定到纹理。 先看效果： 添加水印的步骤： 首先确认水印添加的位置 设置水印的大小 根据水印图片长宽比计算水印的顶点坐标 接下.
Android使用Opengl录像时添加水印
08-19
Android 使用 Opengl 录像时添加水印 Android 使用 Opengl 录像时添加水印是指在 Android 平台上使用 Opengl 技术录制视频时添加水印的过程。水印可以是静态的，也可以是动态的。静态水印是指在录制视频时添加的...
基于ffmpeg对摄像头采集的视频加上时间戳水印
07-13
总之，这个项目展示了如何利用FFmpeg和SDL将时间戳水印添加到通过摄像头捕获的视频中，提供了一种实用的方法来增强视频的可读性和记录性。通过对FFmpeg的深入理解和实践，你可以创建更多自定义的视频处理功能，满足...
android YUV 方式添加水印
10-31
在Android平台上，添加水印是一项常见的任务，尤其是在处理视频流或者实时相机预览时。传统的Java API实现方式可能效率较低，因为它们通常涉及到大量的像素操作，这在性能上是有限制的。为了解决这个问题，我们可以...
opengl 渲染，可旋转+水印+显示文字
11-20
用opengl显示RGB数据，自己测试代码，虽杂乱但是比较简单，可以从中扣自己要的代码。
Android Camera添加水印(编码)
11-10
Android Camera添加水印，编码的时候增加水印，任何APP拍照或录像有水印
覆盖时间戳_给图像添加时间戳_
09-29
在IT行业中，图像处理是一项常见的任务，而给图像添加时间戳是其中的一个实用功能。时间戳的添加可以用于记录图像的生成时间，便于管理和追溯。本文将深入探讨如何实现这一功能，特别是在编程环境下，如LabVIEW...
ffmpeg 添加时间戳
12-24
Windows下安装 ffmpeg 添加时间戳 简单教程 图像处理
OpenGL.ES在Android上的简单实践：18-水印录制（自定义Android-EGL）
vx number：zzr_admin，拉入技术交流群。
05-18 2589
OpenGL.ES在Android上的简单实践：18-水印录制 （自定义Android-EGL）   1、确定需求 这次的项目需求总结下来是这样的：一个摄像头预览界面，一个按钮触发屏幕录制，录制视频带上水印效果。 1. 摄像头预览 2. 屏幕录制 3. 录制视频在指定位置附带上水印 确定需求后，我们逐一分析模块组成并完成它。So，Talk is cheap，Let me show co...
使用OpenGL叠加水印造成OOM的问题
雪飘碧鸳的博客
05-18 399
OOM
Linux系统中的计时机制及相关时间函数
yuyin86的专栏
08-04 1209
1. 时间相关硬件 计算机系统中的时间主要由三种时钟硬件提供的:实时时钟（Real Time Clock，RTC）,可编程间隔定时器（Programmable Interval Timer，PIT),时间戳计数器（Time Stamp Counter，TSC）。这些时钟硬件都是
安卓OpenGL添加水印并录制---抖音录制原理
分享Android应用和系统开发、音视频编码、性能优化相关知识
04-21 3555
简单的音视频录制，我们可以使用 MediaRecorder ，具体示例可以参考 Gitee: Camera2Video。本文将介绍采集 Camera 的预览数据，然后通过 OpenGL 添加水印、贴纸、美颜滤镜等后渲染到 GLSurfaceView ，再用 MediaCodec 硬编码后通过 MediaMuxer 写入 MP4 文件。
如何添加时间戳
06-02
在anglogic模型中添加时间戳可以通过在模型中添加一个时间戳变量来实现。以下是一个简单的步骤： 1. 打开anglogic模型，在模型中选择需要添加时间戳的事件或流程。 2. 选择您要添加时间戳的事件或流程，然后在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值