java drm硬解码 omv 硬解码

转载

数码墨鱼 2024-07-31 21:10:31

文章标签 java drm硬解码移动开发数据结构与算法 ide 数组 文章分类 Java 后端开发

android的多媒体部分采用的编解码标准是OMX，当然这个标准是用于硬件编解码的，软件编解码在这里我就不说了。
直接从stagefright的awesomeplayer开始说起吧，如果看过我前面博客的人知道stagefright使用的三个步骤：

setdatasoure
 prepare
 start

至于它们的作用在这里就不多说了。
在prepare里面，当MediaExtractor解析文件后会产生一个音频流和一个视频流（可能还有字幕流）对应到stagefright里面就是一个MediaSource的数据结构。
也就是awesomeplayer里面的mVideoTrack和mAudioTrack两个数据成员。
得到音视频流后就要开始构造解码器了(暂且只说解码,编码类似)。请看initVideoDecoder或initAudioDecoder。

status_t AwesomePlayer::initVideoDecoder(uint32_t flags) {
 mVideoSource = OMXCodec::Create(
 mClient.interface(), mVideoTrack->getFormat(),//mClient.interface() is BnOMX
 false, // createEncoder
 mVideoTrack,
 NULL, flags);
 ...
 ...
 ...
 status_t err = mVideoSource->start(); if (err != OK) {
 mVideoSource.clear();
 return err;
 }
 }
 return mVideoSource != NULL ? OK : UNKNOWN_ERROR;
 }

函数一开始就创建了一个OMXCodec,下面我们看下传进来的几个参数的意思：
===========================================================================
mClient.interface()
在awesomeplayer的构造函数里面有这么一句话 CHECK_EQ(mClient.connect(), OK);可以到OMXClient里面去看实际是通过MediaPlayerService创建了一个BnOMX(bnOMX会在后面讲到)然后作为自己的成员变量保存下来，这里我们可以将OMXClient看作OMX的客户端，BnOMX则是OMX的具体实现。
再回到mClient.interface()，就知道它返回的就是前面创建的BnOMX。
mVideoTrack->getFormat()
这个很显然是格式信息，但是这个里面不仅仅是编码格式，还有宽高，是否旋转等等，通称MetaData
false
指的是创建解码器，true则是编码器
mVideoTrack
视频流（解码前的压缩数据）
NULL
不指定解码器，如果不指定就会到现有的解码器中去找，选择第一个找到的
flags
解码器的类型，你可以在这里将解码器指定为软解码
===========================================================================
进入OMXCodec::Create函数

sp<MediaSource> OMXCodec::Create(
 const sp<IOMX> &omx,//BnOMX
 const sp<MetaData> &meta, bool createEncoder,
 const sp<MediaSource> &source,
 const char *matchComponentName,//NULL
 uint32_t flags) {
 const char *mime;
 bool success = meta->findCString(kKeyMIMEType, &mime);
 CHECK(success);

 Vector<String8> matchingCodecs;
 findMatchingCodecs(
 mime, createEncoder, matchComponentName, flags, &matchingCodecs); if (matchingCodecs.isEmpty()) {
 return NULL;
 } sp<OMXCodecObserver> observer = new OMXCodecObserver;
 IOMX::node_id node = 0; const char *componentName;
 for (size_t i = 0; i < matchingCodecs.size(); ++i) {
 componentName = matchingCodecs[i].string();
 LOGV("componentName is %s",componentName);
 sp<MediaSource> softwareCodec = createEncoder?
 InstantiateSoftwareEncoder(componentName, source, meta):
 InstantiateSoftwareCodec(componentName, source); if (softwareCodec != NULL) {
 LOGV("Successfully allocated software codec '%s'", componentName); return softwareCodec;
 } LOGV("Attempting to allocate OMX node '%s'", componentName);
 uint32_t quirks = getComponentQuirks(componentName, createEncoder);
 if (!createEncoder
 && (quirks & kOutputBuffersAreUnreadable)
 && (flags & kClientNeedsFramebuffer)) {
 if (strncmp(componentName, "OMX.SEC.", 8)) {
 // For OMX.SEC.* decoders we can enable a special mode that
 // gives the client access to the framebuffer contents. LOGW("Component '%s' does not give the client access to "
 "the framebuffer contents. Skipping.",
 componentName); continue;
 }
 } status_t err = omx->allocateNode(componentName, observer, &node);
 if (err == OK) {
 LOGV("Successfully allocated OMX node '%s'", componentName); sp<OMXCodec> codec = new OMXCodec(
 omx, node, quirks,
 createEncoder, mime, componentName,
 source); observer->setCodec(codec);
 err = codec->configureCodec(meta, flags);
 if (err == OK) {
 return codec;
 } LOGV("Failed to configure codec '%s'", componentName);
 }
 } return NULL;

}

