android openGl连续录制多个视频

最新推荐文章于 2024-07-09 09:50:41 发布
最新推荐文章于 2024-07-09 09:50:41 发布
阅读量666 收藏
点赞数
分类专栏： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gan303/article/details/107152087
版权

继上篇文章的代码，在原来基础之上添加时间判断，到时间则切换至下一个录制器。

在java层我想到的逻辑就是用不同的MediaMuxer来实现，当然你也可以选择将一个视频切割为多个视频来间接实现。

下面只是粗略写下，没有根据时间戳来命名文件名，10秒到了后将视频丢到next.mp4录制，经测试，2个视频之间的差距为400ms，有待优化。

需要注意的是，如果将muxer放置主线程中释放资源，则大约耗时800ms，不同机型不同配置可能耗时更长，所有要将其放置子线程释放。

主要代码：

package com.my.video.util

import android.content.Context
import android.media.*
import android.os.*
import com.my.video.egl.EglCore
import com.my.video.filter.NoFilter
import java.io.File
import java.nio.ByteBuffer

class CodecUtil(val context: Context, val width: Int, val height: Int) {
    //H.264
    private var mediaCodec: MediaCodec? = null
    private var audioCodec: MediaCodec? = null

    //mp4
    private var mediaMuxer: MediaMuxer? = null
    private var audioRecord: AudioRecord? = null
    private var nextMuxer: MediaMuxer? = null

    //获取openGl渲染的数据
    private var eglCore: EglCore? = null

    private var handlerThread: HandlerThread? = null
    private var handler: EncodeHandler? = null
    private val bufferInfo = MediaCodec.BufferInfo()
    private var videoTrack: Int = -1
    private var audioTrack: Int = -1
    private var baseTimeStamp: Long = -1L
    val START_RECORD: Int = 0
    val STOP_RECORD: Int = 1
    val RECORD_TIME: Int = 2
    val CHANGE_NEXT: Int = 3
    var isRecording = false
    private var mAudioRunnable: AudioCodecRunnable? = null
    private var mAudioThread: Thread? = null
    private var bufferSize: Int = 0
    private val lock: Object = Object()
    private var hasStartMuxer: Boolean = false

