Android 音视频播放器 Demo（二）—— 音频解码与音视频同步

音视频编解码系列目录：

Android 音视频基础知识
Android 音视频播放器 Demo（一）—— 视频解码与渲染
Android 音视频播放器 Demo（二）—— 音频解码与音视频同步
RTMP 直播推流 Demo（一）—— 项目配置与视频预览
RTMP 直播推流 Demo（二）—— 音频推流与视频推流

本篇会介绍音频的解码与渲染、音视频同步以及进度条的实现。

1、音频解码与渲染

Android 播放音频通常有三种方式：

Media Player
Audio Track
OpenSL ES

前两种都是在上层，而我们要采用的 OpenSL ES 是在 Native 层。原因如下：

OpenSL ES 是 C 语言的库，在 NDK 下开发能更好地集成到 Native 应用中
在 Native 层播放音频速度快，延时低，非常适合音视频同步中以音频为准的情况
相比于使用上层 API 的方式，可以减少 Java/Kotlin 频繁的反射调用，比如 Audio Track 播放音频需要解码为 PCM 数据再反射 Java/Kotlin，增加开销

OpenSL ES（Open Sound Library for Embedded Systems）是无授权费、跨平台、针对嵌入式系统精心优化的硬件音频加速 API，是一套针对移动式平台的音频标准。该库都允许使用 C 或 C ++ 来实现高性能，低延迟的音频操作。Android 的 OpenSL ES 库位于 NDK 的 platforms 文件夹内，它的使用通常可以分为如下几步：

创建引擎并获取引擎接口
设置混音器
创建播放器
设置播放回调函数
设置播放器状态为播放状态
手动激活回调函数
释放

前面在讲解初始化解码器时，实际上就同时创建了 VideoChannel 和 AudioChannel，现在来看 AudioChannel 的初始化：

/**
 * 初始化音频数据，主要是计算 PCM 大小的三要素：
 * 1.采样率，如 44100,48000
 * 2.位深/采样格式大小，使用 16 位数据表示每个样本数据
 * 3.声道数
 *
 * 由于压缩的 AAC 数据是 44100、32 位双声道，而安卓手机的音频参数是
 * 16 位的，因此需要进行重采样。AAC 用 32 位是因为算法效率高，但是硬
 * 件设备，诸如安卓手机通常采用 16 位，声卡最大也只采用了 24 位
 */
AudioChannel::AudioChannel(int stream_index, AVCodecContext *avCodecContext)
        : BaseChannel(stream_index, avCodecContext) {
    // 采样率
    out_sample_rate = 44100;
    // 位深，每个 sample 两个字节，16 位
    out_sample_size = av_get_bytes_per_sample(AV_SAMPLE_FMT_S16);
    // 双声道：AV_CH_LAYOUT_STEREO = AV_CH_FRONT_LEFT|AV_CH_FRONT_RIGHT
    nb_out_channels = av_get_channel_layout_nb_channels(AV_CH_LAYOUT_STEREO);
    // 输出缓冲区大小 = 采样率 * 位深 * 声道数 = 44100 * 2 * 2
    out_buffer_size = out_sample_rate * out_sample_size * nb_out_channels;
    // 为输出缓冲区开辟空间
    out_buffer = static_cast<uint8_t *>(malloc(out_buffer_size));
    // 重采样上下文
    swrContext = swr_alloc_set_opts(nullptr,
                                    AV_CH_LAYOUT_STEREO, // 输出的声道类型
                                    AV_SAMPLE_FMT_S16, // 输出采样大小
                                    out_sample_rate, // 输出采样率
                                    avCodecContext->channel_layout, // 输入的声道布局
                                    avCodecContext->sample_fmt, // 输入的采样格式
                                    avCodecContext->sample_rate, // 输入的采样率
                                    0, nullptr);
    // 初始化重采样上下文
    swr_init(swrContext);
}

AudioChannel::~AudioChannel() {
    if (swrContext) {
        swr_free(&swrContext);
    }

    DELETE(out_buffer);
}

然后就是开始播放的时候，在 VideoPlayer 中让 AudioChannel 开始工作：

void VideoPlayer::start() {
    isPlaying = true;

    if (videoChannel) {
        videoChannel->start();
    }
	// 音频通道也开始解码和播放
    if (audioChannel) {
        audioChannel->start();
    }

    pthread_create(&pid_start, nullptr, task_start, this);
}

与 VideoChannel 类似，AudioChannel 也是开启两个线程分别解码和播放：

/**
 * 开启解码和播放线程
 */