这里面有几个关键的函数
 findMatchingCodecs
 InstantiateSoftwareCodec
 omx->allocateNode

下面一一进行说明：
=========================================================================
findMatchingCodecs
这个函数里面实际是会到一个CodecInfo的数组里面去找到符合条件的解码器，这个数组在OMXCodec里面定义的。当然放在前面就被放到数组的前面保存在matchingCodecs里面,
然后通过for循环来遍历这个matchingCodecs数组。

InstantiateSoftwareCodec
在看这个函数前我声明一下，我分析的代码是2.3.x的在4.0的代码里面这里会有些区别，这个看我的另一篇blog stagefright之2.3和4.0的区别就知道了。
在这个函数里面，会将matchingCodecs里面的解码器与一些软解码器进行比较(如果是硬解的话名字当然会不一样)。然而我们一般都是将硬解放在前面的，所以这个函数肯定会返回NULL
所以一般都会走到第三函数

omx->allocateNode
这个函数会调到BnOMX里面来。我们先看下它的三个参数componentName不多说，observer大家得留意了，它可是底层给我们上报消息的东西了，在后面会谈到，node显然是一个输出参数暂时我只能说它就是
一个区分不同解码器的标识。
下面看allocateNode的代码，这个比较重要

status_t OMX::allocateNode(
 const char *name, const sp<IOMXObserver> &observer, node_id *node) {
 Mutex::Autolock autoLock(mLock); *node = 0;
 OMXNodeInstance *instance = new OMXNodeInstance(this, observer);
 OMX_COMPONENTTYPE *handle;
 OMX_ERRORTYPE err = mMaster->makeComponentInstance(
 name, &OMXNodeInstance::kCallbacks,
 instance, &handle); if (err != OMX_ErrorNone) {
 LOGV("FAILED to allocate omx component '%s'", name); instance->onGetHandleFailed();
 return UNKNOWN_ERROR;
 } *node = makeNodeID(instance);
 mDispatchers.add(*node, new CallbackDispatcher(instance));//CallbackDispatcher dispatch the callback message from omx hardware instance->setHandle(*node, handle);
 mLiveNodes.add(observer->asBinder(), instance);
 observer->asBinder()->linkToDeath(this); return OK;
 }

这里面先是创建了一个OMXNodeInstance，然后就是mMaster->makeComponentInstance再就是mDispatchers.add(*node, new CallbackDispatcher(instance))
最后instance->setHandle(*node, handle);
先简单介绍几个数据结构
OMXNodeInstance某一种类型的OMX,跟nodeid 一一对应
mMaste是OMXMaster这个说白了就是在本地OMX和硬件厂商的OMX之间做管理和协调工作的
mDispatchers是CallbackDispatcher类型的数组，它负责消息的分发（从硬件厂商获取消息分发到具体的某一种类型的解码器OMXNodeInstance，最后到前面讲的observer）
instance->setHandle(*node, handle)这里的这个handle就很关键了，所有的操作都必须通过它来完成
=========================================================================
细说一下OMXMaster
构造函数里面

