转-音视频基础知识-AND-Codec初始化及Omx组件创建

移动开发者的音视频基础知识

https://mp.weixin.qq.com/s/HjSdmAsHuvixCH_EWdvk3Q

 恋猫de小郭 GSYTech 2020-01-07 08:25

作为移动开发者,大多数时候会需要接触到音视频相关的开发,而其实严格意义上我也并不是专职的音视频开发工程师,只是在 2016 因为业务需要接触到音视频相关的领域,而开源的 GSYVideoPlayer 恰好火起来之后,为了解决系列问题成了“半桶水”的音视频开发工程师。

图片
2016至今

在维护 GSYVideoPlayer 的这几年里,我发现很多开发者对于音视频领域相关的基本概念还是不清楚,所以我也经常可以收获这样的 issue:

“为什么 xxx 可以播而 GSY 不能播?”

“我两个视频都是 mp4 为什么其中一个播放不了?”

“为什么缓冲过的视频 seek 完还要重新请求数据?”

“为什么播放有黑边?”

“····”

而这些其实都是音视频开发过程中的常识性问题,所以本篇将通过基本概念常见问题应用场景来科普音视频开发的基础知识。

基本概念

首先,如下图所示是一个 .MOV 的视频文件,可以看到更多信息栏里编码器有 AAC 、HEVC,而这个就是视频的音频编码视频编码,而 MOV 其实就是封装协议,这其实就是我们接下来要介绍的基本概念。

图片

一般情况下,视频流从加载都准备播放是需要经过解协议、解封装、解编码这样的过程,其中协议指的就是流媒体协议;封装是的是视频的封装格式;编码又分为视频编码和音频编码

图片

协议一般有 HTTP 、RTSPRTMP 等,我们就最常见的就是 HTTP 网络协议,而 RTSP 和 RTMP 一般用于直播流或支持带有控制信令的常见,比如远程监控。

视频封装协议指的是我们常见的 MP4 、AVI 、RMVB 、MKVTSFLV 等常见后缀格式,它们所表示的就是多媒体的封装协议,就是在传输过程中把音频和视频打包都一起的封装,所以播放前是需要把这部分内容解开,提取出对应音频编码和视频编码。

所以如果以后有人问你,你是视频编码是什么,专业的你不能再回答 “我的视频编码是 MP4” 这样的回复哟。

音频编码

音频编码指的是音频数据的编码方式,常见的如:MP3、 PCMWAVAACAC-3 等,因为音频的原始数据大小一般不适合直接传入,比如原始大小一般可以按照采样率 * 声道数 * 样本格式 去计算,假设前面那个 MOV 的音频采样率是 44100 、样本格式是 16 bit 、单声道、24 秒,那么它原始音频大小应该是

44100 * 16 * 1 * 24 / 8 ≈ 2MB

而实际将音频信息提取出来的大小,如下图大概只有 200 多K,这就是音频编码的作用。

图片

所以一般都会音频传输会采用各种编码格式进行压缩和去冗余,其中比如 WAV/PCM 编码的音频质量比较好,但是体积会比较大;MP3 有损压缩能在音频质量还可以的情况下压缩音频的体积;AAC 也是有损压缩,但是又有分有 LC-AACHE-AAC

视频编码

视频编码指的就是画面图像的编码压缩方式,一般有 H263H264HEVCH265)、MPEG-2 、MPEG-4 等,其中H264 是目前比较常见的编码方式。

通常情况下我们理解的画面是 RGB 组合出来,而目前视频领域可能更多使用 YUV 格式,其中 Y 表示的是亮度(灰度),而 U 和 V表示的是色度(饱和度)

YUV 是对 RGB 的特殊处理和叠加来获取颜色,比如 YUV420 可以理解对色度以 2:1 的抽样率进行存储,然后亮度透过色度来显示画面,更多 YUV 的这里就不展开讨论,而为什么使用 YUV 其中有一点因素就是为了兼容以前的黑白电视。

为什么不直接用原始 YUV ?这里假设上面的 MOV 视频直接使用 YUV420 的格式,那么一帧的大小就会是:

1080 * 1920 * 1 + 1080 * 1920 * 0.5 = 2.9MB

如果在这个基础上,算上帧率(30)和一个视频的时长(一小时),那一部视频原始大小就会是天文数字,这样的情况明显不符合网络传输,所以才有了视频编码用于压缩图像。

在视频压缩里,又有几个概念需要知道,比如:

  • 1、IPB 帧是一种常见的帧压缩方法,其中 I 帧属于关键帧是每个画面的参考帧;P 帧是前向预测帧;B 帧是双向预测帧。简单来说就是 I 帧自己就可以得到一个完整画面,而 P 帧需要前面的 I 帧或者 P 帧来帮助解码得到一个完整画面,而 B 帧则需要前面的 I/P 帧或者后面的 P 帧来协助形成一个画面。

