前语

前文讲到Android音视频开发结构中的上半段：音视频的创立，编码，保存，这个属于音视频资源出产端的进程。在消费端，还需求阅历读取，解码，播映这三个节点。

音视频读取

在前文中，咱们能够打通从摄像头+麦克风-编码数据-保存文件这个进程，假设一切顺利，那么能够在磁盘中保存一个MP4文件。可是想要消费这段影片，首先要做的便是提取文件里的编码过的音频和视频信息。这个工作首要依靠于MediaExtractor类。

MediaExtractor的首要办法如下：

// 设置数据源
mediaExtractor.setDataSource()
// 获取轨迹数（音频轨迹，视频轨迹，字幕轨迹等）
mediaExtractor.getTrackCount()
// 获取该轨迹的格式类型（是音频仍是视频）
mediaExtractor.getTrackFormat()
// 挑选轨迹（确定读取哪个轨迹的数据）
mediaExtractor.selectTrack()
// 读取采样数据到数组
mediaExtractor.readSampleData()
// 进入下一个采样,readSampleData之后需求调用advance推进指针往前移动
mediaExtractor.advance()
// 返回当时轨迹索引
mediaExtractor.getSampleTrackIndex()
// 返回当时采样的显现时刻
mediaExtractor.getSampleTime()
// seek到对应时刻
mediaExtractor.seekTo()
// 开释资源
mediaExtractor.release()

咱们能够把MediaExtrtactor看作是MediaMuxer的逆进程，后者是把音频视频封装写入文件，前者是读取文件，解封装获取独立的音频和视频。

音频和视频别离是独立线程编解码的，那么读取天然在分在两个线程中别离读取互不搅扰。而且由于操作的相似性，咱们能够对它的操作进行一定的封装：

class MExtractor(filePath:String) {
    companion object{
        val EXTRACTOR_TAG = "extractor_tag"
    }
    private var audioTrackIndex = -1
    private var videoTrackIndex = -1
    private val mediaExtractor:MediaExtractor by lazy {
        MediaExtractor()
    }
    init {
        try {
            mediaExtractor.setDataSource(filePath)
        }catch (e:IOException){
            e.printStackTrace()
            Log.e(EXTRACTOR_TAG,"${e.message}")
        }
    }
    // 挑选音频轨迹
    fun selectAudioTrack(){
        val index = getAudioTrack()
        if (index == -1) return
        mediaExtractor.selectTrack(index)
    }
     // 挑选视频轨迹
    fun selectVideoTrack(){
        val index = getVideoTrack()
        if (index == -1) return
        mediaExtractor.selectTrack(index)
    }
    // 读取（对应轨迹的）数据
    fun readSampleData(byteBuf: ByteBuffer,  offset:Int):Pair<Int,Long>{
        //读取一块数据
        val readSize = mediaExtractor.readSampleData(byteBuf, offset)
        // 获取这块数据对应的时刻错
        val sampleTimeValue = mediaExtractor.sampleTime
        //指针往前移动
        mediaExtractor.advance()
        return Pair(readSize,sampleTimeValue)
    }
    ...
    ...
    fun getAudioTrack():Int{
        if (audioTrackIndex != -1){
            return audioTrackIndex
        }
        for (i in 0..mediaExtractor.trackCount) {
            val format = mediaExtractor.getTrackFormat(i)
            if (format.getString(MediaFormat.KEY_MIME)?.startsWith("audio/") == true){
                Log.i(EXTRACTOR_TAG,"selected format: $format  track: $i")
                audioTrackIndex = i
                return i
            }
        }
        return -1;
    }
    fun getVideoTrack():Int{
        if (mediaExtractor.trackCount == 0){
            return -1
        }
        if (videoTrackIndex != -1){
            return videoTrackIndex
        }
        for (i in 0..mediaExtractor.trackCount) {
            val format = mediaExtractor.getTrackFormat(i)
            Log.i(EXTRACTOR_TAG,"video index: $i  format: $format")
            if (format.getString(MediaFormat.KEY_MIME)?.startsWith("video/") == true){
                Log.i(EXTRACTOR_TAG,"format: $format")
                videoTrackIndex = i
                return i
            }
        }
        return -1
    }
}

