Android源码第十六章:MediaPlayer 与 MediaCodec——点下播放后,画面和声音怎样到达设备

0 阅读19分钟

本地视频点下播放,onPrepared 很快到了,屏幕却还黑着。onPrepared 到了,应用就可以调用 start()。画面出现前,播放器还要取样、解码、排期,显示系统再合成图层。 解码后的图像经 Surface 送到显示系统,音频采样经 AudioTrack 送到音频系统。播放器用媒体时钟协调两路的输出时间。

手指点下横屏手机上的播放键,画面里的湖面泛起涟漪,手机边缘画出两道声波

用一段本地、未加密的 MP4 跟踪这条链。视频是 H.264,音频是 AAC。应用打开文件,把文件描述符和 SurfaceView 的 Surface 交给 MediaPlayer。播放器负责拆轨、选择解码器和安排输出。想控制每个压缩样本何时送入、解码结果何时交还时,可以换用 MediaExtractor 和 MediaCodec,亲手接过这些步骤。

16.1 让播放器接管一个本地文件

先在主线程创建并持有一个 MediaPlayer,等 SurfaceHolder.Callback.surfaceCreated 后再开始下面的操作。这里的 file 是应用可以读取的 MP4 文件,surface 是回调里拿到的 holder.surface。

val player = MediaPlayer()
player.setSurface(surface)
FileInputStream(file).use { input ->
    player.setDataSource(input.fd)
}
player.setOnPreparedListener { it.start() }
player.prepareAsync()

setSurface() 指定视频的出口。文件描述符交接成功后,应用可以关闭自己的 FileInputStream。Android 的播放器实现会留住后续读取所需的文件引用,16.3 节会看到具体的 dup(fd)。页面或 Surface 销毁时释放播放器,保留实例的界面代码见 16.7 节。

同一份 MP4 里有三样东西要先分清。容器描述有哪些轨道以及样本的位置。样本是从轨道取出的压缩数据,送给相应解码器。展示时间戳(PTS) 说明这份内容应该在媒体的哪个时刻呈现。播放器按轨道供给样本,Renderer 再用 PTS 和播放时钟决定输出时机。

16.2 先分清播放器、解码器和输出设备

本地 MP4 播放架构,展示应用、Android Framework、Native 媒体与系统服务、硬件接口和设备边界

应用通过 Java Framework 的 MediaPlayer 发出请求。JNI 进入应用进程内的 Native MediaPlayer,再经 Binder 到 mediaserver 的 MediaPlayerService。NuPlayer 组织播放,Extractor 拆容器,MediaCodec 统一客户端的编解码接口。选中了 Codec2 组件时,CCodec 负责对接这个组件。

解出什么和交到哪里是两个问题。 视频解码得到图像,按时间交给 Surface,之后还有 SurfaceFlinger 和显示路径。音频解码得到 PCM,交给 AudioTrack 后继续经 AudioFlinger 和输出流。软件 H.264 解码器可以在 CPU 上工作,画面最后仍能通过设备的显示路径输出。

本地 MP4 核心总时序,从设置文件、异步准备、拆轨解码到音视频输出、EOS 和释放

顺着时序看三处交接。第一,prepareAsync() 的返回和准备结果回调是两次交接。第二,解码完成和 Renderer 决定何时输出之间还有排队。第三,流结束信号(End of Stream,EOS)要沿输出方向传到 Renderer,应用收到完成回调后仍要管理播放器的生命周期。

下面的源码摘要以本地 frameworks/base 和 frameworks/av 固定提交为准。片段标有省略的地方只保留正在讨论的分支,文末链接指向对应源码。

16.3 从文件描述符到带时间戳的样本

应用交出文件,服务保存自己的引用

android_media_MediaPlayer.cpp 的 android_media_MediaPlayer_setDataSourceFD 从 Java FileDescriptor 取出整数 fd,再调用应用进程中的 Native MediaPlayer::setDataSource。后者找到名为 media.player 的服务,先建立播放器的 Binder 会话,再传文件范围。

// MediaPlayer::setDataSource(int fd, int64_t offset, int64_t length),节选
status_t err = UNKNOWN_ERROR;
const sp<IMediaPlayerService> service(getMediaPlayerService());
if (service != 0) {
    sp<IMediaPlayer> player(service->create(this, mAudioSessionId, mAttributionSource));
    if ((NO_ERROR != doSetRetransmitEndpoint(player)) ||
        (NO_ERROR != player->setDataSource(fd, offset, length))) {
        player.clear();
    }
    err = attachNewPlayer(player);
}
return err;