所以 I 帧是很关键的存在,压缩 I 帧就可以很容易压制掉空间的大小,而压缩 P/B 帧可以压缩掉时间上的冗余信息 。所以在视频 seek 的时候,I 帧很关键,如果视频 seek 之后发生往前的跳动,那很可能就是你的视频压缩得太厉害了。

  • 2、还有一个叫 IDR 帧的概念,因为 H264 采用的是多帧预测,导致 I 帧不能作为独立的观察条件,所以多出一个叫 IDR 帧的特殊 I 帧用于参考,IDR 帧最关键的概念就是:在解码器过程中一旦收到 IDR 帧,就会立即清空参考帧缓冲区,并将IDR帧作为被参考帧

  • 3、在视频解码里还有一个叫 DTS(Decoding Time Stamp) 和 PTS(Presentation Time Stamp)的存在,DTS主要用于视频的解码,PTS主要用于在解码阶段对视频进行同步和输出。

因为视频包里面数据解码不是连续的,而是需要通过解码数据源得到的 DTS,才能 决定了包应该在什么时候被解码,而得到的PTS 决定了解码后的图片什么时候被绘制。

  • 4、GOP(Group Of Picture)就是两个 I 帧之间的距离,一般 GOP 设置得越大,画面的效果就会越好,到那时需要解码的时间就会越长。 所以如果码率固定而 GOP 值越大,P/B帧 数量会越多,画面质量就会越高。

常见问题