    fun init() {
        handlerThread = HandlerThread("videoEncode")
        handlerThread?.let {
            it.start()
            handler = EncodeHandler(it.looper)
        }
        val path = context.getExternalFilesDir(null)
        val file = File("$path/test")
        if (!file.exists()) {
            file.mkdir()
        }
        mediaMuxer =
            MediaMuxer("/$path/test/test.mp4", MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4)
        nextMuxer =
            MediaMuxer("/$path/test/next.mp4", MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4)
        val mediaFormat: MediaFormat =
            MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, width, height)
        mediaFormat.setInteger(
            MediaFormat.KEY_COLOR_FORMAT,
            MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface
        )
        mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, 3500000)
        mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, 30)
        mediaFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1)
        mediaCodec = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC)
        mediaCodec?.let {
            it.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
            val surface = it.createInputSurface()
            eglCore = EglCore(surface)
            it.start()
        }
        val audioMediaFormat: MediaFormat = MediaFormat.createAudioFormat(
            "audio/mp4a-latm" //音频编码的Mime
            , 48000, 2
        )
        audioMediaFormat.setInteger(
            MediaFormat.KEY_AAC_PROFILE,
            MediaCodecInfo.CodecProfileLevel.AACObjectLC
        )
        audioMediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, 128000)
        audioCodec = MediaCodec.createEncoderByType("audio/mp4a-latm");
        audioCodec?.configure(audioMediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
        audioCodec?.start()
        bufferSize = AudioRecord.getMinBufferSize(
            48000,
            AudioFormat.CHANNEL_IN_STEREO,
            AudioFormat.ENCODING_PCM_16BIT
        )
        audioRecord = AudioRecord(
            MediaRecorder.AudioSource.MIC,
            48000,
            AudioFormat.CHANNEL_IN_STEREO,
            AudioFormat.ENCODING_PCM_16BIT,
            bufferSize
        )
    }

    fun drainEncode(endOfStream: Boolean) {
        var outPutBuffer = mediaCodec?.outputBuffers;
        mediaCodec?.let {
            while (isRecording) {
                val codeStatus: Int = it.dequeueOutputBuffer(bufferInfo, 10000)
                if (codeStatus == MediaCodec.INFO_TRY_AGAIN_LATER) {
                    if (!endOfStream) {
                        break
                    }
                } else if (codeStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
                    outPutBuffer = mediaCodec?.outputBuffers;
                } else if (codeStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
                    synchronized(lock) {
                        mediaCodec?.let {
                            var mediaFormat = it.outputFormat;
                            mediaMuxer?.let {
                                videoTrack = it.addTrack(mediaFormat)
                                if (videoTrack >= 0 && audioTrack >= 0) {
                                    it.start()
                                    hasStartMuxer = true
                                }
                            }
                        }
                    }
                } else if (codeStatus < 0) {
                    LogUtil.e("->unexpected result from encoder.dequeueOutputBuffer code=$codeStatus")
                } else {
                    var encodecData = outPutBuffer?.get(codeStatus)
                    encodecData?.let {
                        if (bufferInfo.flags and MediaCodec.BUFFER_FLAG_CODEC_CONFIG != 0) {
                            bufferInfo.size = 0
                        }
                        LogUtil.e("drainEncode---------->isWaittingInit=$isWaittingInit")
                        if (bufferInfo.size != 0 && hasStartMuxer && !isWaittingInit) {
                            getCurMuxer()?.writeSampleData(videoTrack, encodecData, bufferInfo)
                        }
                    }
                    mediaCodec?.releaseOutputBuffer(codeStatus, false)
                    if (bufferInfo.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM != 0) {
                        break
                    }
                }
            }
        }
    }

    fun release() {
        Thread {
            try {
                stop()
                handlerThread?.quit()
                mAudioThread?.interrupt()
                audioRecord?.stop()
                audioRecord?.release()
                audioCodec?.stop()
                audioCodec?.release()
                mediaCodec?.signalEndOfInputStream()
                mediaCodec?.stop()
                mediaCodec?.release()
                eglCore?.release()
                nextMuxer?.stop()
                nextMuxer?.release()
                mediaMuxer?.stop()
                nextMuxer?.release()
                audioRecord = null
                audioCodec = null
                handlerThread = null
                mediaCodec = null
                eglCore = null
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }.start()
    }

    private var time = 0;
    private var hasChangeMuxer: Boolean = false
    private var isWaittingInit: Boolean = false

    inner class EncodeHandler(looper: Looper) : Handler(looper) {
        override fun handleMessage(msg: Message) {
            super.handleMessage(msg)
            when (msg.what) {
                START_RECORD -> {
                    drainEncode(false)
                    prepare()
                    draw()//如果不绘画将得到无画面的视频
                    if (baseTimeStamp == -1L) {
                        baseTimeStamp = System.nanoTime()
                        sendEmptyMessage(RECORD_TIME)
                    }
                    var time = System.nanoTime() - baseTimeStamp
                    eglCore?.setPresentTime(time)
                    eglCore?.swapBuffer()
                }
                STOP_RECORD -> {
                    drainEncode(true)
                }
                RECORD_TIME -> {
                    if (time <= 10) {
                        time++;
                        sendEmptyMessageDelayed(RECORD_TIME, 1000)
                    } else {
                        sendEmptyMessage(CHANGE_NEXT)
                    }
                }
                CHANGE_NEXT -> {
                    isWaittingInit = true
                    Thread(){
                        mediaMuxer?.let {
                            it.stop()
                            it.release()
                        }
                    }.start()
                    mediaCodec?.let {
                        var mediaFormat = it.outputFormat;
                        videoTrack = nextMuxer?.addTrack(mediaFormat) ?: -1
                    }
                    audioCodec?.let {
                        var mediaFormat = it.outputFormat;
                        audioTrack = nextMuxer?.addTrack(mediaFormat) ?: -1
                    }
                    nextMuxer?.start()
                    hasChangeMuxer = true
                    isWaittingInit = false
                    mediaMuxer = null
                }
            }
        }
    }

    fun start() {
        isRecording = true
        if (mAudioRunnable == null) {
            mAudioRunnable = AudioCodecRunnable()
            mAudioThread = Thread(mAudioRunnable)
            mAudioThread?.start()
        }
        handler?.sendEmptyMessage(START_RECORD)
    }

    fun stop() {
        LogUtil.e("--->stop")
        isRecording = false
        handler?.sendEmptyMessage(STOP_RECORD)
    }

    private var hasPrepare: Boolean = false
    fun prepare() {
        if (hasPrepare) {
            return
        }
        hasPrepare = true
        eglCore?.eglMakeCurrent()
        showFilter.create()
    }

    private var showFilter: NoFilter =
        NoFilter();

    fun setTextureId(textureId: Int) {
        showFilter.setTextureId(textureId)
    }

    fun draw() {
        showFilter.drawFrame()
    }

    private inner class AudioCodecRunnable : Runnable {
        private var baseTimeStamp: Long = -1
        var mInfo = MediaCodec.BufferInfo()

        init {
            baseTimeStamp = System.nanoTime()
            audioRecord?.startRecording()
        }

        override fun run() {
            while (isRecording) {
                if (audioCodec != null) {
                    audioCodec?.let {
                        val index: Int = it.dequeueInputBuffer(0)
                        if (index >= 0) {
                            val buffer: ByteBuffer? =
                                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                                    it.getInputBuffer(index)
                                } else {
                                    it.inputBuffers[index]
                                }
                            buffer?.let {
                                it.clear()
                                val audioLength: Int = audioRecord?.read(it, bufferSize) ?: 0
                                if (audioLength > 0) {
                                    val curTimeStamp: Long = System.nanoTime()
                                    val time = (curTimeStamp - baseTimeStamp) / 1000
                                    var endFlag: Int = if (isRecording) {
                                        0
                                    } else {
                                        MediaCodec.BUFFER_FLAG_END_OF_STREAM
                                    }
                                    audioCodec?.queueInputBuffer(//将audioRecord的数据放置在MediaCodec中转码再塞到MediaMuxer合成Mp4
                                        index,
                                        0,
                                        audioLength,
                                        time,
                                        endFlag
                                    )
                                }
                            }
                        }
                        var outIndex: Int = MediaCodec.INFO_TRY_AGAIN_LATER
                        do {
                            if (audioCodec == null) {
                                outIndex = 1
                            } else {
                                outIndex = it.dequeueOutputBuffer(mInfo, 0)
                                if (outIndex >= 0) {
                                    val buffer: ByteBuffer? =
                                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                                            it.getOutputBuffer(outIndex)
                                        } else {
                                            it.outputBuffers[outIndex]
                                        }
                                    buffer?.position(mInfo.offset)
                                    LogUtil.e("---------->isWaittingInit=$isWaittingInit")
                                    if (buffer != null && hasStartMuxer && mInfo.presentationTimeUs > 0 && !isWaittingInit) {
                                        try {
                                            getCurMuxer()?.writeSampleData(
                                                audioTrack,
                                                buffer,
                                                mInfo
                                            )
                                        } catch (e: Exception) {
                                            e.printStackTrace()
                                        }
                                    }
                                    it.releaseOutputBuffer(outIndex, false)
                                } else if (outIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
                                    synchronized(lock) {
                                        var mediaFormat = it.outputFormat;
                                        mediaMuxer?.let {
                                            audioTrack = it.addTrack(mediaFormat)
                                            LogUtil.e("AudioCodecRunnable----->run in this start videoTrack=$videoTrack->audioTrack=$audioTrack")
                                            if (videoTrack >= 0 && audioTrack >= 0) {
                                                it.start()
                                                hasStartMuxer = true
                                            }
                                        }
                                    }
                                } else if (outIndex == MediaCodec.INFO_TRY_AGAIN_LATER) {

                                }
                            }
                        } while (outIndex >= 0)
                    }
                } else {
                    break
                }
            }
        }
    }

    private fun getCurMuxer(): MediaMuxer? {
        if (hasChangeMuxer) {
            return nextMuxer
        }
        return mediaMuxer
    }
}

 