以上根本上便是MediaExtractor的悉数了，他往往需求合作其他的组件运用。

音视频解码

有了MediaExtractor的协助，咱们现已能够 从文件中获取数据源，接着咱们仍是运用异步形式来敞开解码进程

视频

private val videoHandlerThread: HandlerThread = HandlerThread("video-thread").apply { start() }
private val videoHandler = Handler(videoHandlerThread.looper)
private val mediaExtractor: MExtractor by lazy {
    MExtractor(fileData.filePath)
}
// 异步形式的回调
private val videoCallback = object : CodecCallback() {
    override fun onInputBufferAvailableWrapper(codec: MediaCodec, index: Int) {
        if (isSignalEOF || mediaExtractor.getSampleTrackIndex() == -1) {
            return
        }
        pauseIfNeed()
        val inputBuffer = codec.getInputBuffer(index) ?: return
        inputBuffer.clear()
        // 挑选视频轨迹
        mediaExtractor.selectVideoTrack()
        //读取数据
        // sampleTime 视频的PTS
        var (readSize, sampleTime) = mediaExtractor.readSampleData(inputBuffer, 0)
        if (readSize < 0) {
            inputBuffer.limit(0)
            codec.queueInputBuffer(index, 0, 0, 0, 0)
            isSignalEOF = true
        } else {
            codec.queueInputBuffer(index, 0, readSize, sampleTime, 0)
        }
    }
    override fun onOutputBufferAvailableWrapper(
        codec: MediaCodec, index: Int, info: MediaCodec.BufferInfo
    ) {
        if (isOutputEOF) {
            return
        }
        isOutputEOF = (info.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0
        trySleep(info.presentationTimeUs)
        // index 是解码后的数据缓存空间下标
        // 第二个参数表明是否渲染（假如提早设置了输出端的Surface的话，填true）
        codec.releaseOutputBuffer(index, true)
    }
    ...
    ...
}
...
// configure
mediaExtractor.getVideoFormat()?.let {
    val mime = it.getString(MediaFormat.KEY_MIME)
    mime?.let {m->
        videoDecoder = MediaCodec.createDecoderByType(m)
        // 这个surface来自于播映器（SurfaceView或许TextureView）
        videoDecoder?.configure(it, surface, null, 0)
        videoDecoder?.setCallback(videoCallback, videoHandler)
    }
}
// 开端解码
videoDecoder?.start()
...
...
// release
videoDecoder?.stop()
videoDecoder?.release()

关于视频的解码进程，输出端咱们依然能够运用Surface来简化咱们的输出操作，MediaCodec供给了直接输出数据到Surface的进程，因而咱们把播映端的SurfaceView或许TextureView中的surface传入进来，那么数据就能够直接打通了。

音频

音频的解码进程和视频解码大差不差

private val audioHandlerThread: HandlerThread = HandlerThread("audio-thread").apply { start() }
private val audioHandler = Handler(audioHandlerThread.looper)
private val mediaExtractor: MExtractor by lazy {
    MExtractor(fileData.filePath)
}
// 解码异步形式回调
    private val audioCallback = object : CodecCallback() {
        override fun onInputBufferAvailableWrapper(codec: MediaCodec, index: Int) {
            if (isEOF || mediaExtractor.getSampleTrackIndex() == -1) {
                return
            }
            pauseIfNeed()
            val inputBuffer = codec.getInputBuffer(index) ?: return
            inputBuffer.clear()
            mediaExtractor.selectAudioTrack()
            // 读取采样数据到buffer，获取采样时刻，一起指针向前推进
            // sampleTimeValue便是当时数据的PTS,这个直接从mediaExtractor中获取，从0开端
            val (readSize, sampleTimeValue) = mediaExtractor.readSampleData(inputBuffer, 0)
            if (readSize < 0) {
                codec.queueInputBuffer(index, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM)
                isEOF = true
            } else {
                codec.queueInputBuffer(index, 0, readSize, sampleTimeValue, 0)
            }
        }
        override fun onOutputBufferAvailableWrapper(
            codec: MediaCodec, index: Int, info: MediaCodec.BufferInfo
        ) {
            val outputBuffer = codec.getOutputBuffer(index)
            outputBuffer?.let {
                it.position(info.offset)
                it.limit(info.offset + info.size)
                ...
                // 向音频播映设备写入数据
                ...
            }
            trySleep(info.presentationTimeUs)
            codec.releaseOutputBuffer(index, false) // 重要
        }
    ...
    ...
    }
// configure
mediaExtractor.getAudioFormat()?.let {
    val mime = it.getString(MediaFormat.KEY_MIME) ?: ""
    audioDecoder = MediaCodec.createDecoderByType(mime)
    audioDecoder?.configure(it, null, null, 0)
    audioDecoder?.setCallback(audioCallback, audioHandler)
    Log.i(TAG, "audio inputbuffer mime: $mime")
}
// start
audioDecoder?.start()
...
...
// release
audioDecoder?.stop()
audioDecoder?.release()

音视频播映

音视频播映其实是彻底不同的途径，视频播映依靠TextureView等的view展现，而音频播映则是依靠音频设备。

关于视频而言，咱们需求在UI中刺进TextureView(SurfaceView也相同)，然后在TextureView中设置SurfaceTextureListener，等待SUrface的创立成功，接着把SUrface传入解码器

dataBinding.textureview.surfaceTextureListener = object :SurfaceTextureListener{
    override fun onSurfaceTextureAvailable(
        surfaceTexture: SurfaceTexture,
        width: Int,
        height: Int
    ) {
        Log.i(TAG,"onSurfaceTextureAvailable  $width $height $surfaceTexture")
        val surface = Surface(surfaceTexture)
        startDecodeVideo(surface) // 传入解码模块
        startDecodeAudio() // 一般也能够在此刻触发音频的解码
    }
    override fun onSurfaceTextureSizeChanged(
        surface: SurfaceTexture,
        width: Int,
        height: Int
    ) {
        Log.i(TAG,"onSurfaceTextureSizeChanged  $width $height $surface")
    }
    override fun onSurfaceTextureDestroyed(surfaceTexture: SurfaceTexture): Boolean {
        curSurface?.release()
        Log.i(TAG,"onSurfaceTextureDestroyed   $surfaceTexture")
        return true
    }
    override fun onSurfaceTextureUpdated(surfaceTexture: SurfaceTexture) {
        Log.i(TAG,"onSurfaceTextureUpdated   $surfaceTexture")
    }
}

这样，解码的视频帧就能够显现在textureView上了。

可是音频的播映进程则彻底在后台进行

//  创立音频播映设备
mediaExtractor.getAudioFormat()?.let {
// 初始化装备
    val audioAttr = AudioAttributes.Builder()
        .setContentType(CONTENT_TYPE_MOVIE)
        .setLegacyStreamType(AudioManager.STREAM_MUSIC)
        .setUsage(USAGE_MEDIA)
        .build()
    val sampleRate = it.getInteger(MediaFormat.KEY_SAMPLE_RATE)
    var channelMask = if (it.containsKey(MediaFormat.KEY_CHANNEL_MASK)) {
        it.getInteger(MediaFormat.KEY_CHANNEL_MASK)
    } else {
        null
    }
    var channelCount = 1
    if (it.containsKey(MediaFormat.KEY_CHANNEL_COUNT)) {
        channelCount = it.getInteger(MediaFormat.KEY_CHANNEL_COUNT)
    }
    val channelConfig =
        if (channelCount == 1) AudioFormat.CHANNEL_OUT_MONO else AudioFormat.CHANNEL_OUT_STEREO
    if (channelMask == null) {
        channelMask = channelConfig
    }
    val formatInt = if (it.containsKey(MediaFormat.KEY_PCM_ENCODING)) {
        it.getInteger(MediaFormat.KEY_PCM_ENCODING)
    } else {
        AudioFormat.ENCODING_PCM_16BIT
    }
    val audioFormat = AudioFormat.Builder()
        .setChannelMask(channelMask)
        .setEncoding(formatInt)
        .setSampleRate(sampleRate)
        .build()
    bufferSize = AudioTrack.getMinBufferSize(sampleRate, channelConfig, formatInt)
    // 创立音频播映设备
    audioTrack = AudioTrack(
        audioAttr,
        audioFormat,
        bufferSize,
        AudioTrack.MODE_STREAM,
        audioManager.generateAudioSessionId()
    )
}
//开端播映，和audioDecode.start一起调用即可
audioTrack?.play()
// 在适宜的时机写入音频数据（一般就放在解码完结输出之后写入即可）
audioTrack?.write(...)
// 开释资源
audioTrack?.stop()
audioTrack?.release()

以上便是音频播映设备的运用方式。

你以为这样就结束了么？单纯。

假如按照正常操作视频的解码速度会很快，你会发现视频像走马灯相同播映完了，音频还在播映，因而咱们需求对音视频进行同步。

音视频同步

由于每一帧音频或许视频数据都有PTS,也便是说现已设定好了这一帧数据应该播映的时刻点，而音视频同步要做的便是，当解码出来的帧的时刻戳还没到播映的时刻节点时，咱们需求等待，一向比及播映的时刻节点到来。

音视频同步的办法不止一种，我挑选咱们比较容易了解的一种来描述：挑选一条独立的时刻轴，每次音频或许视频解码出来之后的时刻戳与独立时刻轴的当时时刻戳进行比较，假如大于当时时刻戳，表明该帧数据还没有到展现的时分，需求等待，不然就直接展现。

如何完成呢？比较简略，在开端解码时的时刻设为独立时刻轴的起点startPresentationTimeUs，后续的解码回调中和这个时刻起点进行比较即可

// 开端解码时调用，并记录一下时刻起点
@CallSuper
 override fun start() {
    if (startPresentationTimeUs == -1L){
        startPresentationTimeUs = getMicroSecondTime()
    }
}
protected fun getMicroSecondTime():Long{
    return System.nanoTime()/1000L
}
// 每次准备播映音频或许视频时调用一次，
protected fun trySleep(sampleTime:Long){
    val standAlonePassTime = getMicroSecondTime()-startPresentationTimeUs
    if (sampleTime>standAlonePassTime){
        try {
            val sleepTime = (sampleTime-standAlonePassTime)/1000
            Log.i(TAG,"sleep time $sampleTime  ${sleepTime}ms  $this")
            // 假如时刻不够，就休眠
            Thread.sleep(sleepTime)
        }catch (e:InterruptedException){
            e.printStackTrace()
        }
    }
}

这就完成了一个简略的音视频同步的逻辑了，我信任了解起来没有太大的难度。当然，假如系统有支撑的办法咱们天然不必亲自完成同步逻辑，在Android体系中，有MediaSync能够协助咱们完成音视频播映同步的逻辑，运用起来不算太杂乱，不过它也同样深度嵌套到音视频的解码进程中去了，这个留给咱们去熟悉吧。

除了音视频同步这个重要内容外，其实还有播映/暂停，这个进程也会影响到音视频同步的逻辑，由于播映暂停时，每帧数据的显现时刻戳PTS不会变，可是咱们建立的独立时刻轴的时刻会持续消逝，等恢复之后，在比较时刻戳就彻底错误了，因而咱们需求在暂停和恢复时记录一下暂停的时长，然后在比较时减去这段时刻，又或许直接把独立时刻轴的起点时刻往后移动暂停时长即可。

此外，播映进程中获取预览图，播映进度条等内容也是根本内容，我以为它们并没有比音视频同步更难以了解，因而不一一说明了。

Android当然有支撑较好的播映器能够一起播映音频和视频，而且还能自动协助咱们解码数据，这些我信任咱们是更了解的。

总结

到此，Android的音视频开发结构根本描述完好了，它涵盖了音视频的创立，编码，保存，提取，解码，播映的全进程，当然每个部分仅仅囫囵吞枣的介绍，代码也不是完好，其实这儿里边许多内容都能够单列一章来讲，细节颇多，不过我以为作为一个简介性质的文章深度是够了的，首要侧重于介绍概念和运用办法。后续深入研究还靠自己，自身的水平也有限。