service->create(this, …) 把客户端回调对象交给服务,返回本次专用的 IMediaPlayer。接着 BpMediaPlayer::setDataSource 用 Parcel::writeFileDescriptor(fd) 传文件引用,同时写入 offset 和 length。接收进程得到本进程可用的文件描述符,两个进程里的整数值可以不同。

到服务端,MediaPlayerService::Client::setDataSource 选出并调用对应的播放器实现。本文的实现是 NuPlayerDriver。它把工作交给 NuPlayer::setDataSourceAsync,再等状态离开 STATE_SET_DATASOURCE_PENDING。所以对应用而言,这一次 setDataSource(fd) 仍是同步交接。在 NuPlayer::setDataSourceAsync 创建的 GenericSource 里,可以看到文件为什么还能接着读。

// NuPlayer::GenericSource::setDataSource,节选
resetDataSource();

mFd.reset(dup(fd));
mOffset = offset;
mLength = length;

// delay data source creation to prepareAsync() to avoid blocking
// the calling thread in setDataSource for any significant time.
return OK;

mFd 保存服务侧复制出的 fd,mOffset 和 mLength 则把后续读取限制在这次选择的文件范围内。这里只登记来源,打开数据源和识别轨道延后到准备阶段。这样可以把读取和解析的等待留给后续异步过程。

准备线程拆容器,回调再回应用

示例先设 Surface,再创建服务端播放器会话。JNI 的 setVideoSurface 先在客户端保存输出端点。此时 Native 客户端还没有 mPlayer,第一次提交返回 NO_INIT。JNI 进入 prepareAsync() 时会再向已经建好的会话提交一次 Surface,然后才触发准备。Binder 上传递视频输出端点的具体形式受源码中的图形功能开关影响。

prepareAsync() 经过 Native Client 送到服务,再由 NuPlayer 的消息循环把准备交给 GenericSource。在本文的普通文件路径上,远程提取默认开启。GenericSource::onPrepareAsync 优先请 MediaExtractorService 用复制的 fd 创建 IDataSource。该步骤拿不到数据源时,会退回本进程的 PlayerServiceFileSource。之后 initFromDataSource 将已选的数据源交给 MediaExtractorFactory::Create。创建数据源与创建 Extractor 是两次不同的交接。

// MediaExtractorFactory::Create,远程分支节选
sp<IBinder> binder = defaultServiceManager()->getService(String16("media.extractor"));
if (binder != 0) {
    sp<IMediaExtractorService> mediaExService(
            interface_cast<IMediaExtractorService>(binder));
    sp<IMediaExtractor> ex;
    mediaExService->makeExtractor(
            CreateIDataSourceFromDataSource(source),
            mime ? std::optional<std::string>(mime) : std::nullopt,
            &ex);
    return ex;
}

服务依据容器格式选中 MP4 Extractor。它按样本表定位读取,GenericSource 取得轨道格式和样本,再给音视频轨道各自准备样本队列。在 readBuffer 的普通读取分支,mediaBufferToABuffer 将当前样本变成播放器侧的缓冲对象,queueAccessUnit 把它交给对应轨道的队列。Decoder 从队列取数据时,也取走随样本保存的 PTS。这条路径可以发生样本拷贝,是否跨进程和是否拷贝应分别判断。

本地轨道启动成功后,GenericSource::finishPrepareAsync 通知准备完成。结果经 NuPlayer、NuPlayerDriver::notifyPrepareCompleted、IMediaPlayerClient 回到应用的 Native 客户端,再由 JNI 的 postEventFromNative 投给 Java EventHandler。示例在主线程创建播放器,所以应用的 onPrepared 在主线程收到。服务若在异步准备时发现错误,会经同一条回调通道上报 OnErrorListener,应同时回查文件权限、容器格式和服务能否建立 Extractor。

16.4 从压缩样本到 Codec2 输出 buffer

播放流程图,展示准备成功或失败、样本等待与输入 EOS、输出处理和播放完成