首先说一个经常被问的问题:ffmpeg 全称是 Fast Forward Mpeg ,所以读法为 (ef,ef,'em,peg) ,一般情况下 ffmpeg 使用的是软解码,也即是纯 CPU 解码;而使用平台的 MediaCodec 播放的是硬解码,也就是支持 GPU 协助。

问题1:“为什么同一个视频机器A可以播机器B不可以?”

这个问题很大可能就是使用了 MediaCodec 的硬解码播放,不同手机和系统版本,对于硬解码的支持是不一样的。

问题2:“为什么都是 ffmpeg 播放,vlc 可以播放,ijkplayer 却不行?”

这是因为 ffmpeg 是支持根据配置打包的,因为很多时候你并不需要那么多,比如在 configure 文件中打开和关闭某些格式的支持来达到按需打包的目的,所以同样是 ffmpeg 不同项目打包支持的程度可能都不同。

支持wav
    --enable-libwavpack    --enable-muxer=wav    --enable-demuxer=wav    --enable-decoder=wavpack    --enable-encoder=wavpack    --enable-decoder=wav    --enable-encoder=wav    --enable-encoder=pcm_s16le    --enable-decoder=pcm_s16le
    --enable-encoder=pcm_u8    --enable-decoder=pcm_u8    --enable-muxer=pcm_u8    --enable-demuxer=pcm_u8      支持mp2        --enable-encoder=mp2     --enable-decoder=mp2     --enable-muxer=mp2     --enable-decoder=mp2float     --enable-encoder=mp2fixed     支持 h265       --enable-decoder=hevc

问题3:“为什么我的视频缓冲了,在 seek 之后还需要重新请求?”

这就需要解释缓存和缓冲的区别:

  • 缓冲:就像在倒垃圾的时候,不可能一有垃圾马上跑去垃圾堆倒,而是先把垃圾倒到垃圾桶,垃圾桶满了再一起倒到垃堆。因为缓冲是在内存中,不可在内存中把整个视频都缓冲进去,所以一般情况下你看到的缓冲都是一段一段的临时数据,一个缓冲块是处于不断地加载又不断清除的过程

  • 缓存: 缓存的解释就简单多了,就是把视频在播放的时候同时下载到本地,这样在缓存区域内的数据就不需要发生二次请求。

问题4:“为什么我的视频在拖拽之后会出现跳动?”

其实前面已经解释过了,这和视频的关键帧有关系,同时也和 ffmpeg 选择的兼容策略有关系,比如使用 -accurate_seek 可以让位于跳转点和 position 之间的额外部分将被解码并且丢弃,对应 ijk 中就是 enable-accurate-seek 的配置。

问题5:“为什么我的视频会出现音视频不同步?”

首选确定你的播放器使用的音视频同步协议是什么,比如 ijkplayer 是使用音频作为同步时钟,如果在 ijkplayer 里 在出现音视频不同步,那么很可能就是视频的码率或者帧率太高,可以尝试使用使用 framedrop 丢帧或者开启硬解码支持。

问题6:“为什么我的视频会出现视频大小和方向不对?”

一般情况下视频信息里是带有旋转角度的,比如 Android 手机上录制的视频就可能带有旋转角度,所以在布局和绘制时需要把旋转角度如:270,90 这样的角度考虑上。

另外视频在获取大小还会有  Width Height Ratio 的信息也就是宽高比,例如这个信息在 ijkplayer 上是以 videoSarNum / videoSarDen 得到的,只有把宽高比和视频的宽高一起计算,才能获取到真正的展示宽高。

问题7:“为什么我的视频出现黑边?”

这个问题其实就是常识性问题,面对不同尺寸不同分辨率的平台,视频显示是根据你给定的 Surface 大小去进行显示,所以你可以选择使用拉伸、裁剪、适应高度、适应宽度等不同布局模式去配置你的绘制控件,这样就可以达到你需要的控制黑边的场景。

诸如此类的问题还有 “如何获取某个时间戳的图像”、“如何同时播放几个视频”、“如何实现播放滤镜”、“如何实现倍速播放” 等问题,这里就不一一展开,感兴趣的可以去 GSYVideoPlayer的 issue 或者搜索相关的 ffmpeg 实现。

使用场景

最后讲一下音视频开发的使用场景,为什么要说这个呢?

因为很多时候开发者可能以为“不就是接个播放器 SDK 放个 Url 的功夫吗?” 其实还真不是,做过音视频开发的应该都深有体会。

  • 1、首先在做音视频开发时,要确定好自己需要支持的封装协议、视频编码、音频编码格式,因为编码格式千万种,一般情况下你不可能全都支持,所以首先要在需求内确定好需要支持的格式范围。

  • 2、如果存在用户自主上传视频的场景,最好还要在服务端提供转格式与转码率等功能。因为在服务端判断视频格式并转码可以规范编码统一,这能够减少客户端端因为编解码失败无法播放的问题;另外提供同一视频不同码率的链接,可以在不同手机型号和系统上能够拥有更好的播放体验,减少前面说过的因为码率太高出现音视频不同步或者卡顿的问题

类似功能在阿里云和腾讯云都支持。

  • 3、在网络播放中存在很多场景,比如播放过程中网络环境出现变化,是从 4G 转化为 Wifi 还是从 Wifi 转到了 4G 的场景 ,这里面涉及到两个点:第一是网络环境发生改变,那么原本的拉流通道其实已经断开,这时候需要重新启动一个新的连接来替换旧的播放内核,才能实现继续播放;第二就是 Wifi 到 4G 之间的环境发生改变时,需要给用户提示并确定是否执行后续操作。

  • 4、还有比如当视频画面需要从列表切换到详情页,需要从原本的容器切换到另外一个可渲染容器时,需要在播放内核不暂停的情况下去设置不同的 Surface 来达到切换的目的;片头广告的播放与视频内容的预加载需要两个不同的请求处理等等的场景。

图片

视频播放场景涉及前后端的数据交流,还有用户环境场景的变换和业务需求的迭代,如果你老板和那你说:

“就按照 bilibili 一般做一个视频播放就好了”

相信我,那你的坑才刚刚开始。

Codec创建流程
Android提供给应用编解码的接口为MediaCodec。我们这里从NuPlayerDecoder开始分析,一是为了衔接之前将的MediaPlayer-NuPlayer流程,二是可以从中参考到MediaCodec是怎么用的,然后去分析内部流程会更好。

之前说到NuPlayer.cpp创建Decoder流程(Video部分):instantiateDecoder

1965 sp<AMessage> notify = new AMessage(kWhatVideoNotify, this);
1966 ++mVideoDecoderGeneration;
1967 notify->setInt32(“generation”, mVideoDecoderGeneration);
1968
1969 *decoder = new Decoder(
1970 notify, mSource, mPID, mUID, mRenderer, mSurface, mCCDecoder);
1971 mVideoDecoderError = false;
1
2
3
4
5
6
NuPlayer::Decoder是继承于DecoderBase的,不过DecoderBase主要就是用于处理一些基本的流程(setParameter、start、stop等)。如果Decoder重写了就更不需要看了。Decoder构造函数中主要是创建了一个looper,每一个Decoder都需要有一个looper,因为MediaCodec是阻塞式的调用,但是NuPlayer需要的是异步操作:
Decoder::Decoder

94 mCodecLooper = new ALooper;
95 mCodecLooper->setName(“NPDecoder-CL”);
96 mCodecLooper->start(false, false, ANDROID_PRIORITY_AUDIO);
97 mVideoTemporalLayerAggregateFps[0] = mFrameRateTotal;
1
2
3
再回来init:NuPlayer.cpp::instantiateDecoder

2032 (*decoder)->init();
2042 (*decoder)->configure(format);
1
Init()其实主要就是注册handler,主要看下configure,DecoderBase的未重写函数,最终发送kWhatConfigure,调用NuPlayer::Decoder::onConfigure:

293 AString mime;
294 CHECK(format->findString(“mime”, &mime));
295
296 mIsAudio = !strncasecmp(“audio/”, mime.c_str(), 6);
297 mIsVideoAVC = !strcasecmp(MEDIA_MIMETYPE_VIDEO_AVC, mime.c_str());
298
299 mComponentName = mime;
300 mComponentName.append(” decoder”);
301 ALOGV(“[%s] onConfigure (surface=%p)”, mComponentName.c_str(), mSurface.get());
302
303 mCodec = MediaCodec::CreateByType(
304 mCodecLooper, mime.c_str(), false /* encoder */, NULL /* err */, mPid, mUid);
305 int32_t secure = 0;
306 if (format->findInt32(“secure”, &secure) && secure != 0) {
307 if (mCodec != NULL) {
308 mCodec->getName(&mComponentName);
309 mComponentName.append(“.secure”);
310 mCodec->release();
311 ALOGI(“[%s] creating”, mComponentName.c_str());
312 mCodec = MediaCodec::CreateByComponentName(
313 mCodecLooper, mComponentName.c_str(), NULL /* err */, mPid, mUid);
314 }
315 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
可以看到MediaCodec创建有两种方式

CreateByType
CreateByComponentName
CreateByType是通过mime创建,而CreateByComponentName是通过组件名创建。当format的secure是1的时候会获取之前mime创建mCodec的组件名,并释放,然后在组件名后拼接secure,然后再通过CreateByComponentName创建codec。Secure类型比较典型的就是youtube视频。(组件名一般为OMX.qcom.video.decoder.avc这种,对应media_codec.xml中)。

再看一下后面几个重要的调用:
NuPlayer::Decoder::onConfigure:

360 err = mCodec->configure(
361 format, mSurface, crypto, 0 /* flags */);
//新建一个AMessage传给mediacodec,当mediacodec做好一些处理(如编码一帧)就把buffer index、flag、size等传入msg,然后post回来,相当于一个callback。
388 sp<AMessage> reply = new AMessage(kWhatCodecNotify, this);
389 mCodec->setCallback(reply);
390
391 err = mCodec->start();
1
2
3
4
5
6
然后看下MediaCodec对应的处理吧:
CreateByType

439 sp<MediaCodec> MediaCodec::CreateByType(
440 const sp<ALooper> &looper, const AString &mime, bool encoder, status_t *err, pid_t pid,
441 uid_t uid) {
442 Vector<AString> matchingCodecs;
443
444 MediaCodecList::findMatchingCodecs(
445 mime.c_str(),
446 encoder,
447 0,
448 &matchingCodecs);
449
450 if (err != NULL) {
451 *err = NAME_NOT_FOUND;
452 }
453 for (size_t i = 0; i < matchingCodecs.size(); ++i) {
454 sp<MediaCodec> codec = new MediaCodec(looper, pid, uid);
455 AString componentName = matchingCodecs[i];
456 status_t ret = codec->init(componentName);
457 if (err != NULL) {
458 *err = ret;
459 }
460 if (ret == OK) {
461 return codec;
462 }
463 ALOGD(“Allocating component ‘%s’ failed (%d), try next one.”,
464 componentName.c_str(), ret);
465 }
466 return NULL;
467 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
CreateByComponentName

470 sp<MediaCodec> MediaCodec::CreateByComponentName(
471 const sp<ALooper> &looper, const AString &name, status_t *err, pid_t pid, uid_t uid) {
472 sp<MediaCodec> codec = new MediaCodec(looper, pid, uid);
473
474 const status_t ret = codec->init(name);
475 if (err != NULL) {
476 *err = ret;
477 }
478 return ret == OK ? codec : NULL; // NULL deallocates codec.
479 }
1
2
3
4
5
6
7
8
9
findMatchingCodecs其实就是从所有的mediaCodec数组中选取匹配mime,mediaCodec数组是加载MediaCodecList的时候从media_codecs.xml中读取到的,具体流程放在Extend中跟踪。

CreateByComponentName和CreateByType最终都是new了MediaCodec,调用init传入组件名

887 status_t MediaCodec::init(const AString &name) {
906 const sp<IMediaCodecList> mcl = MediaCodecList::getInstance();

911 for (const AString &codecName : { name, tmp }) {
912 ssize_t codecIdx = mcl->findCodecByName(codecName.c_str());

916 mCodecInfo = mcl->getCodecInfo(codecIdx);
917 Vector<AString> mediaTypes;
918 mCodecInfo->getSupportedMediaTypes(&mediaTypes);

//根据组件名的开头选择CodecBase,如omx.则为ACodec,C2则为CCodec。
931 mCodec = GetCodecBase(name, mCodecInfo->getOwnerName());
//传给ACodec两个callback,参数都为AMessage,what为kWhatCodecNotify,用于ACodec消息回调。
//CodecCallback主要作用为状态回调,BufferChannel主要作用为buffer状态的回调。
951 mCodec->setCallback(
952 std::unique_ptr<CodecBase::CodecCallback>(
953 new CodecCallback(new AMessage(kWhatCodecNotify, this))));
954 mBufferChannel = mCodec->getBufferChannel();
955 mBufferChannel->setCallback(
956 std::unique_ptr<CodecBase::BufferCallback>(
957 new BufferCallback(new AMessage(kWhatCodecNotify,
this))));

959 sp<AMessage> msg = new AMessage(kWhatInit, this);
986 err = PostAndAwaitResponse(msg, &response);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
看一下kWhatInit的消息处理:

2355 case kWhatInit:
2377 mCodec->initiateAllocateComponent(format);
1
OMX组件创建
上面提到了ACodec/CCodec/MediaFilter都是GetCodecBase通过组件名来创建的。这里拿ACodec当例子,如下为ACodec的构造函数,可以看到ACodec创建了九种状态机,ACodec在不同阶段会通过changeState切换不同的状态,用于管理底层各个Component的各种状态,理解状态机也能帮忙我们理解ACodec工作流程,这里可以看到初始化后状态为mUninitializedState。具体每一个状态机的相互切换留在写数据流的时候再写。

581
582 mUninitializedState = new UninitializedState(this);
583 mLoadedState = new LoadedState(this);
584 mLoadedToIdleState = new LoadedToIdleState(this);
585 mIdleToExecutingState = new IdleToExecutingState(this);
586 mExecutingState = new ExecutingState(this);
587
588 mOutputPortSettingsChangedState =
589 new OutputPortSettingsChangedState(this);
590
591 mExecutingToIdleState = new ExecutingToIdleState(this);
592 mIdleToLoadedState = new IdleToLoadedState(this);
593 mFlushingState = new FlushingState(this);
594
595 mPortEOS[kPortIndexInput] = mPortEOS[kPortIndexOutput] = false;
596 mInputEOSResult = OK;
597
598 mPortMode[kPortIndexInput] = IOMX::kPortModePresetByteBuffer;
599 mPortMode[kPortIndexOutput] = IOMX::kPortModePresetByteBuffer;
600
601 memset(&mLastNativeWindowCrop, 0, sizeof(mLastNativeWindowCrop));
602
603 changeState(mUninitializedState);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
之后调用initiateAllocateComponent。看下代码:

634 void ACodec::initiateAllocateComponent(const sp<AMessage> &msg) {
635 msg->setWhat(kWhatAllocateComponent);
636 msg->setTarget(this);
637 msg->post();

6653 case ACodec::kWhatAllocateComponent:
6654 {
6655 onAllocateComponent(msg);
6656 handled = true;
6657 break;

6705 bool ACodec::UninitializedState::onAllocateComponent(const sp<AMessage> &msg){
6710 sp<AMessage> notify = new AMessage(kWhatOMXMessageList, mCodec);

6724 CHECK(msg->findString(“componentName”, &componentName));

6726 sp<CodecObserver> observer = new CodecObserver(notify);

6731 OMXClient client;
6732 if (client.connect(owner.c_str()) != OK) {
6733 mCodec->signalError(OMX_ErrorUndefined, NO_INIT);
6734 return false;
6735 }
6736 omx = client.interface();
//提高线程调度优先级
6739 int prevPriority = androidGetThreadPriority(tid);
6740 androidSetThreadPriority(tid, ANDROID_PRIORITY_FOREGROUND);
6741 err = omx->allocateNode(componentName.c_str(), observer, &omxNode);
6742 androidSetThreadPriority(tid, prevPriority);
//通过CodecCallback调用MediaCodec的onComponentAllocated来通知MediaCodec当前状态
6769 mCodec->mOMX = omx;
6770 mCodec->mOMXNode = omxNode;
6771 mCodec->mCallback->onComponentAllocated(mCodec->mComponentName.c_str());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
接下来主要看下OMX的allocateNode,OMX对象是通过client.interface()获取到的,首先看下OMX是怎么起来的,如下代码可以看到OMX服务是跑在MediaCodec进程中,很标准的HIDL实现。hal接口定义在hardware/hardware/interfaces/media/omx/1.0中。
main_codecservice.cpp

51 using namespace ::android::hardware::media::omx::V1_0;
52 sp<IOmx> omx = new implementation::Omx();

55 } else if (omx->registerAsService() != OK) {

60 sp<IOmxStore> omxStore = new implementation::OmxStore(omx);

63 } else if (omxStore->registerAsService() != OK) {
1
2
3
4
5
6
7
OmxStore和Omx构造函数除了加载mediacodec xml,主要还new了OMXMaster,OMXMaster比较重要的就是添加了各种Plugin,Plugin如其名,就是加载OMX具体组件的插件。一般android原生都是加载soft plugin,各大平台厂商在实现自己硬编解码的时候也会添加自己的plugin。

32 OMXMaster::OMXMaster() {

53 addVendorPlugin();
54 addPlatformPlugin();
55 }

61 void OMXMaster::addVendorPlugin() {
62 addPlugin(“libstagefrighthw.so”);
63 }
64
65 void OMXMaster::addPlatformPlugin() {
66 addPlugin(“libstagefright_softomx_plugin.so”);
67 }

69 void OMXMaster::addPlugin(const char *libname) {
70 void *libHandle = android_load_sphal_library(libname, RTLD_NOW);
71
72 if (libHandle == NULL) {
73 return;
74 }
75
76 typedef OMXPluginBase *(*CreateOMXPluginFunc)();
77 CreateOMXPluginFunc createOMXPlugin =
78 (CreateOMXPluginFunc)dlsym(
79 libHandle, “createOMXPlugin”);
80 if (!createOMXPlugin)
81 createOMXPlugin = (CreateOMXPluginFunc)dlsym(
82 libHandle, “_ZN7android15createOMXPluginEv”);
83
84 OMXPluginBase *plugin = nullptr;
85 if (createOMXPlugin) {
86 plugin = (*createOMXPlugin)();
87 }
88
89 if (plugin) {
90 mPlugins.push_back({ plugin, libHandle });
91 addPlugin(plugin);
92 } else {
93 android_unload_sphal_library(libHandle);
94 }
95 }

97 void OMXMaster::addPlugin(OMXPluginBase *plugin) {
98 Mutex::Autolock autoLock(mLock);
104 while ((err = plugin->enumerateComponents(
105 name, sizeof(name), index++)) == OMX_ErrorNone) {

108 if (mPluginByComponentName.indexOfKey(name8) >= 0) {

112 continue;
113 }

115 mPluginByComponentName.add(name8, plugin);
116 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
回到ACodec,之前调用了omx->allocateNode(componentName.c_str(), observer, &omxNode);

84 Return<void> Omx::allocateNode(
85 const hidl_string& name,
86 const sp<IOmxObserver>& observer,
87 allocateNode_cb _hidl_cb) {
//OMXNodeInstance相当于组件的句柄,对象需要传回给ACodec,
//component就是通过Instance回调一些Codec函数,传回一些状态以及buffer信息。
100 instance = new OMXNodeInstance(
101 this, new LWOmxObserver(observer), name.c_str());
//调用OmxMaster::makeComponentInstance
104 OMX_ERRORTYPE err = mMaster->makeComponentInstance(
105 name.c_str(), &OMXNodeInstance::kCallbacks,
106 instance.get(), &handle);

116 instance->setHandle(handle);
//传给ACodec instance
144 _hidl_cb(toStatus(OK), new TWOmxNode(instance));
}

146 OMX_ERRORTYPE OMXMaster::makeComponentInstance(
147 const char *name,
148 const OMX_CALLBACKTYPE *callbacks,
149 OMX_PTR appData,
150 OMX_COMPONENTTYPE **component) {
//mPluginByComponentName是之前加载plugin存入的
156 ssize_t index = mPluginByComponentName.indexOfKey(String8(name));

162 OMXPluginBase *plugin = mPluginByComponentName.valueAt(index);
//调用plugin中makeComponentInstance
163 OMX_ERRORTYPE err =
164 plugin->makeComponentInstance(name, callbacks, appData, component);

170 mPluginByInstance.add(*component, plugin);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
很多平台厂商的plugin文件的实际函数逻辑都在so文件中,无法查看,这里以Soft Plugin作为例子:

87 OMX_ERRORTYPE SoftOMXPlugin::makeComponentInstance(
88 const char *name,
89 const OMX_CALLBACKTYPE *callbacks,
90 OMX_PTR appData,
91 OMX_COMPONENTTYPE **component) {

94 for (size_t i = 0; i < kNumComponents; ++i) {
95 if (strcmp(name, kComponents[i].mName)) {
96 continue;
97 }
//libstagefright_soft_拼接上组件名
99 AString libName = “libstagefright_soft_”;
100 libName.append(kComponents[i].mLibNameSuffix);
101 libName.append(“.so”);
//dlopen打开软编解码器so
117 void *libHandle = dlopen(libName.c_str(), RTLD_NOW|RTLD_NODELETE);

129 CreateSoftOMXComponentFunc createSoftOMXComponent =
130 (CreateSoftOMXComponentFunc)dlsym(
131 libHandle,
132 “_Z22createSoftOMXComponentPKcPK16OMX_CALLBACKTYPE”
133 “PvPP17OMX_COMPONENTTYPE”);

142 sp<SoftOMXComponent> codec =
143 (*createSoftOMXComponent)(name, callbacks, appData, component);

160 codec->incStrong(this);
161 codec->setLibHandle(libHandle);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
以libstagefright_soft_m4vh263dec.so为例

415 android::SoftOMXComponent *createSoftOMXComponent(
416 const char *name, const OMX_CALLBACKTYPE *callbacks,
417 OMX_PTR appData, OMX_COMPONENTTYPE **component) {
418 using namespace android;
419 if (!strcmp(name, “OMX.google.h263.decoder”)) {
420 return new android::SoftMPEG4(
421 name, “video_decoder.h263”, OMX_VIDEO_CodingH263,
422 kH263ProfileLevels, ARRAY_SIZE(kH263ProfileLevels),
423 callbacks, appData, component);
424 } else if (!strcmp(name, “OMX.google.mpeg4.decoder”)) {
425 return new android::SoftMPEG4(
426 name, “video_decoder.mpeg4″, OMX_VIDEO_CodingMPEG4,
427 kM4VProfileLevels, ARRAY_SIZE(kM4VProfileLevels),
428 callbacks, appData, component);
429 } else {
430 CHECK(!”Unknown component”);
431 }
432 return NULL;
433 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
最终根据传入组件名创建相应解码器SoftMPEG4,看了下SoftMPEG4继承于SoftVideoDecoderOMXComponent,而SoftVideoDecoderOMXComponent又继承于SimpleSoftOMXComponent,所以emptyThisBuffer、fillThisBuffer等omx基本方法,都在SimpleSoftOMXComponent中定义,而SoftMPEG4没有重写。至此omx组件创建完成,后续章节通过OMX各个状态的切换以及ACodec对应状态机的切换来继续分析数据流走向,同时会整理omx框架每个部分的关连。
至于MediaFilter(滤波器)、Codec2,大体流程跟ACodec都差不多,不过多分析,Codec2在Q版本及之前基本都是用于管理软编解码器,R版本应该会兼容硬编解码器,大概率会完全替换OMX框架。补一张整体流程图:

 

Extend
MediaCodecList加载xml
void MediaCodecList::findMatchingCodecs(
346 const char *mime, bool encoder, uint32_t flags,
347 Vector<AString> *matches) {
348 matches->clear();
349
350 const sp<IMediaCodecList> list = getInstance();
351 if (list == nullptr) {
352 return;
353 }
354
355 size_t index = 0;
356 for (;;) {
357 ssize_t matchIndex =
358 list->findCodecByType(mime, encoder, index);
359
360 if (matchIndex < 0) {
361 break;
362 }
363
364 index = matchIndex + 1;
365
366 const sp<MediaCodecInfo> info = list->getCodecInfo(matchIndex);
367 CHECK(info != nullptr);
368 AString componentName = info->getCodecName();
369
370 if ((flags & kHardwareCodecsOnly) && isSoftwareCodec(componentName)) {
371 ALOGV(“skipping SW codec ‘%s'”, componentName.c_str());
372 } else {
373 matches->push(componentName);
374 ALOGV(“matching ‘%s'”, componentName.c_str());
375 }
376 }
377 //所以更改软硬编解码优先可以在这修改
378 if (flags & kPreferSoftwareCodecs ||
379 property_get_bool(“debug.stagefright.swcodec”, false)) {
380 matches->sort(compareSoftwareCodecsFirst);
381 }
382 }
383
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
getInstance的流程跟起来最后都是到了getLocalInstance:

143 sp<IMediaCodecList> MediaCodecList::getLocalInstance() {
MediaCodecList *codecList = new MediaCodecList(GetBuilders());
1
主要就是new了MediaCodecList,关键是参数GetBuilders(),先看omx的话,MediaCodecList中的builder就是OmxInfoBuilder 。

80 OmxInfoBuilder sOmxInfoBuilder{true /* allowSurfaceEncoders */};
95 std::vector<MediaCodecListBuilderBase *> GetBuilders() {
96 std::vector<MediaCodecListBuilderBase *> builders;
97 // if plugin provides the input surface, we cannot use OMX video encoders.
98 // In this case, rely on plugin to provide list of OMX codecs that are usable.
99 sp<PersistentSurface> surfaceTest =
100 StagefrightPluginLoader::GetCCodecInstance()->createInputSurface();
101 if (surfaceTest == nullptr) {
102 ALOGD(“Allowing all OMX codecs”);
103 builders.push_back(&sOmxInfoBuilder);
104 } else {
105 ALOGD(“Allowing only non-surface-encoder OMX codecs”);
106 builders.push_back(&sOmxNoSurfaceEncoderInfoBuilder);
107 }
108 builders.push_back(GetCodec2InfoBuilder());
109 return builders;
110 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
看一下MediaCodecList的构造函数:

203 MediaCodecList::MediaCodecList(std::vector<MediaCodecListBuilderBase*> builders) {
204 mGlobalSettings = new AMessage();
205 mCodecInfos.clear();
206 MediaCodecListWriter writer;
207 for (MediaCodecListBuilderBase *builder : builders) {
208 if (builder == nullptr) {
209 ALOGD(“ignored a null builder”);
210 continue;
211 }
212 mInitCheck = builder->buildMediaCodecList(&writer);
213 if (mInitCheck != OK) {
214 break;
215 }
216 }
217 writer.writeGlobalSettings(mGlobalSettings);
218 writer.writeCodecInfos(&mCodecInfos);
219 std::stable_sort(
220 mCodecInfos.begin(),
221 mCodecInfos.end(),
222 [](const sp<MediaCodecInfo> &info1, const sp<MediaCodecInfo> &info2) {
223 // null is lowest
224 return info1 == nullptr
225 || (info2 != nullptr && info1->getRank() < info2->getRank());
226 });
227
228 // remove duplicate entries
229 bool dedupe = property_get_bool(“debug.stagefright.dedupe-codecs”, true);
230 if (dedupe) {
231 std::set<std::string> codecsSeen;
232 for (auto it = mCodecInfos.begin(); it != mCodecInfos.end(); ) {
233 std::string codecName = (*it)->getCodecName();
234 if (codecsSeen.count(codecName) == 0) {
235 codecsSeen.emplace(codecName);
236 it++;
237 } else {
238 it = mCodecInfos.erase(it);
239 }
240 }
241 }
242
================================ buildMediaCodecList ================================
94 status_t OmxInfoBuilder::buildMediaCodecList(MediaCodecListWriter* writer) {
95 // Obtain IOmxStore
96 sp<IOmxStore> omxStore = IOmxStore::getService();
97 if (omxStore == nullptr) {
98 ALOGE(“Cannot find an IOmxStore service.”);
99 return NO_INIT;
100 }
101
102 // List service attributes (global settings)
103 Status status;
104 hidl_vec<IOmxStore::RoleInfo> roles;
105 auto transStatus = omxStore->listRoles(
106 [&roles] (
107 const hidl_vec<IOmxStore::RoleInfo>& inRoleList) {
108 roles = inRoleList;
109 });
================================ OmxStore::listRoles ================================
136 Return<void> OmxStore::listRoles(listRoles_cb _hidl_cb) {
137 _hidl_cb(mRoleList);
138 return Void();
139 }
================================ mRoleList: ================================
38 OmxStore::OmxStore(
39 const sp<IOmx> &omx,
40 const char* owner,
41 const std::vector<std::string> &searchDirs,
42 const std::vector<std::string> &xmlNames,
43 const char* profilingResultsXmlPath) {
44 // retrieve list of omx nodes 57 MediaCodecsXmlParser parser;
58 parser.parseXmlFilesInSearchDirs(xmlNames, searchDirs);
59 if (profilingResultsXmlPath != nullptr) {
60 parser.parseXmlPath(profilingResultsXmlPath);
61 }
75 const auto& roleMap = parser.getRoleMap(); for (const auto& rolePair : roleMap) {
79 RoleInfo role;
80 role.role = rolePair.first;
81 role.type = rolePair.second.type;
82 role.isEncoder = rolePair.second.isEncoder;
112 mRoleList[i] = std::move(role);

OmxStore析构函数参数在头文件里写死的:
================================ OmxStore.h ================================
46 OmxStore(
47 const sp<IOmx> &omx = nullptr,
48 const char* owner = “default”,
49 const std::vector<std::string> &searchDirs =
50 MediaCodecsXmlParser::getDefaultSearchDirs(),
51 const std::vector<std::string> &xmlFiles =
52 MediaCodecsXmlParser::getDefaultXmlNames(),
53 const char *xmlProfilingResultsPath =
54 MediaCodecsXmlParser::defaultProfilingResultsXmlPath);

================================ MediaCodecsXmlParser ================================
37 static std::vector<std::string> getDefaultSearchDirs() {
38 return { “/odm/etc”, “/vendor/etc”, “/etc” };
39 }
40 static std::vector<std::string> getDefaultXmlNames() {
41 return { “media_codecs.xml”, “media_codecs_performance.xml” };
42 }
43 static constexpr char const* defaultProfilingResultsXmlPath =
44 “/data/misc/media/media_codecs_profiling_results.xml”;
45
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

Kass丶
关注

————————————————
版权声明:本文为CSDN博主「Kass丶」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/junluoyu000/article/details/108536505