那些遇到过的问题

如何混合（合并）视频和音频，以便在持续时间过短的情况下音频会在输出视频中循环播放？

and*_*per 6 audio video android mediamuxer

背景

我需要将视频文件和音频文件合并为一个视频文件，以便：

  1. 输出视频文件的持续时间与输入视频文件的持续时间相同
  2. 输出文件中的音频仅属于输入音频文件。如果太短，它将循环到结尾（如果需要，可以在结尾停止）。这意味着一旦音频完成播放而视频未播放完，我应该一次又一次地播放，直到视频结束（音频的级联）。

正如我所读过的，这种合并操作的技术术语称为“混合”。

例如，假设我们有一个10秒的输入视频和一个4秒的音频文件，输出视频将是10秒（始终与输入视频相同），并且音频将播放2.5次（前2个覆盖前8秒，然后剩下4秒中的2秒）。

问题所在

我找到了一种解决方案，可以将视频和音频多路复用（在此处），但遇到了多个问题：

  1. 我无法弄清楚如何在需要时循环编写音频内容。无论我尝试什么，它总是给我一个错误

  2. 输入文件必须具有特定的文件格式。否则，它可能会引发异常，或者（在极少数情况下）更糟：创建具有黑色内容的视频文件。甚至更多：有时例如可以使用“ .mkv”文件，有时则无法接受（并且两者都可以在视频播放器应用上播放）。

  3. 当前代码处理缓冲区，而不是实际持续时间。这意味着在很多情况下，即使我不这样做，我也可能会停止混合音频，并且即使视频足够长，与原始视频相比，输出视频文件的音频内容也会更短。

我尝试过的

  • 我尝试通过以下方法使音频的MediaExtractor每次到达末尾时都开始播放：

            if (audioBufferInfo.size < 0) {
            Log.d("AppLog", "reached end of audio, looping...")
            audioExtractor.seekTo(0, MediaExtractor.SEEK_TO_CLOSEST_SYNC)
            audioBufferInfo.size = audioExtractor.readSampleData(audioBuf, 0)
        }
    Run Code Online (Sandbox Code Playgroud)

  • 为了检查文件的类型，我尝试使用MediaMetadataRetriever然后检查mime-type。我认为受支持的文档可以在文档（此处）中作为标有“编码器” 的文档获得。对此不确定。我也不知道那是哪一种MIME类型。

  • 我还尝试重新初始化与音频有关的所有内容，但也没有用。

这是我当前的多路复用本身的代码（可在此处找到完整的示例项目）：