void AudioChannel::start() {
    isPlaying = true;

    packets.setEnable(true);
    frames.setEnable(true);

    pthread_create(&pid_decode, nullptr, task_decode_audio, this);
    pthread_create(&pid_play, nullptr, task_play_audio, this);
}

1.1 音频解码

音频解码的代码实际上是跟视频解码几乎一致的，只不过解码出来的 AVFrame 是存放在 AudioChannel 的 AVFrame 队列中：

void *task_decode_audio(void *args) {
    auto audioChannel = static_cast<AudioChannel *>(args);
    audioChannel->decode();
    return nullptr;
}

void AudioChannel::decode() {
    // 由于从队列中取出的 AVPacket 在使用完后直接
    // 就释放了，因此可以放在 while 外复用
    AVPacket *packet = nullptr;
    int result;
    while (isPlaying) {
        // 由于解码速度要快于音视频的渲染/播放速度，因此需要控制
        // frames 队列的入队速度，以防队列过大而撑爆内存
        if (isPlaying && frames.size() > 100) {
            av_usleep(10 * 1000);
            continue;
        }
        // 从队列中取出一个 AVPacket
        result = packets.get(packet);

        // 如果此时已经设置停止播放，则跳出循环
        if (!isPlaying) {
            break;
        }
        // 如果取 AVPacket 失败，可能是因为队列中尚未有
        // AVPacket，继续循环等待 AVPacket 被读取到队列中
        if (!result) {
            continue;
        }

        // 将 AVPacket 发送给解码器
        result = avcodec_send_packet(avCodecContext, packet);
        if (result != 0) {
            break;
        }

        // 从解码器中获取解码后的 AVFrame 存入 frames 队列中，av_frame_alloc()
        // 会在堆区开辟内存空间，使用完毕需要回收
        AVFrame *frame = av_frame_alloc();
        result = avcodec_receive_frame(avCodecContext, frame);
        LOGD("音频解码结果：%d", result);
        if (!result) {
            frames.put(frame);
            // 每当调用 av_read_frame() 时就会对相应的 AVPacket 引用计数加一，
            // 对 AVPacket 的 *data 指向的内存区域的引用计数减 1，减到 0 时会回收
            av_packet_unref(packet);
            // 回收 AVPacket 指针本身
            releaseAVPacket(&packet);
        } else if (result == AVERROR(EAGAIN)) {
            continue;
        } else {
            // 解码失败，但是 AVFrame 有值，需要释放
            if (frame) {
                releaseAVFrame(&frame);
            }
            break;
        }
        LOGD("音频解码，frames 中完成解码的帧数：%d", frames.size());
    }
    av_packet_unref(packet);
    // 对于从 while 循环 break 出来的情况还要再回收一次 AVPacket
    releaseAVPacket(&packet);
}

1.2 音频播放

使用 OpenSL ES 播放音频，先按照如下步骤设置：

/**
 * 播放线程的任务，是配置 OpenSL ES 的引擎与播放器，并在最后触发
 * 回调接口。回调接口触发后会不断地自我回调，每次回调都从 mFrames
 * 队列中取出 AVFrame 将音频数据以及大小存入 OpenSL ES 的播放队列
 */
