android - 如何混合(合并)视频和音频，以便音频在持续时间太短的情况下在输出视频中循环播放？

Question

背景

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

1. 输出视频文件的时长与输入视频文件的时长相同
2. 输出文件中的音频将仅来自输入音频文件。如果它太短，它将循环到最后(如果需要可以在最后停止)。这意味着一旦音频播放完而视频还没有播放完，我应该一遍又一遍地播放，直到视频结束(音频的串联)。

这个合并操作的技术术语叫做“muxing”，正如我所读到的。

例如，假设我们有一个 10 秒的输入视频和一个 4 秒的音频文件，输出视频将是 10 秒(始终与输入视频相同)，音频将播放 2.5 次(前 2 秒覆盖前 8 秒，然后 4 秒中的 2 秒用于其余部分)。

问题

虽然我找到了如何混合视频和音频的解决方案 (here)，但我遇到了多个问题:

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)
          }
  

• 为了检查文件类型，我尝试使用 MediaMetadataRetriever 然后检查 mime 类型。我认为支持的那些在文档 ( here ) 上可用，因为那些标有“编码器”。不确定这一点。我也不知道那里提到的哪种 MIME 类型。

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

这是我当前的 muxing 代码(完整的示例项目可用 here):

object VideoAndAudioMuxer {
    //   based on:  https://stackoverflow.com/a/31591485/878126
    @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
    }
}

• 我还尝试使用 FFMPEG 库(here 和 here)，看看如何操作。它运行良好，但有一些可能的问题:该库似乎占用了大量空间，烦人的许可条款，并且出于某种原因，该示例无法播放我必须创建的输出文件，除非我删除了命令会使转换速度变慢。我真的更愿意使用内置的 API 而不是使用这个库，即使它是一个非常强大的库...而且，对于某些输入文件，它似乎没有循环...

问题

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

2. 我该怎么做才能在视频结束时准确地剪切音频(视频和音频都没有残留)？

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

Answer 1

我有同样的场景。

• 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)
    }
}