我要这中杯
关注
专栏目录
安卓双摄像头录像_android开发之调用手机的摄像头使用MediaRecorder录像并播放_Android_脚本之家...
weixin_39940788的博客
12-21 584
我们玩玩手机的录像功能吧。做个DEMO。看看录制过程：复制代码 代码如下:mediarecorder = new MediaRecorder();// 创建mediarecorder对象// 设置录制视频源为Camera(相机)mediarecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);// 设置录制完成后视频的封装格式THREE_...
【USBCamera】UVCCamera多摄像头预览拍照
lianghao的博客
04-28 4464
USB多摄像头同时预览和拍照
Android(3) : 按钮点击录音和结束录音保存为pcm文件
最新发布
Lxinccode的博客
07-09 87
注: 来自gpt生成, 已验证可用。
安卓平台多个视频叠加演示demo说明
baodaheng5756的博客
12-16 353
多个音视频编辑演示说明: 第一个-----字幕和视频的叠加: 说明: 把字幕文件中的文字,按照时间叠加到视频上去,形成新的视频. 类似我们看电影时的字幕. 下载地址:http://www.cnblogs.com/guobaPlayer/p/5036235.html 操作步骤: 需要您在编辑框里输入要叠加的视频文件和字幕文件.然后点击...
Android OpenGL渲染双视频
K-night的专栏
04-23 9309
前言想做的有很多，奈何能力实在有限，所以只能一步一步来，将自己做出来的尽量用简单易懂的语言描述出来，希望自己总结的对阅读这篇文章的同学有所帮助。在上一篇文章中讲述了怎样在GLSurfaceView上预览Camera的视频数据，在本章中打算实现一个类似微信视频通话的效果，微信视频通话主要有大小两个视频数据渲染（自己的视频和对端的视频），手指点击小视频，可以切换大视频和小视频的位置，可以拖动小视频。第一
camera2 opengl实现滤镜效果录制视频
11-27
简单的java代码，复制到项目就可以了，我只用了黑白滤镜效果
Android使用Opengl录像时添加水印
08-19
主要为大家详细介绍了Android使用Opengl录像时添加水印，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
OpenGl录制音视频
06-08
在"OpenGl录制音视频"的场景中，我们不仅要处理图形渲染，还需要整合音频和视频的录制功能。这涉及到Android多媒体框架的使用，包括MediaRecorder、AudioRecord和Camera等关键组件。 1. **MediaRecorder**：这是一...
android短视频录制编辑
09-29
在Android平台上，开发短视频录制和编辑功能是一项技术性较强的任务，涉及到多媒体处理、图像处理以及用户界面设计等多个方面。在本项目中，开发者利用了开源库RxFFmpeg来实现这一功能，这是一个基于FFmpeg库的...
openGL时间水印录制
06-10
OpenGL时间水印录制技术主要涉及计算机图形学、...综上所述，OpenGL时间水印录制涉及了OpenGL图形编程、Android开发、视频编码、时间戳处理和滤镜应用等多个方面，需要对这些技术有深入理解和实践能力才能成功实现。
OpenGL 解决边录像边拍照
04-16
利用opengl将录像和和camera数据进行分离,可以在service中运行,保证程序在后台一直运行,并可以在录像中获取图片,还可以添加水印图片,行车记录仪的一种很好的解决方案
Android使用MediaCodeC与OpenGL硬解码 录制mp4音视频实现源码
11-02
将Camera数据显示到OpenGL ES渲染的图像中，并通过MediaCodeC 将 OpenGL ES 缓冲数据，硬编码写入到 mp4 视频文件中，完成视频的录制。 文件介绍请见： https://xiaxl.blog.csdn.net/article/details/72530314 原理及实现步骤： 1、通过OpenGLES渲染Camera采集数据； 2、通过 MediaCodec.createInputSurface获取一个Surface； 3、通过EGL构建EGLDisplay并绑定Surface； 4、通过 EGL 线程中渲染GL_TEXTURE_EXTERNAL_OES对应的纹理ID； 5、在 EGL 线程完成渲染后，通过eglSwapBuffers交换缓冲，将EGL渲染内容交换到MediaCodeC给定的Surface中，从而完成mp4视频录制。
Android 仿抖音之使用OpenGL实现抖音视频录制
YuQing_Cat的博客
11-07 3074
前言 在之前写了仿抖音的第一步，就是使用OpenGL显示摄像头数据，今天这篇就是在之前的基础上来录制视频，并且对之前的代码的结构进行了简单的整理，然后进行了仿抖音的视频录制。 工程结构整理 在仿抖音的第一步中封装了ScreenFilter类来实现渲染屏幕的操作，我们都知道在抖音的视频录制过程中，可以添加很多的效果进行显示，比如说磨皮、美颜、大眼以及滤镜等效果，如果把这些效果都放在ScreenFil...
使用OpenGL同时对两路摄像头进行录像(动态水印)、并且两路录像文件都带音轨
雪飘碧鸳的博客
09-03 1948
本文介绍在Android平台下，使用OpenGL同时对两个摄像头同时预览、录像，并且录像文件均带音轨，并将录像文件（带声音）、音频文件保存下来。预览与录像均添加时间水印： 先放一个demo效果图： 1.先初始化两个摄像头预览： import android.content.Context; import android.util.Log; import android.view.SurfaceHolder; import android.view.SurfaceView; import.
安卓双摄像头录像_Android使用MediaRecorder和Camera实现视频录制及播放功能整理
weixin_39520204的博客
12-21 663
package com.example.mediarecorder;import android.app.Activity;import android.hardware.Camera;import android.media.AudioManager;import android.media.MediaPlayer;import android.media.MediaRecorder;impor...
Android OpenGL+Camera2渲染（5） —— 录制视频，实现快录慢录
wangchao1412的博客
01-04 3898
Android OpenGL+Camera2渲染（1） —— OpenGL简单介绍 Android OpenGL+Camera2渲染（2） —— OpenGL实现Camera2图像预览 Android OpenGL+Camera2渲染（3） —— 大眼，贴纸功能实现 Android OpenGL+Camera2渲染（4） —— 美颜功能实现 Android OpenGL+Camera2渲染...
android 视频分段录制,短视频录制,分段,回删,美颜,时长限制,分辨率,码率,压缩
weixin_28878185的博客
05-28 629
更新记录1.0(2019-10-30)Android版本上线，有疑问请联系QQ37894663平台兼容性AndroidiOS√×原生插件通用使用流程：购买插件，选择该插件绑定的项目。在HBuilderX里找到项目，在manifest的app原生插件配置中勾选模块，如需要填写参数则参考插件作者的文档添加。根据插件作者的提供的文档开发代码，在代码中引用插件，调用插件功能。打包自定义基座，选择插件，得到...
Android-多路摄像头实现总结（Camera - UVC）
热门推荐
迷彩狼的博客
06-20 2万+
原生Android-Camera类打开一个摄像头没有问题，打开多个会在open()的时候报错。 注意原生camera要在surface之后在open，否则会报错。也就是说不要直接在oncreate里open。（相机Open前要设置surface ,这个surface就是底层用来渲染预览画面的，如果surface 都没有create ，底层将无法渲染，我想这就是为什么open不了的原因吧）参考：h...
Android媒体开发指南：视频音频播放与录制
本书涵盖了Android平台上的视频播放与录制、音频播放与录制、图形绘制以及丰富的媒体应用开发技术。书中通过详细的代码解释和逐步指导，为读者提供了一个良好的入门教程，适合想要在Android上构建多媒体应用的开发者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值