void AudioChannel::play() {
    SLresult result;
    /*
     * 1.创建引擎对象并获取引擎接口
     */
    // 1.1 创建引擎对象
    result = slCreateEngine(&engineObject, 0, nullptr, 0, nullptr, nullptr);
    if (SL_RESULT_SUCCESS != result) {
        LOGE("创建引擎失败 slCreateEngine error");
        return;
    }
    // 1.2 初始化引擎
    result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
    if (SL_RESULT_SUCCESS != result) {
        LOGE("初始化引擎失败 Realize error");
        return;
    }
    // 1.3 获取引擎接口
    result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineInterface);
    if (SL_RESULT_SUCCESS != result) {
        LOGE("创建引擎接口失败 Realize error");
        return;
    }

    if (engineInterface) {
        LOGD("创建引擎接口 create success");
    } else {
        LOGE("创建引擎接口 create error");
        return;
    }

    /*
     * 2.设置混音器
     */
    // 2.1 创建混音器
    result = (*engineInterface)->CreateOutputMix(engineInterface, &outputMixObject,
                                                 0, nullptr, nullptr);
    if (SL_RESULT_SUCCESS != result) {
        LOGE("创建混音器失败 CreateOutputMix failed");
        return;
    }
    // 2.2 初始化混音器
    result = (*engineObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE);
    if (SL_RESULT_SUCCESS != result) {
        LOGE("初始化混音器失败 (*outputMixObject)->Realize failed");
        return;
    }
    // 2.3 设置混音器接口，这步可选
    result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_ENVIRONMENTALREVERB,
                                              &environmentalReverb);
    if (SL_RESULT_SUCCESS == result) {
        (*environmentalReverb)->SetEnvironmentalReverbProperties(environmentalReverb, &settings);
    }

    /*
     * 3.创建播放器
     */
    // 3.1 配置输入声音的信息
    // 创建两个缓冲队列
    SLDataLocator_AndroidSimpleBufferQueue loc_buf_queue = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE,
                                                            10};
    // 设置 PCM 数据格式
    SLDataFormat_PCM format_pcm = {SL_DATAFORMAT_PCM, 2, // PCM 格式，双声道
                                   SL_SAMPLINGRATE_44_1, // 采样率为 44100
                                   SL_PCMSAMPLEFORMAT_FIXED_16, // 采样格式为 16 位
                                   SL_PCMSAMPLEFORMAT_FIXED_16, // 数据大小为 16 位
                                   SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT, // 左右声道
                                   SL_BYTEORDER_LITTLEENDIAN}; // 小端模式
    // 将以上配置信息存入数据源以便后续使用
    SLDataSource audioSrc = {&loc_buf_queue, &format_pcm};
    // 3.2 配置音轨
    // 设置混音器，SL_DATALOCATOR_OUTPUTMIX 为混音器类型
    SLDataLocator_OutputMix loc_outMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject};
    SLDataSink audioSink = {&loc_outMix, nullptr};
    // 操作队列的接口
    const SLInterfaceID ids[1] = {SL_IID_BUFFERQUEUE};
    const SLboolean req[1] = {SL_BOOLEAN_TRUE};
    // 3.3 创建播放器
    result = (*engineInterface)->CreateAudioPlayer(engineInterface, // 引擎接口
                                                   &bqPlayerObject, // 播放器
                                                   &audioSrc, // 音频配置信息
                                                   &audioSink, // 混音器
                                                   1, // 回调接口个数为 1
                                                   ids, // 播放队列 ID
                                                   req); // 使用内置播放
    if (SL_RESULT_SUCCESS != result) {
        LOGE("创建播放器失败 CreateAudioPlayer failed!");
        return;
    }
    // 3.4 初始化播放器
    result = (*bqPlayerObject)->Realize(bqPlayerObject, SL_BOOLEAN_FALSE);
    if (SL_RESULT_SUCCESS != result) {
        LOGE("实例化播放器失败 CreateAudioPlayer failed!");
        return;
    }
    // 3.5 获取播放器接口
    result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_PLAY, &bqPlayerPlay);
    if (SL_RESULT_SUCCESS != result) {
        LOGE("获取播放接口失败 GetInterface SL_IID_PLAY failed!");
        return;
    }

    /*
     * 4.设置播放回调函数
     */
    // 4.1 获取播放器队列接口
    result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_BUFFERQUEUE,
                                             &bqPlayerBufferQueue);
    if (result != SL_RESULT_SUCCESS) {
        LOGE("获取播放队列 GetInterface SL_IID_BUFFERQUEUE failed!");
        return;
    }
    // 4.2 设置回调
    (*bqPlayerBufferQueue)->RegisterCallback(bqPlayerBufferQueue, bqPlayerCallback, this);
    LOGD("播放器回调函数设置成功");

    /*
     * 5.设置播放器为播放状态
     */
    (*bqPlayerPlay)->SetPlayState(bqPlayerPlay, SL_PLAYSTATE_PLAYING);

    /*
     * 6.手动激活回调函数
     */
    bqPlayerCallback(bqPlayerBufferQueue, this);
    LOGD("音频播放器创建成功！");
}

4.2 步骤设置了播放器回调 bqPlayerCallback，在第 6 步中又手动激活这个回调，它需要不断将音频数据添加到 OpenSL 的队列中：

/**
 * 回调函数，将每一帧音频数据存入 bq 队列中
 */
void bqPlayerCallback(SLAndroidSimpleBufferQueueItf bq, void *args) {
    auto audioChannel = static_cast<AudioChannel *>(args);
    // 获取 PCM 格式数据的大小
    int pcm_size = audioChannel->getPCMSize();
    // 添加 PCM 数据到播放器队列中
    (*bq)->Enqueue(bq, audioChannel->out_buffer, pcm_size);
}

将音频帧存入队列时，需要计算 PCM 的大小并传入：

/**
 * 从 AVFrame 队列中取出一个 AVFrame，对其进行重采样并将数据
 * 存入 out_buffer，同时获取重采样后的数据大小
 */