object VideoAndAudioMuxer {
    //   based on:  /sf/answers/2211403981/
    @WorkerThread
    fun joinVideoAndAudio(videoFile: File, audioFile: File, outputFile: File): Boolean {
        try {
            //            val videoMediaMetadataRetriever = MediaMetadataRetriever()
            //            videoMediaMetadataRetriever.setDataSource(videoFile.absolutePath)
            //            val videoDurationInMs =
            //                videoMediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION).toLong()
            //            val videoMimeType =
            //                videoMediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_MIMETYPE)
            //            val audioMediaMetadataRetriever = MediaMetadataRetriever()
            //            audioMediaMetadataRetriever.setDataSource(audioFile.absolutePath)
            //            val audioDurationInMs =
            //                audioMediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION).toLong()
            //            val audioMimeType =
            //                audioMediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_MIMETYPE)
            //            Log.d(
            //                "AppLog",
            //                "videoDuration:$videoDurationInMs audioDuration:$audioDurationInMs videoMimeType:$videoMimeType audioMimeType:$audioMimeType"
            //            )
            //            videoMediaMetadataRetriever.release()
            //            audioMediaMetadataRetriever.release()
            outputFile.delete()
            outputFile.createNewFile()
            val muxer = MediaMuxer(outputFile.absolutePath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4)
            val sampleSize = 256 * 1024
            //video
            val videoExtractor = MediaExtractor()
            videoExtractor.setDataSource(videoFile.absolutePath)
            videoExtractor.selectTrack(0)
            videoExtractor.seekTo(0, MediaExtractor.SEEK_TO_CLOSEST_SYNC)
            val videoFormat = videoExtractor.getTrackFormat(0)
            val videoTrack = muxer.addTrack(videoFormat)
            val videoBuf = ByteBuffer.allocate(sampleSize)
            val videoBufferInfo = MediaCodec.BufferInfo()
//            Log.d("AppLog", "Video Format $videoFormat")
            //audio
            val audioExtractor = MediaExtractor()
            audioExtractor.setDataSource(audioFile.absolutePath)
            audioExtractor.selectTrack(0)
            audioExtractor.seekTo(0, MediaExtractor.SEEK_TO_CLOSEST_SYNC)
            val audioFormat = audioExtractor.getTrackFormat(0)
            val audioTrack = muxer.addTrack(audioFormat)
            val audioBuf = ByteBuffer.allocate(sampleSize)
            val audioBufferInfo = MediaCodec.BufferInfo()
//            Log.d("AppLog", "Audio Format $audioFormat")
            //
            muxer.start()
//            Log.d("AppLog", "muxing video&audio...")
            //            val minimalDurationInMs = Math.min(videoDurationInMs, audioDurationInMs)
            while (true) {
                videoBufferInfo.size = videoExtractor.readSampleData(videoBuf, 0)
                audioBufferInfo.size = audioExtractor.readSampleData(audioBuf, 0)
                if (audioBufferInfo.size < 0) {
                    //                    Log.d("AppLog", "reached end of audio, looping...")
                    //TODO somehow start from beginning of the audio again, for looping till the video ends
                    //                    audioExtractor.seekTo(0, MediaExtractor.SEEK_TO_CLOSEST_SYNC)
                    //                    audioBufferInfo.size = audioExtractor.readSampleData(audioBuf, 0)
                }
                if (videoBufferInfo.size < 0 || audioBufferInfo.size < 0) {
//                    Log.d("AppLog", "reached end of video")
                    videoBufferInfo.size = 0
                    audioBufferInfo.size = 0
                    break
                } else {
                    //                    val donePercentage = videoExtractor.sampleTime / minimalDurationInMs / 10L
                    //                    Log.d("AppLog", "$donePercentage")
                    // video muxing
                    videoBufferInfo.presentationTimeUs = videoExtractor.sampleTime
                    videoBufferInfo.flags = videoExtractor.sampleFlags
                    muxer.writeSampleData(videoTrack, videoBuf, videoBufferInfo)
                    videoExtractor.advance()
                    // audio muxing
                    audioBufferInfo.presentationTimeUs = audioExtractor.sampleTime
                    audioBufferInfo.flags = audioExtractor.sampleFlags
                    muxer.writeSampleData(audioTrack, audioBuf, audioBufferInfo)
                    audioExtractor.advance()
                }
            }
            muxer.stop()
            muxer.release()
//            Log.d("AppLog", "success")
            return true
        } catch (e: Exception) {
            e.printStackTrace()
//            Log.d("AppLog", "Error " + e.message)
        }
        return false
    }
}
Run Code Online (Sandbox Code Playgroud)
  • 我也尝试过使用FFMPEG库（在这里和这里）来了解如何做。它运行良好，但是存在一些可能的问题：该库似乎占用了很多空间，令人讨厌的许可条款，并且由于某种原因，该示例无法播放我必须创建的输出文件，除非我删除了其中的内容。命令，将使转换速度大大降低。我真的更喜欢使用内置的API，而不是使用此库，即使它是一个非常强大的库...而且，对于某些输入文件，它似乎没有循环...

问题

  1. 我如何混音视频和音频文件，以便在音频比视频短（持续时间）的情况下音频会循环播放？

  2. 如何做到在视频结束时准确地剪切音频（视频和音频中都没有剩余）？

  3. 如何在调用此函数之前检查当前设备是否可以处理给定的输入文件并实际将其混合？有没有一种方法可以在运行时检查这种操作所支持的方法，而不是依赖将来可能会更改的文档列表？

lij*_*jia 2

我也有同样的场景。

  • 1：当audioBufferInfo.size< 0时，寻道开始。但记住，你需要积累presentationTimeUs。

  • 2：获取视频时长，当音频循环到时长（presentationTimeUs也用）时，进行剪切。

  • 3：音频文件需要是MediaFormat.MIMETYPE_AUDIO_AMR_NB或MediaFormat.MIMETYPE_AUDIO_AMR_WB或MediaFormat.MIMETYPE_AUDIO_AAC。在我的测试机器上，它运行良好。

这是代码：