OMXMaster::OMXMaster()
 : mVendorLibHandle(NULL) {
 addVendorPlugin();#ifndef NO_OPENCORE
 addPlugin(new OMXPVCodecsPlugin);
 #endif
 }
 在没有Opencore的情况下我们只看addVendorPlugin(),这从函数名就可以看出来就是将厂家的插件加入进来。
 void OMXMaster::addVendorPlugin() {
 mVendorLibHandle = dlopen("libstagefrighthw.so", RTLD_NOW); if (mVendorLibHandle == NULL) {
 return;
 } typedef OMXPluginBase *(*CreateOMXPluginFunc)();
 CreateOMXPluginFunc createOMXPlugin =
 (CreateOMXPluginFunc)dlsym(
 mVendorLibHandle, "_ZN7android15createOMXPluginEv"); if (createOMXPlugin) {
 addPlugin((*createOMXPlugin)());
 }
 }

看到了吧，这里开始使用动态库来调用了，也就是说厂家自己替换这个库就行了。
至于要实现什么东西是有标准的，这里我就不多说了。
像CreateOMXPluginFunc这个函数是一定得有的，也就是所创建了一个厂家提供的OMX插件。
再看

void OMXMaster::addPlugin(OMXPluginBase *plugin) {
 Mutex::Autolock autoLock(mLock); mPlugins.push_back(plugin);
 OMX_U32 index = 0;
 char name[128];
 OMX_ERRORTYPE err;
 while ((err = plugin->enumerateComponents(
 name, sizeof(name), index++)) == OMX_ErrorNone) {
 String8 name8(name); if (mPluginByComponentName.indexOfKey(name8) >= 0) {
 LOGE("A component of name '%s' already exists, ignoring this one.",
 name8.string()); continue;
 } mPluginByComponentName.add(name8, plugin);
 }
 CHECK_EQ(err, OMX_ErrorNoMore);
 }

这里有一个数组保存这些插件，plugin->enumerateComponents这句话的意思是说把厂家提供的这个OMX插件支持的解码器格式一一放入到mPluginByComponentName里面，以后需要的这种格式的解码
器就到这里来找。
回到OMXMaster::makeComponentInstance这个函数，它在OMX::allocateNode中被调用的，

OMX_ERRORTYPE OMXMaster::makeComponentInstance(
 const char *name,//name is codec type 
 const OMX_CALLBACKTYPE *callbacks,
 OMX_PTR appData,
 OMX_COMPONENTTYPE **component) {
 Mutex::Autolock autoLock(mLock); *component = NULL;
 ssize_t index = mPluginByComponentName.indexOfKey(String8(name));
 if (index < 0) {
 return OMX_ErrorInvalidComponentName;
 } OMXPluginBase *plugin = mPluginByComponentName.valueAt(index);
 OMX_ERRORTYPE err =
 plugin->makeComponentInstance(name, callbacks, appData, component); if (err != OMX_ErrorNone) {
 return err;
 } mPluginByInstance.add(*component, plugin);
 return err;
 }

可以看到这里就通过插件创建了实例，这里的component就是handle,也是底下返回的。callbacks就是OMXNodeInstance里面的几个回调函数OnEvent，OnEmptyBufferDone，OnFillBufferDone

总结一下操作的流程：

OMXCodec ---> BnOMX ----> OMXNodeInstance -----> handle(看作是厂家OMX的句柄)

消息回调的流程就是

handle ---->OnEvent(OMXNodeInstance) ------->OnEvent(BnOMX)-------->post(CallbackDispatcher)-------->onMessage(OMXNodeInstance)
 ----->onMessage(OMXCodecObserver)------->on_message(OMXCodec)

操作的流程大家都清楚了，下面正式进入我们最关心的，OMX是怎么来实现解码，又是怎么把解码后的数据交给我们的：
上面的操作流程里面我们知道了解码器的创建，开始解码我们必须调用OMXCodec的start函数