start() 之后,NuPlayer 开始为解码和输出安排工作,在轨道及输出条件满足时创建 Decoder。准备阶段预读的样本也可以交给 Decoder。视频和本章的普通 PCM 音频路径都由 Decoder 把轨道格式交给 Native MediaCodec。

// NuPlayer::Decoder::onConfigure,普通非加密分支节选
mCodec = MediaCodec::CreateByType(
        mCodecLooper, mime.c_str(), false /* encoder */, NULL /* err */, mPid, mUid, format);
// 省略安全组件处理、空对象与配置失败检查
err = mCodec->configure(
        format, mSurface, crypto, 0 /* flags */);
// 省略输出格式记录
sp<AMessage> reply = new AMessage(kWhatCodecNotify, this);
mCodec->setCallback(reply);
err = mCodec->start();

此处是 mediaserver 中的 Native MediaCodec,应用没有为这条播放路径创建 Java MediaCodec。如果应用直接使用 Java MediaCodec,JNI 则会在应用一侧创建 Native 封装。两种入口都可走到 Codec2,缓冲区的调度者分别是 NuPlayer 和应用。

输入槽位交给组件,结果异步折返

当 Decoder 收到输入空闲的通知,它从 GenericSource 取一个压缩样本。普通非加密分支将数据送入 Codec 输入缓冲,随后用 queueInputBuffer 交出 槽位索引、有效数据的 offset 和 size、PTS 与 flags。有数据时需要准备好相应输入内存。如果暂时拿不到样本,Decoder 保留待处理请求并安排后续尝试。正常读到文件末尾时,Decoder 送入 EOS,让组件排空已经接收的工作。部分读取错误也会尝试排入 EOS,并独立上报原错误。

在 Codec2 路径,MediaCodec::GetCodecBase 根据选中组件的归属或名称使用 CCodec,CCodec::allocate 再用 Codec2Client::CreateComponentByName 取得组件。之前交给 MediaCodec 的输入,进入 CCodecBufferChannel::queueInputBufferInternal 后,时间、标志与缓冲描述会装进 Codec2 工作单元。下面两段来自同一函数。前半记录时间和标识。

std::list<std::unique_ptr<C2Work>> items;
std::unique_ptr<C2Work> work(new C2Work);
work->input.ordinal.timestamp = timeUs;
work->input.ordinal.frameIndex = mFrameIndex++;

函数后半段把缓冲描述和标志装进工作单元,再把工作列表提交给组件。

err = std::atomic_load(&mComponent)->queue(&items);

frameIndex 和 PTS 有不同用途。 前者标识组件工作,后者表示媒体时间。多个 work 可以同时在途,组件也可能需要先累计输入再交出输出。一份输入成功排队后,应继续等后续结果。对本文核对的源码,Codec2Client::Component::queue 有 APEX 处理器、AIDL 和 HIDL 三种分支。远程分支把工作描述和关联的 buffer 交给对应服务,具体传输取决于组件和缓冲池。以软件组件 c2.android.avc.decoder 为例,C2SoftAvcDec 调用软件解码实现完成 H.264 解码,通用 Codec2 接口这里没有规定某个专用芯片设备节点。

缓冲区流转,从压缩样本和输入槽位,经 C2Work 到图像、PCM 和消费后的归还

组件的 onWorkDone 结果经 CCodec 和 CCodecBufferChannel 整理后回到 MediaCodec 的输出队列。Decoder 得到 输出索引、数据范围、PTS 和 flags,再把 buffer 与一条 kWhatRenderBuffer 回信交给 Renderer。一旦 Renderer 完成本次消费决策,回信就能把同一个输出索引交回 Decoder。这也解释了直接使用 MediaCodec 时为什么要对每个已领取的输出调用 releaseOutputBuffer。槽位一直留在客户端手里,解码流水线可用的槽位就会变少。

16.5 Renderer 让画面和声音各走自己的出口

视频按媒体时钟排期,再交到 Surface

NuPlayer::Renderer::onDrainVideoQueue 从帧的媒体时间算出预定输出时间,并交给视频调度器调整。如果一帧迟到,Renderer 可以要求丢帧。源码特意让该队列首次处理的画面按当前时间送出。下面是准备回信的部分。

// NuPlayer::Renderer::onDrainVideoQueue,节选
if (!mVideoSampleReceived) {
    realTimeUs = nowUs;
    tooLate = false;
}