int AudioChannel::getPCMSize() {
    int pcm_data_size = 0;
    AVFrame *frame = nullptr;
    bool result;
    while (isPlaying) {
        result = frames.get(frame);
        if (!isPlaying) {
            break;
        }
        if (!result) {
            continue;
        }

        // 重采样，因为输入的音频频率可能有多种，如 48000，而输出音频需要统一为 44100，
        // 假如输入的是 10 个 48000，那么输出为 44100 时就需要 10 * 48000 / 44100 = 10.88 ≈ 11
        int dst_nb_samples = av_rescale_rnd(
                swr_get_delay(swrContext, frame->sample_rate) + frame->nb_samples,
                frame->sample_rate, // 输入采样率
                out_sample_rate, // 输出采样率
                AV_ROUND_UP); // 向上取整
        int samples_per_channel = swr_convert(swrContext,
                                              &out_buffer, // 重采样后的输出数据保存在 out_buffer 中
                                              dst_nb_samples, // 输出的单通道样本数
                                              (const uint8_t **) (frame->data), // 输入的未重采样的 PCM 数据
                                              frame->nb_samples); // 输入的样本数

        // 计算重采样后的 PCM 数据大小
        pcm_data_size = out_sample_size * samples_per_channel * nb_out_channels;
        break;
    }
    av_frame_unref(frame);
    releaseAVFrame(&frame);
    return pcm_data_size;
}

2、音视频同步

现在是音频和视频各自播放各自的，从解码后的 AVFrame 队列中取出一帧就渲染了，因此出现音画不同步的情况很正常，现在需要想个办法让音视频同步。

音视频同步解决方案：

以音频为准：音频只管正常播放，视频通过延时或丢帧等方式与音频同步
以视频为准：视频画面每次循环不变，音频根据视频来延迟或等待
自定义时间为准：设定开始加载视频的时间为 0，后续的音频帧与视频帧依赖自定义时间进行同步

2.1 FFmpeg 的时间戳

FFmpeg 中有两个时间戳概念 DTS 与 PTS：

DTS（Decoding Time Stamp）解码时间戳，告诉解码器 AVPacket 的解码顺序
PTS（Presentation Time Stamp）显示时间戳，指示 AVPacket 中解码出来的数据显示的顺序

在没有 B 帧的情况下，DTS 和 PTS 的输出顺序是一样的。因为 B 帧打乱了解码和显示的顺序（要解码 B 帧需要先解码后面的 P 帧），所以一旦存在 B 帧，PTS 和 DTS 就会不同：

2024-1-7.GOP与DTS与PTS

也就是说，在音频中，DTS 与 PTS 相同。但是在视频中，由于可能存在 B 帧，所以 DTS 与 PTS 不一定相同。比如在一个帧序列中，先解码出 I 帧，然后解码出 P 帧，最后才解码出多个 B 帧。但是在显示时，顺序必须是 I、B、B、P 才是（B 是双向预测帧，参考前面的 I 帧与后面的 I/P 帧），这样 DTS 与 PTS 就不同。

实现音视频同步要基于 PTS，PTS 中有一个时间基 time_base 的概念，实际上是一个时间刻度，定义在 AVStream -> AVCodecContext 中：

	/**
     * 以秒为单位表示帧时间戳的基本时间单位
     * 对于固定帧速率的内容，时间基应为 1/帧速率，时间戳增量应为 1。
     * 对于视频来说，这通常是帧速率或场率的倒数，但并不总是如此。
     * 如果帧速率不是恒定的，1/time_base 不是平均帧速率。
     * - 编码：必须由用户设置。
     * - 解码：不推荐将此字段用于解码。请使用帧速率（framerate）代替。
     */
    AVRational time_base;

AVRational 表示音视频相关的有理数，num 字段是分子，den 字段是分母：

/**
 * Rational number (pair of numerator and denominator).
 */
typedef struct AVRational{
    int num; ///< Numerator
    int den; ///< Denominator
} AVRational;

AVRational 可以表示帧率，num 表示每秒的帧数，den 表示帧率的分母，25 就表示 25 帧/秒，那么对应的时间基就是 1/25 = 0.04 秒。

AVRational 还可以表示音频采样率，num 表示每秒的采样数，den 表示采样率的分母，44100 表示 44.1 kHz 的采样率，那么对应的时间基就是 1/44100 ≈ 22.68 微秒。

当你获取到媒体流对象后，可以直接获取其时间基：

AVRational time_base = stream->time_base;

也可以通过平均帧率计算出时间基：

