本地视频点下播放,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 先分清播放器、解码器和输出设备
应用通过 Java Framework 的 MediaPlayer 发出请求。JNI 进入应用进程内的 Native MediaPlayer,再经 Binder 到 mediaserver 的 MediaPlayerService。NuPlayer 组织播放,Extractor 拆容器,MediaCodec 统一客户端的编解码接口。选中了 Codec2 组件时,CCodec 负责对接这个组件。
解出什么和交到哪里是两个问题。 视频解码得到图像,按时间交给 Surface,之后还有 SurfaceFlinger 和显示路径。音频解码得到 PCM,交给 AudioTrack 后继续经 AudioFlinger 和输出流。软件 H.264 解码器可以在 CPU 上工作,画面最后仍能通过设备的显示路径输出。
顺着时序看三处交接。第一,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
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 接口这里没有规定某个专用芯片设备节点。
组件的 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,再确认实际路由和播放位置。
参考资料
- Android MediaPlayer API
- Android MediaCodec API
- Android MediaCodecInfo API
- AOSP Media 模块
- MediaPlayer Java 事件处理
- JNI 在准备前再次提交 Surface
- MediaPlayer JNI
- Native MediaPlayer 的 fd 入口
- MediaPlayerService 客户端会话
- NuPlayerDriver 数据源状态
- GenericSource 保存 fd 与准备数据源
- MediaExtractorFactory 远程提取入口
- MPEG4Extractor 读取样本
- NuPlayer Decoder 的输入和输出
- CCodecBufferChannel 的输入工作单元
- Codec2Client 的组件提交
- AOSP H.264 软件解码器
- NuPlayer Renderer 的视频排期
- Codec2 图形缓冲送往输出 Surface
- AudioTrack 写入 PCM
- NuPlayer 的音视频 EOS 汇合