entry->mNotifyConsumed->setInt64("timestampNs", realTimeUs * 1000LL);
entry->mNotifyConsumed->setInt32("render", !tooLate);
entry->mNotifyConsumed->post();

回信到 Decoder 后,render=true 走 renderOutputBufferAndRelease(bufferIx, timestampNs),释放索引的同时安排送显。遇到丢帧等无需显示的情况,就走普通 releaseOutputBuffer(bufferIx)。与应用侧 MediaCodec.releaseOutputBuffer(index, renderTimestampNs) 一样,此处的纳秒值是调度用的目标时间,由 Renderer 将媒体 PTS 映射到播放时钟后决定。

// MediaCodec 的输出渲染分支,节选
status_t err = mBufferChannel->renderOutputBuffer(buffer, renderTimeNs);

在本章的 Codec2 路径,CCodecBufferChannel::renderOutputBuffer 拿到图形 block,设置包括时间戳在内的队列参数,调用 Codec2Client::Component::queueToOutputSurface。本地源码的 AIDL 与 HIDL 图形接口分别经过各自的 allocator 或 output queue。随后,Surface 对应的图形缓冲经 SurfaceView 的 BufferQueue/BLAST 路径送到 SurfaceFlinger。SurfaceFlinger 组织图层,再按设备和图层条件与 Composer HAL 协作。需要 GPU 客户端合成的图层先合成到 client target,再交给 Composer。支持设备合成的图层可以由 Composer 交给显示硬件处理。

为什么要留出图形缓冲这一站?视频解码、图层合成和显示刷新各有自己的节奏。把帧交给图形队列,后续阶段可以按自己的时序取得缓冲并协商何时可再次使用它。MEDIA_INFO_VIDEO_RENDERING_START 是播放器的首帧调度信号。 本版本 Renderer 在投递渲染回信后就能发出该通知,应用要证明画面已经进入显示帧,还需检查对应图层的呈现证据。

音频写入共享环形缓冲,由输出端消耗

本章关注解码后经普通混音输出的 PCM 路径。设备启用音频 offload 时,压缩音频可以走另一条输出路径。在普通 PCM 路径,Renderer 取出已解码的音频数据,通过 mAudioSink->write 写给播放器的 AudioOutput。它继续调用 AudioTrack::write。AudioTrack 从供客户端写入的共享环形缓冲取得可用空间,再将 PCM 复制进去。以下是 AudioTrack::write 中一次提交的后半段。

size_t toWrite = audioBuffer.size();
memcpy(audioBuffer.raw, buffer, toWrite);
buffer = ((const char *) buffer) + toWrite;
userSize -= toWrite;
written += toWrite;

releaseBuffer(&audioBuffer);

releaseBuffer 推进共享缓冲的生产者位置。普通混音线程从对应 track 消费 PCM,处理混音,再将合成结果送往输出流。Android 音频 HAL 负责把输出流交给所选后端。这一段与上一站不同,AudioFlinger 调用的是已打开的输出流,当前 AIDL 与 HIDL 适配均可使用快速消息队列(FMQ)传输数据。写入共享缓冲成功时,客户端已交出这些帧。要判断声音何时实际播放,还要结合输出端的播放位置和设备路由。Renderer 使用音频播放信息更新媒体时钟,视频排期可以据此跟上;音频先结束时,视频还有自己的推进逻辑。

追到驱动前,先问设备选中了哪条路

链路AOSP 可继续追查的交接设备侧要补的证据
视频解码CCodec → Codec2 组件;c2.android.avc.decoder 在 CPU 上解码若实际选中厂商组件,找对应的 vendor 服务、组件实现、节点或固件证据。V4L2 仅是可能的实现。
画面显示图形缓冲与同步 fence → SurfaceFlinger → Composer HAL / 合成与提交用目标设备的 Composer 实现、显示后端和 trace 对上本次提交。在采用 Linux DRM/KMS 的设备上,可继续追查 atomic commit 和显示驱动。
声音输出AudioFlinger 输出线程 → StreamOutHalAidl/Hidl → 设备音频输出流先确认实际路由。采用 ALSA 的板级路径可追 PCM 设备与驱动,模拟器、蓝牙和其他输出的终点各有不同。

用普通应用跟做时,公开 API 能确认组件名称和输出结果。厂商闭源实现、模拟器宿主的呈现链和具体设备节点,需要为选定的镜像另外取证。