// 获取平均帧率
AVRational frame_rate = stream->avg_frame_rate;
// 计算帧率
int fps = frame_rate.num / frame_rate.den;
// 或者也可以使用现成的方法，一样的
fps = av_q2d(frame_rate);
// 帧率取倒数就是帧率的时间基
float time_base = 1.0 / fps;

2.2 代码实现

在 Native 的 VideoPlayer 执行准备工作时，打开流的解码器之后，就可以获取这个流的时间基，在创建 Channel 时将时间基传入。视频通道还要追加帧率，这些都是音视频同步所需的参数：

void VideoPlayer::prepareInChildThread() {
    ...
    /*
     * 3.打开解码器，对音视频流分别创建对应的处理通道
     */
    // 编解码器上下文
    AVCodecContext *avCodecContext = nullptr;
    for (int i = 0; i < avFormatContext->nb_streams; ++i) {
        ...
    	// 获取流的时间基，音视频同步需要
        AVRational time_base = stream->time_base;
        // 3.5 根据媒体流的类型创建对应的处理通道
        if (codecParameters->codec_type == AVMEDIA_TYPE_VIDEO) {
            // 有的视频类型只有一帧封面图片，这种情况需要跳过
            if (stream->disposition & AV_DISPOSITION_ATTACHED_PIC) {
                continue;
            }
            // 计算帧率供音视频同步使用
            AVRational avg_frame_rate = stream->avg_frame_rate;
            // 将 AVRational 换算为 double 再取整数
            int fps = av_q2d(avg_frame_rate);
            // 创建视频通道
            videoChannel = new VideoChannel(i, avCodecContext, time_base, fps);
            videoChannel->setRenderCallback(renderCallback);
        } else if (codecParameters->codec_type == AVMEDIA_TYPE_AUDIO) {
            // 创建音频通道
            audioChannel = new AudioChannel(i, avCodecContext, time_base);
        } else if (codecParameters->codec_type == AVMEDIA_TYPE_SUBTITLE) {
            // 创建字幕通道...省略
        }
    }
    ...
}

由于我们采用以音频为准的同步方案，因此 VideoChannel 需要持有 AudioChannel 以获取音频播放的时间戳：

void VideoPlayer::start() {
    ...

    // 如果音视频流都存在，就让视频通道持有音频通道，以便做音频为准的音视频同步
    if (videoChannel && audioChannel) {
        videoChannel->setAudioChannel(audioChannel);
    }

    pthread_create(&pid_start, nullptr, task_start, this);
}

现在我们拿到音频播放的时间戳了，要考虑一些同步的实现细节：

如果视频播放进度比音频快，需要让视频延时，时长是每一帧的时长加上解码这一帧所需要的时间，手机配置好解码时间就短一些
如果视频播放进度比音频慢，视频需要追赶，如果差距过大就什么都不做，让其自然追赶是最快的方式；如果差距不大，可以考虑以丢帧的方式进行追赶
丢帧的时候要考虑是丢弃 AVPacket 还是 AVFrame，因为 AVPacket 是区分关键帧和非关键帧的，我们丢帧只能丢非关键帧。AVFrame 则没有关键帧的问题，它每一帧都是一个完整的画面

在 VideoChannel 的 play() 中，拿到 AVFrame 的图像数据回调给渲染接口之前，要比对音视频播放时间戳，如果视频比音频播的快就延时一段时间再做渲染回调。反之，视频播放比音频慢，如果差距不大可以采用丢帧的方式让视频追赶音频播放，否则不加干涉让视频自然追赶音频：

