camera2 opengl实现滤镜效果录制视频 五 音视频合并

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

前几篇文章实现了音频和视频的录制，这篇就来实现录制有声音的视频

VideoEncoder用于录制视频和编码

public class VideoEncoder {
    private static final int CHANNEL_CONFIG = AudioFormat.CHANNEL_IN_MONO; //音频通道(单声道)
    private static final int AUDIO_FORMAT = AudioFormat.ENCODING_PCM_16BIT; //音频格式
    private static final int AUDIO_SOURCE = MediaRecorder.AudioSource.MIC; //音频源（麦克风）
    private static final String AUDIO_MIME_TYPE = "audio/mp4a-latm"; //音频类型
    private static final int SAMPLE_RATE = 44100; //采样率(CD音质)
    private static final int BIT_RATE = 128000; //比特率
    private static final int CHANNEL_COUNT = 1;//声道

    private static final String VIDEO_MIME_TYPE = "video/avc";//视频类型
    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 MediaCodec audioMediaCodec;



    private Surface surface;

    //初始化
    public void initEncoder(){
        micStop = true;
        muxerVideoStart = false;
        muxerAudioStart = false;
        muxerStart = false;
        initVideo();
        initAudio();
        initMuxer();
    }
    private void initVideo(){
        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);
        try {
            videoMediaCodec = MediaCodec.createEncoderByType(VIDEO_MIME_TYPE);
        } catch (IOException e) {
            e.printStackTrace();
        }
        videoMediaCodec.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
        surface = videoMediaCodec.createInputSurface();
        videoMediaCodec.start();
    }
    private void initAudio(){
        MediaFormat audioFormat = MediaFormat.createAudioFormat(AUDIO_MIME_TYPE,SAMPLE_RATE,CHANNEL_COUNT);
        audioFormat.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC);
        audioFormat.setInteger(MediaFormat.KEY_BIT_RATE, BIT_RATE);
        audioFormat.setInteger(MediaFormat.KEY_CHANNEL_MASK, AudioFormat.CHANNEL_IN_MONO);//立体声
        try {
            audioMediaCodec = MediaCodec.createEncoderByType(AUDIO_MIME_TYPE);
        } catch (IOException e) {
            e.printStackTrace();
        }
        audioMediaCodec.configure(audioFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
        audioMediaCodec.start();
    }

    private void initMuxer(){
        String path = "/storage/emulated/0/360/" + System.currentTimeMillis() + ".mp4";
        try {
            mediaMuxer = new MediaMuxer(path,MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);
        } catch (Exception e){
            e.printStackTrace();
        }
    }

    public Surface getSurface() {
        return surface;
    }
    //视频尺寸随便写的，可以用摄像头支持尺寸
    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;
    }

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

    public void start(){
        Thread videoThread = new Thread(new VideoRun());
        Thread micThread = new Thread(new MicRun());
        Thread audioThread = new Thread(new AudioRun());
        micThread.start();
        videoThread.start();
        audioThread.start();
    }
    public void stop(){
        videoMediaCodec.signalEndOfInputStream();
        micStop = false;
    }

    //因为有多个线程调用mediaMuxer，所以使用synchronized来防止同时操作mediaMuxer
    private boolean muxerVideoStart = false;
    private boolean muxerAudioStart = false;
    private boolean muxerStart = false;
    private synchronized void muxerStart(){
        if(muxerVideoStart && muxerAudioStart && !muxerStart){
            muxerStart = true;
            mediaMuxer.start();
        }
    }
    private long outputStartTime = 0;
    //写入数据，音频和视频写入都要调用这个
    private synchronized void muxerWriteData(int mTrackIndex,ByteBuffer encodedData,MediaCodec.BufferInfo mBufferInfo){
        if(muxerStart){
            if(outputStartTime == 0){
                outputStartTime = System.nanoTime() / 1000L;
            }
            //数据写入的时间戳
            mBufferInfo.presentationTimeUs = System.nanoTime() / 1000L - outputStartTime;
            mediaMuxer.writeSampleData(mTrackIndex, encodedData, mBufferInfo);
        }
    }
    //释放mediaMuxer
    private synchronized void muxerRelease(){
        if(audioMediaCodec == null && videoMediaCodec == null && mediaMuxer != null){
            mediaMuxer.stop();
            mediaMuxer.release();
            mediaMuxer = null;
        }
    }
    //录像数据线程，靠surface获取数据
    public class VideoRun implements Runnable{
        @Override
        public void run() {
            MediaCodec.BufferInfo mBufferInfo = new MediaCodec.BufferInfo();
            int mTrackIndex = -1;
            while (true){
                //dequeueOutputBuffer:没有数据时阻塞线程，时间1000，有数据时返回一个整数状态
                int encoderStatus = videoMediaCodec.dequeueOutputBuffer(mBufferInfo, 1000);
                if (encoderStatus >= 0) {
                    if(!muxerStart){
                        continue;
                    }
                    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);
                        muxerWriteData(mTrackIndex, encodedData, mBufferInfo);
                    }
                    videoMediaCodec.releaseOutputBuffer(encoderStatus, false);
                    if ((mBufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
                        //调用 videoMediaCodec.signalEndOfInputStream();时会进入这里
                        break;
                    }
                }else if(encoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER){

                }else if(encoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED){
                    //录音和录像都会进入这里，可能会多次进入，
                    // mediaFormat相同而多次调用mediaMuxer.addTrack会报错
                    if(mTrackIndex == -1){
                        if(!muxerVideoStart){
                            muxerVideoStart = true;
                            MediaFormat mediaFormat = videoMediaCodec.getOutputFormat();
                            mTrackIndex = mediaMuxer.addTrack(mediaFormat);
                            muxerStart();
                        }
                    }
                }else{

                }
            }
            if(surface != null){
                surface.release();
                surface = null;
            }
            if (videoMediaCodec != null) {
                videoMediaCodec.stop();
                videoMediaCodec.release();
                videoMediaCodec = null;
            }
            muxerRelease();
        }
    }
    //麦克风线程
    private boolean micStop = true;
    public class MicRun implements Runnable{
        @Override
        public void run() {
            int bufferSizeInBytes = AudioRecord.getMinBufferSize(SAMPLE_RATE, CHANNEL_CONFIG, AUDIO_FORMAT);
            AudioRecord audioRecord = new AudioRecord(
                    AUDIO_SOURCE,//音频源
                    SAMPLE_RATE,//采样率
                    CHANNEL_CONFIG,//音频通道
                    AUDIO_FORMAT,//音频格式
                    bufferSizeInBytes//缓冲区
            );
            if (audioRecord.getState() != AudioRecord.STATE_INITIALIZED) {
                return;
            }
            audioRecord.startRecording();
            byte[] buffer = new byte[bufferSizeInBytes];
            long audioStartTime = System.nanoTime();
            while (micStop) {
                //时间戳随便给，和写入时间戳没有关系
                long presentationTimeUs = (System.nanoTime() - audioStartTime) / 1000;
                int bufferReadResult = audioRecord.read(buffer, 0, bufferSizeInBytes);
                if (bufferReadResult == AudioRecord.ERROR_BAD_VALUE || bufferReadResult == AudioRecord.ERROR_INVALID_OPERATION) {

                }
                //将获得的数据传给audioMediaCodec
                audioInputBuffer(buffer, presentationTimeUs, false);
            }

            long presentationTimeUs = (System.nanoTime() - audioStartTime) / 1000;
            int bufferReadResult = audioRecord.read(buffer, 0, bufferSizeInBytes);
            if (bufferReadResult == AudioRecord.ERROR_BAD_VALUE || bufferReadResult == AudioRecord.ERROR_INVALID_OPERATION) {

            }
            //停止录音时通知audioMediaCodec
            audioInputBuffer(buffer, presentationTimeUs, true);
            audioRecord.stop();
            audioRecord.release();
        }
        public void audioInputBuffer(byte[] buffer, long presentationTimeUs, boolean audioEnd) {
            int inputBufferIndex = audioMediaCodec.dequeueInputBuffer(-1);
            if (inputBufferIndex >= 0) {
                ByteBuffer inputBuffer = audioMediaCodec.getInputBuffer(inputBufferIndex);
                inputBuffer.clear();
                inputBuffer.put(buffer);
                if (audioEnd) {
                    audioMediaCodec.queueInputBuffer(inputBufferIndex, 0, buffer.length, presentationTimeUs, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
                } else {
                    audioMediaCodec.queueInputBuffer(inputBufferIndex, 0, buffer.length, presentationTimeUs, 0);
                }
            }
        }
    }

    public class AudioRun implements Runnable{
        @Override
        public void run() {
            int mTrackIndex = -1;
            MediaCodec.BufferInfo mBufferInfo = new MediaCodec.BufferInfo();
            while (true) {
                int encoderIndex = audioMediaCodec.dequeueOutputBuffer(mBufferInfo, 1000);
                if (encoderIndex == MediaCodec.INFO_TRY_AGAIN_LATER) {

                } else if (encoderIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {

                    if(!muxerAudioStart){
                        muxerAudioStart = true;
                        MediaFormat mediaFormat = audioMediaCodec.getOutputFormat();
                        mTrackIndex = mediaMuxer.addTrack(mediaFormat);
                        muxerStart();
                    }
                } else if (encoderIndex < 0) {

                } else {
                    if(!muxerStart){
                        continue;
                    }
                    ByteBuffer encodedData = audioMediaCodec.getOutputBuffer(encoderIndex);
                    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);
                        muxerWriteData(mTrackIndex, encodedData, mBufferInfo);
                        audioMediaCodec.releaseOutputBuffer(encoderIndex, false);
                    }
                    if ((mBufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
                        break;
                    }
                }
            }
            if (audioMediaCodec != null) {
                audioMediaCodec.stop();
                audioMediaCodec.release();
                audioMediaCodec = null;
            }
            muxerRelease();
        }
    }




}

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.initEncoder();
        stop = false;
        Thread thread = new Thread(){
            @Override
            public void run() {
                super.run();
                GLRenderer renderer = new GLRenderer(getContext());
                EGLUtils eglUtils = new EGLUtils();
                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();

                    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];
    }

}