16.6 EOS 沿输出走完,播放器自己还要释放

文件读到末尾后,输入 EOS 告诉解码器这条轨道不会再有样本。后续还可能吐出已缓存的帧,甚至最后一个输出缓冲也可能带着有效数据。Decoder 继续处理输出,看到输出 EOS 后再向 Renderer 排入该轨的 EOS。Renderer 处理队列,遇到 EOS 后通知 NuPlayer。

// NuPlayer::onMessageReceived,Renderer::kWhatEOS 分支节选
if (audio) {
    mAudioEOS = true;
} else {
    mVideoEOS = true;
}
// 省略非正常结束时上报 MEDIA_ERROR 的代码
if ((mAudioEOS || mAudioDecoder == NULL)
        && (mVideoEOS || mVideoDecoder == NULL)) {
    notifyListener(MEDIA_PLAYBACK_COMPLETE, 0, 0);
}

对两条轨道都存在的普通播放,NuPlayer 要等音视频的 Renderer EOS 都达到,然后沿先前建立的回调链通知应用。完成回调反映的是播放器状态,不适合作为最后一帧物理呈现的时间戳。遇到错误以 OnErrorListener 的记录为准。

退出页面时,MediaPlayer.release() 清掉 Java 到 Native 播放器的关联。JNI 清空 Native listener 并调用 disconnect(),服务复位播放器、断开输出,缓冲和会话由各自的持有者释放。应用侧的 SurfaceView 随它自己的生命周期销毁;示例传入的是框架持有的 Surface,无需由 Activity 手动调用其 release()。

16.7 用普通应用观察准备、首帧信号和结束

用 Android Studio 新建 Empty Views Activity(Kotlin,包名 com.example.localplayback),在 API 29 或以上的模拟器安装运行。在电脑终端进入 Android Studio 项目根目录,用下面的命令生成短片。也可以把自备的 H.264 + AAC MP4 放到同一路径 app/src/main/res/raw/clip.mp4。生成短片需要支持 libx264 和 AAC 编码的 FFmpeg。生成的片段有移动测试图和持续音调,方便分别确认画面和声音。

mkdir -p app/src/main/res/raw
ffmpeg -f lavfi -i testsrc2=size=320x180:rate=30 \
  -f lavfi -i sine=frequency=550:sample_rate=48000 \
  -t 4 -c:v libx264 -pix_fmt yuv420p -c:a aac \
  -movflags +faststart app/src/main/res/raw/clip.mp4

保留模板 Manifest 中的启动 Activity,用下面的代码替换 MainActivity.kt。示例把准备回调、首帧调度和播放结束分别记到日志,方便和看到的画面、听到的声音对照。它从资源拿到 fd + startOffset + length。APK 中的资源可以只是整个 APK 文件的一段,三个参数应一起使用。这就是 16.3 节里 mOffset 和 mLength 的用途。

package com.example.localplayback

import android.app.Activity
import android.media.MediaPlayer
import android.os.Bundle
import android.util.Log
import android.view.SurfaceHolder
import android.view.SurfaceView

class MainActivity : Activity(), SurfaceHolder.Callback {
    private var player: MediaPlayer? = null
    private val tag = "Playback16"

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val view = SurfaceView(this)
        setContentView(view)
        view.holder.addCallback(this)
    }

    override fun surfaceCreated(holder: SurfaceHolder) {
        releasePlayer()
        val media = MediaPlayer()
        player = media
        try {
            media.setSurface(holder.surface)
            resources.openRawResourceFd(R.raw.clip).use { clip ->
                media.setDataSource(clip.fileDescriptor, clip.startOffset, clip.length)
            }
            media.setOnPreparedListener {
                if (player === it) {
                    Log.i(tag, "prepared")
                    it.start()
                }
            }
            media.setOnInfoListener { _, what, _ ->
                if (what == MediaPlayer.MEDIA_INFO_VIDEO_RENDERING_START) {
                    Log.i(tag, "video_rendering_start")
                }
                false
            }
            media.setOnCompletionListener { Log.i(tag, "completion") }
            media.setOnErrorListener { current, what, extra ->
                Log.e(tag, "error what=$what extra=$extra")
                if (player === current) releasePlayer()
                true
            }
            media.prepareAsync()
            Log.i(tag, "prepareAsync returned")
        } catch (error: Exception) {
            Log.e(tag, "setup failed", error)
            if (player === media) releasePlayer()
        }
    }

    override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) = Unit

    override fun surfaceDestroyed(holder: SurfaceHolder) = releasePlayer()

    override fun onDestroy() {
        releasePlayer()
        super.onDestroy()
    }

    private fun releasePlayer() {
        val current = player ?: return
        player = null
        current.release()
        Log.i(tag, "released")
    }
}