void VideoChannel::play() {
    ...
    AVFrame *frame = nullptr;
    int result;
    while (isPlaying) {
        result = frames.get(frame);
        if (!isPlaying) {
            break;
        }
        if (!result) {
            continue;
        }

        // 执行 YUV -> RGBA 转换，转换后的数据保存在 dst_data 和 dst_lineSize 中
        sws_scale(swsContext, frame->data, frame->linesize, 0,
                  avCodecContext->height, dst_data, dst_lineSize);

        /*
         * 音视频同步，计算每一帧视频应该延时还是丢帧
         */
        // 先计算每一帧的延时时间
        double fps_delay = 1.0 / fps;
        // 再计算每一帧解码所耗费的时间，repeat_pict 是编码器指定的
        double extra_delay = frame->repeat_pict / (2 * fps);
        double delay = fps_delay + extra_delay;

        // 获取音视频的时间戳并进行比较
        double video_time = frame->pts * av_q2d(time_base);
        double audio_time = audioChannel->audio_time;
        double time_diff = video_time - audio_time;

        // 根据 time_diff 决定视频应该延时还是丢帧
        if (time_diff > 0) {
            // 视频超前，需要给视频设置延时
            if (time_diff > 1) {
                // 如果视频远远快于音频，你不能也睡眠相应的时间，否则视频可能会“定格”，
                // 最长的睡眠时间设置为 delay 的 2 倍
                av_usleep(delay * 2 * 1000000);
            } else {
                // 差距在 0 ~ 1 之间，可以根据实际差值睡眠
                av_usleep((delay + time_diff) * 1000000);
            }
        } else if (time_diff < 0) {
            // 视频播放慢于音频，需要丢帧以追赶音频。根据经验值，当差值绝对值在 0.05
            // 以内时，丢包不会对视频播放产生严重影响（人对视频没有音频敏感）
            if (fabs(time_diff) <= 0.05) {
                // 同步丢包
                frames.sync();
                // 丢完取下一个包
                continue;
            }
        } else {
            LOGD("同步：当前处于完全同步状态");
        }

        renderCallback(dst_data[0], avCodecContext->width, avCodecContext->height, dst_lineSize[0]);
        // 释放 AVFrame
        av_frame_unref(frame);
        releaseAVFrame(&frame);
    }
    ...
}

丢帧策略是 SafeQueue 交给外界定制的：

template<class T>
class SafeQueue {
    // 同步时丢弃队列中视频包的回调
    typedef void (*SyncCallback)(std::queue<T> &);
public:
	void sync() {
        pthread_mutex_lock(&mutex);
        syncCallback(queue);
        pthread_mutex_unlock(&mutex);
    }
    
    void setSyncCallback(SyncCallback callback) {
        syncCallback = callback;
    }
}

VideoChannel 在初始化时对 packets 和 frames 两个队列设置了回调：

void dropAVPackets(std::queue<AVPacket *> &packets) {
    while (!packets.empty()) {
        AVPacket *packet = packets.front();
        if (packet->flags != AV_PKT_FLAG_KEY) {
            BaseChannel::releaseAVPacket(&packet);
            packets.pop();
        } else {
            break;
        }
    }
}

void dropAVFrames(std::queue<AVFrame *> &frames) {
    if (!frames.empty()) {
        AVFrame *frame = frames.front();
        BaseChannel::releaseAVFrame(&frame);
        frames.pop();
    }
}

VideoChannel::VideoChannel(int stream_index, AVCodecContext *avCodecContext, AVRational time_base,
                           int fps)
        : BaseChannel(stream_index, avCodecContext, time_base), fps(fps) {
    packets.setSyncCallback(dropAVPackets);
    frames.setSyncCallback(dropAVFrames);
}

当然你可以看到，两个队列的丢帧策略并不相同，因为 AVPacket 是区分关键帧与非关键帧的，丢帧时不能丢关键帧，否则画面渲染会受到影响。而 AVFrame 是解码后完整的一帧画面，没有关键帧与非关键帧之说，可以直接丢弃。

3、进度条

分两步，首先要正常显示进度，其次拖动进度条要跳转到相应的时间戳上。

3.1 显示进度

想让界面显示进度条，必须先从上层调用 Native 方法查询视频的时长，成功获取后才显示进度条：

class MainActivity : AppCompatActivity() {
    private var duration = 0
    private var isTouch = false
        
    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        videoPlayer.setOnPreparedListener(object : VideoPlayer.OnPreparedListener {
            override fun onPrepared() {
                duration = videoPlayer.nativeGetDuration()
                runOnUiThread {
                    if (duration > 0) {
                        setProgressTime(0, duration)
                        binding.seekBar.visibility = View.VISIBLE
                        binding.tvTime.visibility = View.VISIBLE
                    }
                    Toast.makeText(this@MainActivity, "准备就绪", Toast.LENGTH_LONG).show()
                }
                videoPlayer.start()
            }
        })
        ...
    }
    
    private fun setProgressTime(progress: Int, duration: Int) {
        binding.tvTime.text =
            String.format("%s / %s", getTimeString(progress), getTimeString(duration))
    }

    private fun getTimeString(timeInSecond: Int): String {
        val second = timeInSecond % 60
        val minute = timeInSecond / 60
        val hour = timeInSecond / 3600
        return if (hour > 1) {
            String.format("%d:%02d:%02d", hour, minute, second)
        } else {
            String.format("%02d:%02d", minute, second)
        }
    }
}

VideoPlayer 的 nativeGetDuration() 去获取 Native 层查询到的视频时长：