通过opengl的fbo处理图像，再把图像传给MediaCodec生成的Surface和SurfaceView的Surface













红色与青色
关注
专栏目录
FFmpeg 开发(10)：FFmpeg 视频录制 - 视频添加滤镜和编码
字节流动
03-09 6887
该文章首发于微信公众号：字节流动 FFmpeg 开发系列连载： FFmpeg 开发(01)：FFmpeg 编译和集成 FFmpeg 开发(02)：FFmpeg + ANativeWindow 实现视频解码播放 FFmpeg 开发(03)：FFmpeg + OpenSLES 实现音频解码播放 FFmpeg 开发(04)：FFmpeg + OpenGLES 实现音频可视化播放 FFmpeg 开发(05)：FFmpeg + OpenGLES 实现视频解码播放和视频滤镜 FFmpeg 开发(06)：FFmp.
OpenGl录制音视频
06-08
android录制音视频，有声音有画面有聚焦功能，支持切换前后摄像头等
ffmpeg-concat：使用ffmpeg和性感的OpenGL过渡将视频列表合并在一起
02-03
ffmpeg-concat 使用带有性感OpenGL过渡的ffmpeg将视频列表合并在一起。 （将9个视频与唯一的转场串联在一起的示例） （请注意，由于GIF预览，质量和fps都很差； 是原始图像） 介绍 是命令行视频编辑中的事实上的标准，但是使用非平​​凡的过渡将视频连接在一起确实很困难。 这是两个视频之间简单淡入淡出的一些。 FFmpeg过滤器图功能非常强大，但是对于实现过渡而言，它们太复杂且容易出错。 另一方面， 是由牵头的一项伟大的开源计划，旨在利用GLSL建立通用的过渡。 它非常简单的规范使您可以非常轻松地自定义现有转换或编写自己的转换，而不用费力处理复杂的ffmpeg过滤器图。 通过此模块和CLI，可以轻松使用gl-transition将视频合并在一起。 安装 该模块需要安装 。 npm install --save ffmpeg-concat # or if you want to use the CLI npm install -g ffmpeg-concat 该软件包可在Linux，macOS和Windows上运行。 支持Node.js 10.13.0
camera2 opengl实现滤镜效果录制视频 三 录音
红色与青色
08-30 954
本来是想用MediaRecorder直接录像的，可是好像参数设置错误总是报错就改用MediaCodec了 MediaCodec配合MediaMuxer进行录音，以后可以直接用来录像 public class AudioEncoder { private static final int CHANNEL_CONFIG = AudioFormat.CHANNEL_IN_MONO; //
Android 平台的音视频编解码项目，使用 MediaCodeC、OpenGL 高效解决音视频编解码问题
未来很长，但我会努力的走下去。
07-31 631
MediaLearn 项目地址：JadynAi/MediaLearn 简介：基于 Android 平台的音视频编解码项目，使用 MediaCodeC、OpenGL 高效解决音视频编解码问题 更多：作者提 Bug 标签： MediaLearn是一个旨在分享音视频开发知识的项目，目前仅仅局限于 Android 平台，后续会逐步扩展。 因为项目是以学习为目的，所以暂时不支持...
基于Android平台的音视频编解码项目，使用MediaCodeC、OpenGL高效解决音视频编解码问题.zip
最新发布
02-14
【项目资源】： 包含前端、后端、移动开发、操作系统、人工智能、物联网、信息化管理、数据库、硬件开发、大数据、课程资源、音视频、网站开发等各种技术项目的源码。 包括STM32、ESP8266、PHP、QT、Linux、iOS、C++、Java、python、web、C#、EDA、proteus、RTOS等项目的源码。 【项目质量】： 所有源码都经过严格测试，可以直接运行。 功能在确认正常工作后才上传。 【适用人群】： 适用于希望学习不同技术领域的小白或进阶学习者。 可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【附加价值】： 项目具有较高的学习借鉴价值，也可直接拿来修改复刻。 对于有一定基础或热衷于研究的人来说，可以在这些基础代码上进行修改和扩展，实现其他功能。 【沟通交流】： 有任何使用上的问题，欢迎随时与博主沟通，博主会及时解答。 鼓励下载和使用，并欢迎大家互相学习，共同进步。
OpenGLCamera2:Android OpenGL Camera 2.0 实现 30 种滤镜和抖音特效
05-02
音视频录制可以参考项目，该项目基于 FFmpeg 和 Android Camera2.0 实现带滤镜的视频录制。 项目编译环境: Android Studio 4.1+ , NDK r21 滤镜展示 相关推荐 Android FFmpeg 音视频开发教程 联系交流 有疑问或技术...
使用JavaCV提供的支持， 使用OpenGL实时处理+显示摄像头采集的图像， 并使用FFMPEG实时录制音视频_Java
07-12
在本文中，我们将深入探讨如何使用JavaCV库在Android平台上实现OpenGL实时图像处理，同时结合FFmpeg进行音视频录制。JavaCV是一个强大的工具包，它为Java和Android开发者提供了多种计算机视觉库的接口，包括OpenCV、...
FFmpeg 开发(05)：FFmpeg + OpenGLES 实现视频解码播放和视频滤镜
yinshipin007的博客
05-19 1094
前面 Android FFmpeg 开发系列文章中，我们已经利用 FFmpeg 的解码功能和 ANativeWindow 的渲染功能，实现了的视频的解码播放。但是，当你想为播放器做一些视频滤镜时，如加水印、旋转缩放等效果，使用 OpenGL ES 实现起来就极为方便。 OpenGLES 渲染解码帧 经过上面几节的介绍，我们对音视频的解码过程已经比较熟悉了。本文要用 OpenGL 实现视频的渲染，这里再回顾下视频的解码流程： 从流程图中可以看出，解码一帧图像后，首先将对图像进行格式转换.
音视频开发系列(39)OpenGL ES 实时滤镜
yinshipin007的博客
04-18 483
一、基本知识介绍 **外部纹理是什么？** public static native void glBindTexture( int target, int texture ); 我们在前面几篇中target一直是GL_TEXTURE_2D，即一张纹理图片，直接进行渲染。而在播放视频或者Camera预览 对数据进行滤镜、特效处理后在渲染到屏幕上而不是直接渲染到屏幕，这是就需要用到OES外部纹理，GLES11Ext.GL_TEXTURE_EXTER
camera2 opengl实现滤镜效果录制视频
11-27
简单的java代码，复制到项目就可以了，我只用了黑白滤镜效果
OpenGLES 在 android 上显示摄像头滤镜效果
11-04
这是一份 使用opengles 绘制摄像头数据的代码，并使用滤镜处理了摄像头的效果，使用GPU绘制，减少cpu的占用
FFmpeg，opengl，gpuimage，完成音视频同步加GpuImage的滤镜功能
09-21
FFmpeg，opengl，gpuimage，完成音视频同步加GpuImage的滤镜功能 android平台 FFmpeg2.7.2 opengl 2.0
OpenGL ES和Metal 滤镜处理资料.zip
05-19
OpenGL是跨平台GPU编程技术，估计大家都有遇到过滤镜，视频相关的开发那么肯定听说过OpenGL，最近在学习OpenGL 时，在网上找了好久的资料都没有找到，经过不懈努力还是被我找到了，
Android代码-七牛短视频SDK美颜滤镜水印编辑混音特效
08-06
PLDroidShortVideo PLDroidShortVideo 是七牛推出的一款适用于 Android 平台的短视频 SDK，提供了包括美颜、滤镜、水印、断点录制、分段回删、视频编辑、混音特效、本地/云端存储在内的多种功能，支持高度定制以及二次开发。 1. 功能列表 短视频 SDK 的功能，主要分为 3 大块：拍摄、编辑、上传。 1.1 拍摄功能 功能点 版本 摄像头采集 1.0.0( ) 麦克风采集 1.0.0( ) 静音功能 1.0.0( ) 实时美颜 1.0.0( ) 贴纸特效 1.0.0( ) 大眼/瘦脸 1.0.0( ) 闪光灯开关 1.0.0( ) 第三方美颜接口 1.0.0( ) 第三方滤镜接口 1.0.0( ) 自定义拍摄时长 1.0.0( ) 自定义分辨率 1.0.0( ) 自定义视频帧率 1.0.0( ) 自定义视频码率 1.0.0( ) 支持 1:1 正方形录制 1.0.0( ) 断点拍摄（多段录制） 1.0.0( ) 回删视频 1.0.0( ) H.264 硬编 1.0.0(
NDK OpenGL ES 3.0 开发（十七）：相机基础滤镜
字节流动
12-01 8333
该原创文章首发于微信公众号：字节流动 相机基础滤镜 上文中我们通过 ImageReader 获取到 Camera2 预览的 YUV 数据，然后利用 OpenGLES 渲染实现相机预览，这一节将利用 GLSL （OpenGL 着色器语言）基于不同的着色器实现多种基础滤镜。 GLSL 一些使用频率比较高的内建函数 内建函数 函数说明 float distance (genType ...
视频文件怎样加滤镜？
rangsou5445的博客
12-29 342
我想给视频文件加上各种滤镜效果生成一个新视频，但是我找了半天，发现网上的例子大都是给图片或者实时录像加滤镜的，有给视频文件加滤镜的例子吗？
Camera2+MediaCodec+AudioRecord+MediaMuxer实现录制功能（带源码）
weixin_44752167的博客
06-08 7230
该文章实现了Camera2使用MediaCodec进行录像，合成MP4 有视频轨道，有音频轨道 Camera2+MediaCodec+AudioRecord+MediaMuxer 存在完整源码
android openGl录制音视频
坚持，努力
06-08 1264
步骤->将camera预览至GlSurfaceView上，然后通过EGLSurface+MediaCodec+AudioRecord+MediaMuxer后台录制成Mp4 主要代码: package com.my.video import android.graphics.SurfaceTexture import android.opengl.GLES20 import android.opengl.GLSurfaceView import javax.microedition.khrono
Android MediaRecorder 实现视频音频录制详解
"Android使用MediaRecorder类实现视频和音频录制功能" 在Android平台上，开发者可以利用MediaRecorder类来实现视频和音频的录制功能。MediaRecorder是一个强大的工具，它允许我们设置各种参数以满足不同的录制需求...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值