从 Android Studio 点击 Run,电脑终端运行 adb logcat -s Playback16:I。如果连接了多个设备,给 adb 加上 -s 和模拟器序列号。看见测试图在动、听见音调后等待片段结束,再退出 Activity。

观察支持的判断缺少这条信号时查看
prepareAsync returned 后出现 prepared当前进程先提交准备请求,随后处理准备回调setup failed、error what=…,以及资源是否压缩、文件是否可解复用
video_rendering_start,并看到测试图在动前者来自 Renderer 的首帧调度,后者是实际可见结果Surface 是否有效,是否有对应的解码器,图层是否可见
听见音调当前测试设备的音频输出能听到这条轨道模拟器和宿主音量、输出路由、MP4 是否有 AAC 轨
completion,退出后 released正常播放走到结束回调,应用随后释放播放器是否提前离开或收到错误,是否有轨道卡在输出或 EOS

若要看服务侧,在播放期间执行 adb shell dumpsys media.player,先找当前活跃播放器或 NuPlayer 的状态。短片来不及抓时可重新生成更长的同类素材。观察声音路径可以用 adb shell dumpsys media.audio_flinger 的活动 track 与输出信息。仅凭服务存在或日志有关键词,无法确定两项记录属于同一次播放。用应用日志和播放的起止时间缩小范围,再用活跃会话确认对应关系。以上是源码推导出的实验判据,没有针对某台模拟器填入实测数据。

16.8 换成 MediaCodec,接手一次输入和输出

MediaPlayer 替应用协调两条轨。换成 MediaExtractor + MediaCodec 后,可以单独选择视频轨,用同一份压缩样本做软件与硬件的对照。下面只验证视频解码,不启动音频,也不使用 Surface。解码出来的内容可以直接归还,用输出帧数量和 EOS 判断这次解码是否走通。

先在 MediaCodecList(REGULAR_CODECS) 中找支持本文件 MediaFormat 的非编码组件。用 isSoftwareOnly、isHardwareAccelerated 查看组件声明的类型。使用 isFormatSupported(format) 预筛,仍应以实际配置和启动成功为准。同一份素材用同一个视频轨,分别把各自的 codecInfo.name 传给 createByCodecName。模拟器只有软件候选时,只记录软件结果。要比较硬件候选,可以换到同时支持两类组件的设备上重新做一组。

把下面的函数放进同包名下的 DecodeVideo.kt,在文件首行加上 package com.example.localplayback。函数在无 Surface 模式下同步等待,应从后台线程调用。

import android.content.Context
import android.media.MediaCodec
import android.media.MediaCodecList
import android.media.MediaExtractor
import android.media.MediaFormat
import android.os.SystemClock
import android.util.Log
import java.io.File

fun probeCodecs(context: Context, selected: String?) {
    val clip = File(context.cacheDir, "playback16-probe.mp4")
    context.resources.openRawResource(R.raw.clip).use { input ->
        clip.outputStream().use { input.copyTo(it) }
    }
    val extractor = MediaExtractor()
    val format = try {
        extractor.setDataSource(clip.absolutePath)
        (0 until extractor.trackCount)
            .map(extractor::getTrackFormat)
            .first { it.getString(MediaFormat.KEY_MIME)?.startsWith("video/") == true }
    } finally {
        extractor.release()
    }
    val mime = checkNotNull(format.getString(MediaFormat.KEY_MIME))
    val candidates = MediaCodecList(MediaCodecList.REGULAR_CODECS).codecInfos.filter { codec ->
        !codec.isEncoder && !codec.isAlias && codec.supportedTypes.any { it.equals(mime, true) } &&
            codec.getCapabilitiesForType(mime).isFormatSupported(format)
    }
    for (codec in candidates) {
        Log.i("Playback16", "${codec.name} software=${codec.isSoftwareOnly} " +
            "hardware=${codec.isHardwareAccelerated}")
    }
    Log.i("Playback16", "candidates=${candidates.size}")
    if (selected != null) {
        check(candidates.any { it.name == selected }) { "Unknown candidate: $selected" }
        val frames = decodeVideo(clip.absolutePath, selected)
        check(frames > 0) { "$selected produced no nonempty video frames" }
        Log.i("Playback16", "$selected frames=$frames output_eos=true")
    }
}