void VideoPlayer::prepareInChildThread() {
    ...
    /*
     * 2.查找媒体中的音视频流信息存入 AVFormatContext
     */
    ...

    // 获取视频的时长信息
    duration = avFormatContext->duration / AV_TIME_BASE;
    ...
}

int VideoPlayer::getDuration() {
    return duration;
}

这样可以显示出进度条和总时间，但是进度条与当前时长不会更新。要实现这个需要在 AudioChannel 的 getPCMSize() 取出 AVFrame 时计算出音频的时间戳并回调给上层。

Native 回调上层还是借助 JNICallbackHelper：

JNICallbackHelper::JNICallbackHelper(JavaVM *jvm, JNIEnv *jEnv, jobject jObj) {
    javaVM = jvm;
    jniEnv = jEnv;
    // jobject 默认不能跨越线程和函数，必须声明为全局引用才可以
    jObject = jEnv->NewGlobalRef(jObj);
    // 反射获取上层方法对象需要方法所在的类对象
    jclass clazz = jEnv->GetObjectClass(jObject);
    // 获取要反射的方法 ID
    ...
    onProgressId = jEnv->GetMethodID(clazz, "onProgress", "(I)V");
}

void JNICallbackHelper::onProgress(int thread_mode, int progress) {
    if (thread_mode == MAIN_THREAD) {
        // 在主线程中，可以直接使用主线程的 JNIEnv 调用上层方法
        jniEnv->CallVoidMethod(jObject, onProgressId, progress);
    } else {
        // 在子线程中，需要先获取子线程的 JNIEnv 再调用上层方法
        JNIEnv *childEnv;
        javaVM->AttachCurrentThread(&childEnv, nullptr);
        childEnv->CallVoidMethod(jObject, onProgressId, progress);
        javaVM->DetachCurrentThread();
    }
}

AudioChannel 通过 JNICallbackHelper 将时间戳回调给上层：

int AudioChannel::getPCMSize() {
    int pcm_data_size = 0;
    AVFrame *frame = nullptr;
    bool result;
    while (isPlaying) {
        result = frames.get(frame);
        if (!isPlaying) {
            break;
        }
        if (!result) {
            continue;
        }

        // 重采样，因为输入的音频频率可能有多种，如 48000，而输出音频需要统一为 44100，
        // 假如输入的是 10 个 48000，那么输出为 44100 时就需要 10 * 48000 / 44100 = 10.88 ≈ 11
        int dst_nb_samples = av_rescale_rnd(
                swr_get_delay(swrContext, frame->sample_rate) + frame->nb_samples,
                frame->sample_rate, // 输入采样率
                out_sample_rate, // 输出采样率
                AV_ROUND_UP); // 向上取整
        int samples_per_channel = swr_convert(swrContext,
                                              &out_buffer, // 重采样后的输出数据保存在 out_buffer 中
                                              dst_nb_samples, // 输出的单通道样本数
                                              (const uint8_t **) (frame->data), // 输入的未重采样的 PCM 数据
                                              frame->nb_samples); // 输入的样本数

        // 计算重采样后的 PCM 数据大小
        pcm_data_size = out_sample_size * samples_per_channel * nb_out_channels;

        // 计算准确的音频时间戳，如果编码器不能提供准确时间戳，就采用 frame->best_effort_timestamp 计算
        audio_time = frame->pts * av_q2d(time_base);
        if (jniCallbackHelper) {
            jniCallbackHelper->onProgress(CHILD_THREAD, audio_time);
        }
        break;
    }
    av_frame_unref(frame);
    releaseAVFrame(&frame);
    return pcm_data_size;
}

上层的接收方法还是在 VideoPlayer 中：

	private var onProgressListener: OnProgressListener? = null

	fun onProgress(progress: Int) {
        onProgressListener?.onProgress(progress)
    }

	fun setOnProgressListener(onProgressListener: OnProgressListener) {
        this.onProgressListener = onProgressListener
    }

	interface OnProgressListener {
        fun onProgress(progress: Int)
    }

UI 设置 OnProgressListener 更新进度条和时间：

	override fun onCreate(savedInstanceState: Bundle?) {
        ...
        videoPlayer.setOnProgressListener(object : VideoPlayer.OnProgressListener {
            override fun onProgress(progress: Int) {
                if (!isTouch) {
                    runOnUiThread {
                        binding.seekBar.progress = progress * 100 / duration
                        setProgressTime(progress, duration)
                    }
                }
            }
        })
        ...
    }

3.2 拖拽进度条

拖动进度条将视频跳转到对应的时间戳上，首先为 SeekBar 设置监听，在发生拖动事件时将进度传递给 Native 层：