status_t OMXCodec::start(MetaData *meta) {
 ...
 ...
 ...
 status_t err = mSource->start(params.get()); if (err != OK) {
 return err;
 }
 ...
 ...
 ...

 return init();
 }

我选择了两个比较重要的地方贴了出来。
mSource->start(params.get());
这句话实际是开启了音视频流Track，也就是说准备好压缩数据给解码器去取。
init()里面会调用一个非常重要的函数allocateBuffers（）；从字面上看是分配内存，没错它就是分配内存的。

status_t OMXCodec::allocateBuffers() {
 status_t err = allocateBuffersOnPort(kPortIndexInput); if (err != OK) {
 return err;
 } return allocateBuffersOnPort(kPortIndexOutput);
 }

它分配了两块内存，一块用于输入，一块用于输出。
至于这里面的实现不同的厂家又有所不同了，我之前做过的一个项目是从/dev/pmem_adsp这个设备中映射出来的一块内存。当然，内存的大小跟厂家提供的解码器的能力是相关的可以通过
status_t err = mOMX->getParameter(
mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
来获取(前面我们讲到了调用的流程，这里就不再多说，总之看到调OMX的最终都会到厂家自定义里面去)。申请的内存在代码中被分为一块一块的(了解camera底层实现的应该知道，这个跟camera的风格很类似)
这些内存块会放到一个叫mPortBuffers[inPort/outPort]的容器中

在awesomeplayer里面开始进行播放后不管是视频还是音频都会调OMXCodec里面的read函数。

status_t OMXCodec::read(
 MediaBuffer **buffer, const ReadOptions *options) {
 *buffer = NULL; ...
 ...
 ... if (mInitialBufferSubmit) {
 mInitialBufferSubmit = false;...
 ...
 ...
 drainInputBuffers();//key word if (mState == EXECUTING) {
 // Otherwise mState == RECONFIGURING and this code will trigger
 // after the output port is reenabled.
 fillOutputBuffers();//key word
 }
 }
 ...
 ...
 ...

while (mState != ERROR && !mNoMoreOutputData && mFilledBuffers.empty()) {
 LOGV("NO MORE OUTPUT DATA=============");
 mBufferFilled.wait(mLock);//key word
 } if (mState == ERROR) {
 return UNKNOWN_ERROR;
 } if (mFilledBuffers.empty()) {
 return mSignalledEOS ? mFinalStatus : ERROR_END_OF_STREAM;
 } if (mOutputPortSettingsHaveChanged) {
 mOutputPortSettingsHaveChanged = false; return INFO_FORMAT_CHANGED;
 } size_t index = *mFilledBuffers.begin();
 mFilledBuffers.erase(mFilledBuffers.begin()); BufferInfo *info = &mPortBuffers[kPortIndexOutput].editItemAt(index);//key word ,we got original data
 info->mMediaBuffer->add_ref();
 *buffer = info->mMediaBuffer; return OK;
 }

read要做的事就是从Track里面读取数据给解码器解码后返回给awesomeplayer。而其中最关键的就是

mOMX->emptyBuffer(
 mNode, info->mBuffer, 0, offset,
 flags, timestampUs);//在drainInputBuffers中被调用
 和mOMX->fillBuffer(mNode, info->mBuffer);//在fillOutputBuffers中被调用

前面一个函数是将从Track读取来的数据交给OMX解码器解码，而后一个函数就是向OMX解码器请求获取解码后的数据。
这两个操作完成后都是有回调的，至于回调的地方大家自己找吧！上面流程里面已经提到过了。

由于时间的原因后面说的比较简洁，但是大家认真看代码再结合我说的看起来应该没问题的。
先就说这么多吧！希望如果有搞驱动或硬件的能贴出来一些厂家OMX具体实现的代码，并且做下讲解，大家一起学习，感激不尽！

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。