fun decodeVideo(path: String, codecName: String): Int {
    val extractor = MediaExtractor()
    try {
        extractor.setDataSource(path)
        val video = (0 until extractor.trackCount).first { track ->
            extractor.getTrackFormat(track).getString(MediaFormat.KEY_MIME)
                ?.startsWith("video/") == true
        }
        val format = extractor.getTrackFormat(video)
        extractor.selectTrack(video)
        val codec = MediaCodec.createByCodecName(codecName)
        try {
            codec.configure(format, null, null, 0)
            codec.start()
            val info = MediaCodec.BufferInfo()
            var inputEnded = false
            var frames = 0
            val deadline = SystemClock.elapsedRealtime() + 15_000L
            while (SystemClock.elapsedRealtime() < deadline) {
                if (!inputEnded) {
                    val inputIndex = codec.dequeueInputBuffer(10_000)
                    if (inputIndex >= 0) {
                        val input = checkNotNull(codec.getInputBuffer(inputIndex))
                        input.clear()
                        val size = extractor.readSampleData(input, 0)
                        if (size < 0) {
                            codec.queueInputBuffer(
                                inputIndex, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM
                            )
                            inputEnded = true
                        } else {
                            codec.queueInputBuffer(inputIndex, 0, size, extractor.sampleTime, 0)
                            extractor.advance()
                        }
                    }
                }

                val outputIndex = codec.dequeueOutputBuffer(info, 10_000)
                if (outputIndex >= 0) {
                    val eos = info.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM != 0
                    val config = info.flags and MediaCodec.BUFFER_FLAG_CODEC_CONFIG != 0
                    if (info.size > 0 && !config) frames++
                    codec.releaseOutputBuffer(outputIndex, false)
                    if (eos) return frames
                }
            }
            error("Timed out before output EOS: $codecName ($frames frames)")
        } finally {
            codec.release()
        }
    } finally {
        extractor.release()
    }
}

在 16.7 节的 MainActivity.onCreate 中,把下面这段接在 super.onCreate(savedInstanceState) 后面、创建 SurfaceView 之前。探测模式单独走后台线程,结果写入日志,页面上没有播放画面。

if (intent.getBooleanExtra("probe", false)) {
    val selected = intent.getStringExtra("codec")
    val context = applicationContext
    Thread {
        runCatching { probeCodecs(context, selected) }
            .onFailure { Log.e("Playback16", "probe failed", it) }
    }.start()
    return
}

重新安装后,先退出正常播放页面。用以下两种启动方式先列组件,再各选一个软件和硬件组件重复运行第二条启动命令。只枚举时,等日志打印 candidates=N,为 0 表示未筛到候选。有指定组件时,等日志给出帧数和 output_eos=true 或报告错误,再退出页面并开始下一轮。若系统把已有页面带回前台而未重走 onCreate,先从最近任务关闭示例页面,再启动。NAME 替换为上次日志列出的实际组件名。

adb shell am start -n com.example.localplayback/.MainActivity --ez probe true
adb shell am start -n com.example.localplayback/.MainActivity --ez probe true --es codec NAME
adb logcat -s Playback16:I

负的 dequeue 返回值不代表输出 EOS。格式变化或暂时无缓冲时,循环继续供给输入和取走输出。成功结果是得到非零输出帧数并收到输出 EOS。15 秒是这段短片实验的等待上限,只用来避免失去进展时无限循环。若硬件组件在无 Surface 模式下无法配置或运行,该样本无法完成同条件对照。组件分类和帧数足以观察应用 API 这层的行为,驱动和硬件占用还需设备证据。

如果 onPrepared 已到,应用也调用了 start(),画面还是黑的,就顺着视频轨往下查。轨道有没有给出样本?解码器有没有交出输出?这帧有没有进入可见图层?画面出来了却没有声音时,从音频轨的样本和 PCM 输出查到 AudioTrack,再确认实际路由和播放位置。

参考资料