class MainActivity : AppCompatActivity(), SeekBar.OnSeekBarChangeListener {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        binding.seekBar.setOnSeekBarChangeListener(this)
        ...
    }
    
    // SeekBar.OnSeekBarChangeListener start
    override fun onProgressChanged(seekBar: SeekBar?, progress: Int, fromUser: Boolean) {
        if (fromUser) {
            setProgressTime(progress * duration / 100, duration)
        }
    }

    override fun onStartTrackingTouch(seekBar: SeekBar?) {
        isTouch = true
    }

    override fun onStopTrackingTouch(seekBar: SeekBar?) {
        isTouch = false
        seekBar?.let {
            videoPlayer.seek(it.progress * duration / 100L)
        }
    }
    // SeekBar.OnSeekBarChangeListener end
}

VideoPlayer 执行 Native 的 seek 函数：

	fun seek(progress: Long) {
        nativeSeek(progress)
    }

	private external fun nativeSeek(progress: Long)

native-lib 将 seek 请求交给 Native 的 VideoPlayer：

extern "C"
JNIEXPORT void JNICALL
Java_com_video_player_VideoPlayer_nativeSeek(JNIEnv *env, jobject thiz, jlong progress) {
    if (videoPlayer) {
        videoPlayer->seek(progress);
    }
}

VideoPlayer 通过 FFmpeg 的 av_seek_frame() 执行 seek 操作，同时将 VideoChannel 和 AudioChannel 的 AVPacket 队列和 AVFrame 队列清空再重新接收解码帧：

VideoPlayer::VideoPlayer(const char *data_source, JNICallbackHelper *helper) {
    // 由于参数传入的 data_source 指针在调用完当前构造函数后会被回收，
    // 为了避免 dataSource 成为悬空指针，需要对 data_source 进行深拷贝，
    // 声明 char 数组时不要忘记为 \0 预留出一个字节的空间
    dataSource = new char[strlen(data_source) + 1];
    strcpy(dataSource, data_source);

    jniCallbackHelper = helper;

    pthread_mutex_init(&seek_mutex, nullptr);
}

VideoPlayer::~VideoPlayer() {
    pthread_mutex_unlock(&seek_mutex);
}

void VideoPlayer::seek(long progress) {
    if (progress < 0 || progress > duration) {
        return;
    }
    if (!audioChannel && !videoChannel) {
        return;
    }
    if (!avFormatContext) {
        return;
    }

    pthread_mutex_lock(&seek_mutex);

    // 通过 av_seek_frame() 传入 progress 实现播放对应的帧，但是需要注意，由于该函数会修改 mAVFormatContext
    // 中的内容，而我们处于多线程环境中，需要使用同步以保证 AVFormatContext 内容的线程安全
    // 流的位置传 -1 会让 FFmpeg 自动选择是音频流还是视频流进行 seek
    // 最后一个参数是标记位，有四种选择：
    // AVSEEK_FLAG_BACKWARD（向后参考关键帧）、AVSEEK_FLAG_BYTE、AVSEEK_FLAG_ANY（精确到指定帧）、
    // AVSEEK_FLAG_FRAME（找关键帧，可能你指定的帧与关键帧相隔很多帧，单独使用可能不准确，会与其他模式配合使用）
    // 如果使用 AVSEEK_FLAG_ANY 模式，会 seek 到你指定的帧，但是由于该帧有可能不是关键帧，会出现花屏的情况
    int result = av_seek_frame(avFormatContext, -1, progress * AV_TIME_BASE,
                               AVSEEK_FLAG_BACKWARD | AVSEEK_FLAG_FRAME);
    if (result < 0) {
        LOGE("seek 失败");
        pthread_mutex_unlock(&seek_mutex);
        return;
    }

    // 清除队列中存有的帧，停止播放，跳转到新的位置后再开启
    // 队列接收新位置读取的 AVPacket 和解码后的 AVFrame
    if (audioChannel) {
        audioChannel->packets.setEnable(false);
        audioChannel->frames.setEnable(false);
        audioChannel->packets.clear();
        audioChannel->frames.clear();
        audioChannel->packets.setEnable(true);
        audioChannel->frames.setEnable(true);
    }

    if (videoChannel) {
        videoChannel->packets.setEnable(false);
        videoChannel->frames.setEnable(false);
        videoChannel->packets.clear();
        videoChannel->frames.clear();
        videoChannel->packets.setEnable(true);
        videoChannel->frames.setEnable(true);
    }

    pthread_mutex_unlock(&seek_mutex);
}