private fun muxing(musicName: String) {
    val saveFile = File(DirUtils.getPublicMediaPath(), "$saveName.mp4")
    if (saveFile.exists()) {
        saveFile.delete()
        PhotoHelper.sendMediaScannerBroadcast(saveFile)
    }
    try {
        // get the video file duration in microseconds
        val duration = getVideoDuration(mSaveFile!!.absolutePath)

        saveFile.createNewFile()

        val videoExtractor = MediaExtractor()
        videoExtractor.setDataSource(mSaveFile!!.absolutePath)

        val audioExtractor = MediaExtractor()
        val afdd = MucangConfig.getContext().assets.openFd(musicName)
        audioExtractor.setDataSource(afdd.fileDescriptor, afdd.startOffset, afdd.length)

        val muxer = MediaMuxer(saveFile.absolutePath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4)

        videoExtractor.selectTrack(0)
        val videoFormat = videoExtractor.getTrackFormat(0)
        val videoTrack = muxer.addTrack(videoFormat)

        audioExtractor.selectTrack(0)
        val audioFormat = audioExtractor.getTrackFormat(0)
        val audioTrack = muxer.addTrack(audioFormat)

        var sawEOS = false
        val offset = 100
        val sampleSize = 1000 * 1024
        val videoBuf = ByteBuffer.allocate(sampleSize)
        val audioBuf = ByteBuffer.allocate(sampleSize)
        val videoBufferInfo = MediaCodec.BufferInfo()
        val audioBufferInfo = MediaCodec.BufferInfo()

        videoExtractor.seekTo(0, MediaExtractor.SEEK_TO_CLOSEST_SYNC)
        audioExtractor.seekTo(0, MediaExtractor.SEEK_TO_CLOSEST_SYNC)

        muxer.start()

        val frameRate = videoFormat.getInteger(MediaFormat.KEY_FRAME_RATE)
        val videoSampleTime = 1000 * 1000 / frameRate

        while (!sawEOS) {
            videoBufferInfo.offset = offset
            videoBufferInfo.size = videoExtractor.readSampleData(videoBuf, offset)

            if (videoBufferInfo.size < 0) {
                sawEOS = true
                videoBufferInfo.size = 0

            } else {
                videoBufferInfo.presentationTimeUs += videoSampleTime
                videoBufferInfo.flags = videoExtractor.sampleFlags
                muxer.writeSampleData(videoTrack, videoBuf, videoBufferInfo)
                videoExtractor.advance()
            }
        }

        var sawEOS2 = false
        var sampleTime = 0L
        while (!sawEOS2) {

            audioBufferInfo.offset = offset
            audioBufferInfo.size = audioExtractor.readSampleData(audioBuf, offset)

            if (audioBufferInfo.presentationTimeUs >= duration) {
                sawEOS2 = true
                audioBufferInfo.size = 0
            } else {
                if (audioBufferInfo.size < 0) {
                    sampleTime = audioBufferInfo.presentationTimeUs
                    audioExtractor.seekTo(0, MediaExtractor.SEEK_TO_CLOSEST_SYNC)
                    continue
                }
            }
            audioBufferInfo.presentationTimeUs = audioExtractor.sampleTime + sampleTime
            audioBufferInfo.flags = audioExtractor.sampleFlags
            muxer.writeSampleData(audioTrack, audioBuf, audioBufferInfo)
            audioExtractor.advance()
        }

        muxer.stop()
        muxer.release()
        videoExtractor.release()
        audioExtractor.release()
        afdd.close()
    } catch (e: Exception) {
        LogUtils.e(TAG, "Mixer Error:" + e.message)
    }
}
Run Code Online (Sandbox Code Playgroud)

归档时间：

查看次数：

320 次

最近记录：

6 年，5 月 前
android - 如何复用音频文件和视频文件？ 7
更多相关链接
相关归档
RelativeLayout比LinearLayout更昂贵吗？ 113
如何在Android项目中从头开始设置DAGGER依赖注入？ 96
如何禁用EditText软件键盘上的"下一步"按钮(替换为"完成"按钮) 82
有没有更好的方法从适配器获取对父级RecyclerView的引用？ 72
TaskStackBuilder和后台堆栈的附加功能 39
完整的Android支持OSGi包 37
将触摸事件从Javascript翻译为jQuery 35
如何以编程方式更改Ubuntu中的卷 25
加速度计低通滤波和高通滤波 - 与音响工程相同吗？ 5
如何使用python获取mp3文件的采样率 4
难疑归档
Dockerfile中的`COPY`和`ADD`命令有什么区别？ 1991
使用pip升级所有包 1859
如何使用对象作为成员循环一个普通的JavaScript对象？ 1521
Markdown中的评论 1277
在文本框中的Enter键上使用JavaScript触发按钮单击 1250
npm在没有sudo的情况下抛出错误 1218
按列名从pandas DataFrame中删除列 1136
什么是Python 3相当于"python -m SimpleHTTPServer" 1124
返回IEnumerable <T>与IQueryable <T> 1051
#Hibernate hbm2ddl.auto配置的可能值是什么,它们做了什么 1046