camera2 opengl实现滤镜效果录制视频 四 录像

最新推荐文章于 2024-10-08 16:03:02 发布
最新推荐文章于 2024-10-08 16:03:02 发布
阅读量2.1k 收藏 2
点赞数
分类专栏： android opengl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010302327/article/details/77839583
版权

对录像这块，没怎么研究视频尺寸，这也是我没有用MediaRecorde的原因，我估计用MediaRecorde报错是尺寸不匹配

录像和录音差不多

VideoEncoder

public class VideoEncoder {

    //视频参数
    private static final String VIDEO_MIME_TYPE = "video/avc";//视频类型
    private static final int BIT_RATE = 128000; //比特率
    private static final int FRAME_RATE = 25; //帧率
    private static final int FI_FRAME_INTERVAL = 5; //关键帧时间
    private static final int MAX_WIDTH = 1280;
    private static final int MAX_HEIGHT = 1280;
    private int videoWidth = 1280;
    private int videoHeight = 720;

    private MediaMuxer mediaMuxer;
    private MediaCodec videoMediaCodec;

    private Surface surface;
    //应该是按2的倍数吧，没验证过，反正直接用相机的尺寸会报错，可能尺寸太大
    public void setVideoSize(int width,int height){
        int w = width;
        int h = height;
        if(w > h){
            while (w > MAX_WIDTH){
                w = w/2;
                h = h/2;
            }
        }else{
            while (h > MAX_HEIGHT){
                w = w/2;
                h = h/2;
            }
        }
        videoWidth = w;
        videoHeight = h;
    }
    //初始化，和录音差不多就MediaFormat初始化参数不同和获取Surface
    public void initVideo(){
        File f = new File("/storage/emulated/0/360/"+System.currentTimeMillis()+".mp4");
        try {
            mediaMuxer = new MediaMuxer(f.getPath(),MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);
        } catch (Exception e){
            e.printStackTrace();
        }
        try {
            videoMediaCodec = MediaCodec.createEncoderByType(VIDEO_MIME_TYPE);
        } catch (IOException e) {
            e.printStackTrace();
        }
        MediaFormat mediaFormat = MediaFormat.createVideoFormat(VIDEO_MIME_TYPE, videoWidth, videoHeight);
        mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, BIT_RATE);
        mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, FRAME_RATE);
        mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
        mediaFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, FI_FRAME_INTERVAL);
        videoMediaCodec.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
        surface = videoMediaCodec.createInputSurface();
        videoMediaCodec.start();
    }

    public Surface getSurface() {
        return surface;
    }
    public int getVideoWidth(){
        return videoWidth;
    }
    public int getVideoHeight(){
        return videoHeight;
    }

    public void start(){
        Thread thread = new Thread(){
            @Override
            public void run() {
                super.run();
                videoEncoder();
            }
        };
        thread.start();
    }



    private boolean stop = true;
    public void stop(){
        stop = false;
    }
    //继续死循环
    public void videoEncoder() {
        MediaCodec.BufferInfo mBufferInfo = new MediaCodec.BufferInfo();
        int mTrackIndex = -1;
        while (stop) {
            //等待数据返回，阻塞线程，时间1000毫秒
            int encoderStatus = videoMediaCodec.dequeueOutputBuffer(mBufferInfo, 1000);
            if (encoderStatus >= 0) {
                ByteBuffer encodedData = videoMediaCodec.getOutputBuffer(encoderStatus);
                if ((mBufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
                    mBufferInfo.size = 0;
                }
                //有数据是写入
                if (mBufferInfo.size != 0) {
                    encodedData.position(mBufferInfo.offset);
                    encodedData.limit(mBufferInfo.offset + mBufferInfo.size);
                    writeData(mTrackIndex, encodedData, mBufferInfo);
                }
                videoMediaCodec.releaseOutputBuffer(encoderStatus, false);
                if ((mBufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
                    break;      // out of while
                }
            }else if(encoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER){
                //负数，听说是一段数据写入完成传入INFO_TRY_AGAIN_LATER，会进入这里，用Surface不知道会不会进入，没验证过
            }else if(encoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED){
                MediaFormat mediaFormat = videoMediaCodec.getOutputFormat();
                mTrackIndex = mediaMuxer.addTrack(mediaFormat);
                mediaMuxer.start();
            }else{
                //不是正数都跳过
            }
        }
        //使用Surface需要调用，通知MediaCodec停止接收数据，直接数据操作时不需要调用
        videoMediaCodec.signalEndOfInputStream();

        release();
    }
    //防止多线程时同时调用
    public synchronized void writeData(int mTrackIndex,ByteBuffer encodedData,MediaCodec.BufferInfo mBufferInfo){
        mediaMuxer.writeSampleData(mTrackIndex, encodedData, mBufferInfo);
    }
    //释放
    public void release() {
        if(surface != null){
            surface.release();
            surface = null;
        }
        if (videoMediaCodec != null) {
            videoMediaCodec.stop();
            videoMediaCodec.release();
            videoMediaCodec = null;
        }
        if(mediaMuxer != null){
            mediaMuxer.release();
            mediaMuxer = null;
        }
    }
}

VideoSurfaceView

public class VideoSurfaceView extends SurfaceView{


    private EGLUtils mEglUtils;
    private GLFramebuffer mFramebuffer;
    private GLRenderer mRenderer;
    private SurfaceTexture mSurfaceTexture;
    private Surface mSurface;

    private final Object mObject = new Object();

    private String mCameraId;
    private CameraManager mCameraManager;
    private CameraCaptureSession mCameraCaptureSession;
    private CameraDevice mCameraDevice;
    private Handler mHandler;


    private VideoEncoder mVideoEncoder;
    private final Object vObject = new Object();


    private int screenWidth, screenHeight;
    private int previewWidth;
    private int previewHeight;

    public VideoSurfaceView(Context context) {
        super(context);
        init(context);
    }
    public VideoSurfaceView(Context context, AttributeSet attributeSet) {
        super(context,attributeSet);
        init(context);
    }
    private void init(Context context){
        mFramebuffer = new GLFramebuffer(context);
        mRenderer = new GLRenderer(context);
        initCamera2();
        getHolder().addCallback(new SurfaceHolder.Callback() {
            @Override
            public void surfaceCreated(SurfaceHolder surfaceHolder) {

            }
            @Override
            public void surfaceChanged(SurfaceHolder surfaceHolder, int i, int i1, int i2) {
                screenWidth = i1;
                screenHeight = i2;
                //都是前面的代码
                Thread thread = new Thread(){
                    @Override
                    public void run() {
                        super.run();
                        mEglUtils = new EGLUtils();
                        mEglUtils.initEGL(EGL14.EGL_NO_CONTEXT,getHolder().getSurface());

                        mRenderer.initShader();

                        Size mPreviewSize =  getPreferredPreviewSize(mSizes, screenWidth, screenHeight);
                        previewWidth = mPreviewSize.getHeight();
                        previewHeight = mPreviewSize.getWidth();
                        int left,top,viewWidth,viewHeight;
                        if(previewHeight > previewWidth){
                            left = 0;
                            viewWidth = screenWidth;
                            viewHeight = (int)(previewHeight*1.0f/previewWidth*viewWidth);
                            top = (screenHeight - viewHeight)/2;
                        }else{
                            top = 0;
                            viewHeight = screenHeight;
                            viewWidth = (int)(previewWidth*1.0f/previewHeight*viewHeight);
                            left = (screenWidth - viewWidth)/2;
                        }
                        Rect rect = new Rect();
                        rect.left = left;
                        rect.top = top;
                        rect.right = left + viewWidth;
                        rect.bottom = top + viewHeight;

                        mFramebuffer.initFramebuffer(previewWidth,previewHeight);

                        mSurfaceTexture = mFramebuffer.getSurfaceTexture();
                        mSurfaceTexture.setDefaultBufferSize(previewWidth, previewHeight);
                        mSurfaceTexture.setOnFrameAvailableListener(new SurfaceTexture.OnFrameAvailableListener() {
                            @Override
                            public void onFrameAvailable(SurfaceTexture surfaceTexture) {
                                synchronized (mObject) {
                                    mObject.notifyAll();
                                }
                            }
                        });
                        openCamera2();
                        while (true){
                            synchronized (mObject) {
                                try {
                                    mObject.wait();
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                            }

                            if(mSurfaceTexture == null){
                                break;
                            }
                            mFramebuffer.drawFrameBuffer(previewWidth,previewHeight);
                            //控制录像线程，和双屏播放一样，有主渲染线程控制子渲染线程
                            if(mVideoEncoder != null){
                                synchronized (vObject){
                                    vObject.notifyAll();
                                }
                            }

                            GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);

                            GLES20.glViewport(rect.left,rect.top,rect.width(),rect.height());

                            mFramebuffer.drawFrame();

                            mRenderer.drawFrame();
                            mEglUtils.swap();

                        }
                        mEglUtils.release();

                    }
                };
                thread.start();
            }

            @Override
            public void surfaceDestroyed(SurfaceHolder surfaceHolder) {
                if(mCameraCaptureSession != null){
                    mCameraCaptureSession.getDevice().close();
                    mCameraCaptureSession.close();
                    mCameraCaptureSession = null;
                }
                if(mSurface != null){
                    mSurface.release();
                    mSurface = null;
                }
                if(mSurfaceTexture != null){
                    mSurfaceTexture.release();
                    mSurfaceTexture = null;
                    synchronized (mObject) {
                        mObject.notifyAll();
                    }
                }
            }
        });
    }

    private boolean stop = false;
    public void startVideo(){
        if(mVideoEncoder != null){
            return;
        }

        mVideoEncoder = new VideoEncoder();
        mVideoEncoder.setVideoSize(previewWidth,previewHeight);
        mVideoEncoder.initVideo();
        stop = false;
        Thread thread = new Thread(){
            @Override
            public void run() {
                super.run();
                GLRenderer renderer = new GLRenderer(getContext());
                EGLUtils eglUtils = new EGLUtils();
                //把MediaCodec生成的Surface给EGL做渲染用
                eglUtils.initEGL(mEglUtils.getContext(),mVideoEncoder.getSurface());
                renderer.initShader();
                //继续死循环
                while (true){
                    synchronized (vObject) {
                        try {
                            vObject.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    if(mSurfaceTexture == null){
                        break;
                    }
                    if(stop){
                        break;
                    }

                    GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
                    GLES20.glViewport(0,0,mVideoEncoder.getVideoWidth(),mVideoEncoder.getVideoHeight());
                    mFramebuffer.drawFrame();
                    renderer.drawFrame();
                    //渲染，这样MediaCodec.dequeueOutputBuffer就有数据了
                    eglUtils.swap();
                }
                eglUtils.release();

            }
        };
        thread.start();
        mVideoEncoder.start();
    }

    public void stopVideo(){
        mVideoEncoder.stop();
        stop = true;
        mVideoEncoder = null;
    }
    //相机操作
    private Size[] mSizes;
    private void initCamera2() {
        HandlerThread handlerThread = new HandlerThread("Camera2");
        handlerThread.start();
        mHandler = new Handler(handlerThread.getLooper());
        mCameraManager = (CameraManager) getContext().getSystemService(Context.CAMERA_SERVICE);
        try {
            String[] CameraIdList = mCameraManager.getCameraIdList();
            mCameraId = CameraIdList[0];
            CameraCharacteristics characteristics = mCameraManager.getCameraCharacteristics(mCameraId);
            characteristics.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL);
            StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
            if(map != null){
                mSizes = map.getOutputSizes(SurfaceTexture.class);
            }

        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }
    private void openCamera2(){
        if (PermissionChecker.checkSelfPermission(getContext(), Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) {
            try {
                mCameraManager.openCamera(mCameraId, stateCallback, mHandler);
            } catch (CameraAccessException e) {
                e.printStackTrace();
            }
        }
    }
    private CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() {
        @Override
        public void onOpened(@NonNull CameraDevice cameraDevice) {
            mCameraDevice = cameraDevice;
            takePreview();
        }

        @Override
        public void onDisconnected(@NonNull CameraDevice cameraDevice) {
            if (mCameraDevice != null) {
                mCameraDevice.close();
                mCameraDevice = null;
            }
        }

        @Override
        public void onError(@NonNull CameraDevice cameraDevice, int i) {

        }
    };

    private void takePreview() {
        try {
            mSurface = new Surface(mSurfaceTexture);
            final CaptureRequest.Builder builder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
            builder.addTarget(mSurface);
            mCameraDevice.createCaptureSession(Arrays.asList(mSurface), new CameraCaptureSession.StateCallback() {
                @Override
                public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
                    if (null == mCameraDevice) return;
                    mCameraCaptureSession = cameraCaptureSession;
                    builder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
                    builder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
                    CaptureRequest previewRequest = builder.build();
                    try {
                        mCameraCaptureSession.setRepeatingRequest(previewRequest, null, mHandler);
                    } catch (CameraAccessException e) {
                        e.printStackTrace();
                    }
                }

                @Override
                public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {

                }
            }, mHandler);

        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }
    private Size getPreferredPreviewSize(Size[] sizes, int width, int height) {
        List<Size> collectorSizes = new ArrayList<>();
        for (Size option : sizes) {
            if (width > height) {
                if (option.getWidth() > width && option.getHeight() > height) {
                    collectorSizes.add(option);
                }
            } else {
                if (option.getHeight() > width && option.getWidth() > height) {
                    collectorSizes.add(option);
                }
            }
        }
        if (collectorSizes.size() > 0) {
            return Collections.min(collectorSizes, new Comparator<Size>() {
                @Override
                public int compare(Size s1, Size s2) {
                    return Long.signum(s1.getWidth() * s1.getHeight() - s2.getWidth() * s2.getHeight());
                }
            });
        }
        return sizes[0];
    }

}











红色与青色
关注
专栏目录
Android Opengles mediaCodec 预览录制视频 添加水印
三木仔
09-29 7758
将外部纹理转化为普通纹理 使用pbo 叠加水纹纹理（或者其他滤镜等） 使用AVO BVO 创建EGL环境共享GLSurfaceview EGLContext 绘制生成的纹理到Mediacodec创建的Surface中，录制成mp4 ...
Android 实现openGL录像添加静态图片水印
feipu1988的博客
07-18 1099
Android 水印
camera2 opengl实现滤镜效果录制视频
11-27
简单的java代码，复制到项目就可以了，我只用了黑白滤镜效果
OpenGL ES实现Android录像与拍照功能及水印添加
最新发布
weixin_29092787的博客
10-08 1117
本文还有配套的精品资源，点击获取 简介：OpenGL ES是嵌入式设备上的OpenGL版本，在Android平台上具有广泛的应用。本项目探讨如何利用OpenGL ES和Android的Camera API，实现在Android设备上进行实时视频录制的同时进行拍照和添加水印的功能。本项目的实现步骤包括设置OpenGL ES纹理视图、注册Camera预览回调、视频录制、拍照功能...
OpenGLCamera2.zip
02-25
OpenGLCamera2，Android OpenGL Camera 2.0 实现 30 种滤镜和抖音特效，博客附件，效果请查看博客相对应项目
OpenGLCamera2:Android OpenGL Camera 2.0 实现 30 种滤镜和抖音特效
05-02
OpenGLCamera2 Android OpenGL Camera 2.0 项目使用 OpenGL ES 3.0 实现 30 种相机滤镜和特效，支持相机预览和拍照，左右滑动切换滤镜。 对 OpenGL ES 3.0 不熟悉的同学可以移步 音视频录制可以参考项目，该项目基于 FFmpeg 和 Android Camera2.0 实现带滤镜的视频录制。 项目编译环境: Android Studio 4.1+ , NDK r21 滤镜展示 相关推荐 Android FFmpeg 音视频开发教程 联系交流 有疑问或技术交流可以添加我的微信：Byte-Flow , 领取视频教程，拉你入相关技术交流群，里面很多牛人帮你解答。
NDK调用OpenGL使用Camera2进行相机黑白滤镜预览(FBO离屏渲染)
weixin_44752167的博客
01-05 1266
NDK调用OpenGL使用Camera2进行相机黑白滤镜预览(FBO离屏渲染)
android opengl camera2 实现相机的实时预览 以及 点坐标samplerExternalOES的纹理坐标
Lammy的专栏
12-06 4587
相机一直是我的心病，花了几周的时间学习了下opengl se。并利用opengl来实现android平台下的实时预览。，真的硬着头皮啃 网上的大神的代码，没有什么注解，确实有点苦逼，闲话不说了现在做好笔记 ，方便回顾。 相机的预览 首先回到相机的预览，我们知道camera2，利用surfacetexture 可以在非预览情况下获得相机的数据，，然后利用与surfacetexture同一个textu...
GLCamera:基于 OpenGL ES 开发,支持实时滤镜、相机录制、视频播放功能
05-13
通过OpenGL ES，可以实现滤镜在已录制视频上的后处理，让用户在观看回放时也能体验到滤镜效果。 4. **Java编程**：由于GLCamera的标签为“Java”，我们可以推断该项目主要使用Java语言进行开发。Java是Android平台...
安卓开发实现实时拍照滤镜、录像、图片修改的完整项目源码.rar
01-29
在实时滤镜的录像场景下，开发者需要在MediaRecorder的准备阶段设置Surface，使其指向应用处理后的图像源，从而实现滤镜效果在录像中的实时应用。 4. **图片修改**： 图片修改可能包括裁剪、旋转、调整亮度对比度...
FFmpeg 开发(10)：FFmpeg 视频录制 - 视频添加滤镜和编码
yinshipin007的博客
05-20 663
音视频开发中，视频编码是另一个重要的部分，基于 FFmpeg 软件解码前面系列文章已经介绍过了，接下来主要介绍软件编码这一块，包括视频编码、音频编码、为视频添加滤镜等。后期文章安排将介绍 Android MediaCodec 硬件编解码。 前文我们对x264、fdk-aac 及 FFmpeg 进行了整合编译，本文将利用编译好的 FFmpeg 库对 Android Camera2 采集的预览帧先进行渲染，然后利用OpenGL添加滤镜，最后读取渲染结果进行编码，生成 mp4 文件。 ​ FFmpe..
MagicCamera-ImageReader, 关于美颜/滤镜 从OpenGl录制视频的一种方案.zip
09-17
MagicCamera-ImageReader, 关于美颜/滤镜 从OpenGl录制视频的一种方案
Android Studio Camera2的录像功能
04-17
利用MediaRecorder+Camera2框架实现基本的录像功能，当APP启动时自动打开摄像头，点击按钮开始录像，点击按钮停止录像并将录制的视频文件保存在sdcard/my_video/中
Camera2GLPreview,使用camera2 api和opengl es的android相机预览应用程序.zip
09-26
使用camera2 api的android相机预览应用程序。捕获是在Java中实现的，但是使用NDK和JNI在OpenGL ES／VurkC 中进行C 渲染。
RecordGL源码 OpenGL绘图、截屏、录像
04-05
一个VC++写的利用OpenGL进行绘图、录像的源码实例。RecordGL 亲测可直接编译运行（需要先安装必要的opengl包，站里很多，请自行下载）
OpenGL 解决边录像边拍照
04-16
利用opengl将录像和和camera数据进行分离,可以在service中运行,保证程序在后台一直运行,并可以在录像中获取图片,还可以添加水印图片,行车记录仪的一种很好的解决方案
Camera 2 录像
I_am_a_loser的博客
09-24 282
package com.example.camera; import android.annotation.SuppressLint; import android.content.Context; import android.content.Intent; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.ImageFormat; import android.
camera2 opengl实现滤镜效果录制视频 六 摄像头方向(完)
红色与青色
09-21 1397
补上demoGitHub 摄像头坑还是挺多的,优化了下代码，发现原来的长宽设置不对，就仔细研究了一下 显示摄像头数据时要按照摄像头的内部规定长宽来设置，而获得的尺寸都是宽比高大的,也就是横屏尺寸,而且摄像头方向和当前屏幕方向又不一样，所以刚开始的时候画面严重拉伸 贴代码 Camera2SurfaceView public class Camera2SurfaceView extends...
Camera2录像
qq_39008113的博客
09-27 515
用于录制音频和视频的一个类：MediaRecorder Initial：初始状态，当使用new()方法创建一个MediaRecorder对象或者调用了reset()方法时，该MediaRecorder对象处于Initial状态。在设定视频源或者音频源之后将转换为Initialized状态。另外，在除Released状态外的其它状态通过调用reset()方法都可以使MediaRecorder进入该状态。 Initialized:已初始化状态，可以通过在Initial状态调用setAudioSour.
Android Camera2 API实现及Demo演示
8. 视频录制：在Camera2中实现视频录制功能，并需注意处理相应的权限问题。 9. 高级功能：包括连续自动对焦、零快门延迟、RAW数据捕获等。 10. 学习资源：本Demo项目提供了一个实操示例，并配合博主在CSDN上的文章，...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值