精华内容
下载资源
问答
  • androidopenMax的实现

    2018-04-20 15:34:44
     android AwesomePlayer就是用openmax来做(code)编解码,其实在openmax接口设计中,他不光能用来当编解码。通过他组件可以组成一个完整播放器,包括source、demux、decode、output。但是为什么android只用...

    1.android中用openmax来干啥?

     android中的 AwesomePlayer就是用openmax来做(code)编解码,其实在openmax接口设计中,他不光能用来当编解码。通过他的组件可以组成一个完整的播放器,包括source、demux、decode、output。但是为什么android只用他来做code呢?我认为有以下几方面:


    1.在整个播放器中,解码器不得不说是最重要的一部分,而且也是最耗资源的一块。如果全靠软解,直接通过cpu来运算,特别是高清视频。别的事你就可以啥都不干了。所以解码器是最需要硬件提供加速的部分。现在的高清解码芯片都是主芯片+DSP结构,解码的工作都是通过DSP来做,不会在过多的占用主芯片。所有将芯片中DSP硬件编解码的能力通过openmax标准接口呈现出来,提供上层播放器来用。我认为这块是openmax最重要的意义。

    2.source 主要是和协议打交道,demux 分解容器部分,大多数的容器格式的分解是不需要通过硬件来支持。只是ts流这种格式最可能用到硬件的支持。因为ts格式比较特殊,单包的大小太小了,只有188字节。所以也是为什么现在常见的解码芯片都会提供硬件ts demux 的支持。

    3.音视频输出部分video\audio output 这块和操作系统关系十分紧密。可以看看著名开源播放器vlc。vlc 在mac、linux、Windows都有,功能上差别也不大。所以说他是跨平台的,他跨平台跨在哪?主要的工作量还是在音视频解码完之后的输出模块。因为各个系统的图像渲染和音频输出实现方法不同,所以vlc需要针对每个平台实现不同的output。这部分内容放在openmax来显然不合适。
    所以openmax 中硬件抽象的编解码是最为常用的,也是为什么android中只用它来抽象code
    展开全文
  • android AwesomePlayer就 是用openmax来做(code)编解码,其实在openmax接口设计中,他不光能用来当编解码。通过他组件可以组成一个完整播放器,包括 sourc、demux、decode、output。但是为什么android只用他...

    原址

    1.android中用openmax来干啥?

    android中的 AwesomePlayer就 是用openmax来做(code)编解码,其实在openmax接口设计中,他不光能用来当编解码。通过他的组件可以组成一个完整的播放器,包括 sourc、demux、decode、output。但是为什么android只用他来做code呢?我认为有以下几方面:

    1.在整个播放器中,解码器不得不说是最重要的一部分,而且也是最耗资源的一块。 如果全靠软解,直接通过cpu来运算,特别是高清视频。别的事你就可以啥都不干了。所以解码器是最需要硬件提供加速的部分。现在的高清解码芯片都是主芯 片+DSP结构,解码的工作都是通过DSP来做,不会在过多的占用主芯片。所有将芯片中DSP硬件编解码的能力通过openmax标准接口呈现出来,提供 上层播放器来用。我认为这块是openmax最重要的意义。

    2.source 主要是和协议打交道,demux 分解容器部分,大多数的容器格式的分解是不需要通过硬件来支持。只是ts流这种格式最可能用到硬件的支持。因为ts格式比较特殊,单包的大小太小了,只有 188字节。所以也是为什么现在常见的解码芯片都会提供硬件ts demux 的支持。

    3.音视频输出部分video\audio output 这块和操作系统关系十分紧密。可以看看著名开源播放器vlc。vlc 在mac、linux、Windows都有,功能上差别也不大。所以说他是跨平台的,他跨平台跨在哪?主要的工作量还是在音视频解码完之后的输出模块。因 为各个系统的图像渲染和音频输出实现方法不同,所以vlc需要针对每个平台实现不同的output。这部分内容放在openmax来显然不合适。

    所以openmax 中硬件抽象的编解码是最为常用的,也是为什么android中只用它来抽象code。

    2.android中openmax实现框架

    1.上面已经说过了,android系统中只用openmax来做code,所以android向上抽象了一层OMXCodec,提供给上层播放器用。

    播放器中音视频解码器mVideosource、mAudiosource都是OMXCodec的实例。

    2.OMXCodec通过IOMX 依赖binder机制 获得 OMX服务,OMX服务 才是openmax 在android中 实现。

    3. OMX把软编解码和硬件编解码统一看作插件的形式管理起来。

    AwesomePlayer 中有个变量 

    [cpp] view plaincopy

    1. OMXClient mClient;  

    让我们看看   OMXClient 

    [cpp] view plaincopy

    1. class OMXClient {  
    2. public:  
    3.     OMXClient();  
    4.   
    5.     status_t connect();  
    6.     void disconnect();  
    7.   
    8.     sp<IOMX> interface() {  
    9.         return mOMX;  
    10.     }  
    11.   
    12. private:  
    13.     sp<IOMX> mOMX;  
    14.   
    15.     OMXClient(const OMXClient &);  
    16.     OMXClient &operator=(const OMXClient &);  
    17. };  

    OMXClient 有个IOMX 的变量 mOMX ,这个就是和OMX服务进行binder通讯的。

    在 AwesomePlayer 的构造函数中会调用 

    [cpp] view plaincopy

    1. CHECK_EQ(mClient.connect(), (status_t)OK);  

    [cpp] view plaincopy

    1. status_t OMXClient::connect() {  
    2.     sp<IServiceManager> sm = defaultServiceManager();  
    3.     sp<IBinder> binder = sm->getService(String16("media.player"));  
    4.     sp<IMediaPlayerService> service = interface_cast<IMediaPlayerService>(binder);  
    5.   
    6.     CHECK(service.get() != NULL);  
    7.   
    8.     mOMX = service->getOMX();  
    9.     CHECK(mOMX.get() != NULL);  
    10.   
    11.     if (!mOMX->livesLocally(NULL /* node */, getpid())) {  
    12.         ALOGI("Using client-side OMX mux.");  
    13.         mOMX = new MuxOMX(mOMX);  
    14.     }  
    15.   
    16.     return OK;  
    17. }  

    [cpp] view plaincopy

    1. sp<IOMX> MediaPlayerService::getOMX() {  
    2.     Mutex::Autolock autoLock(mLock);  
    3.   
    4.     if (mOMX.get() == NULL) {  
    5.         mOMX = new OMX;  
    6.     }  
    7.   
    8.     return mOMX;  
    9. }  


    OMXClient::connect函数是通过binder机制 获得到MediaPlayerService,然后通过MediaPlayerService来创建OMX的实例。这样OMXClient就获得到了OMX的入口,接下来就可以通过binder机制来获得OMX提供的服务。

    也就是说OMXClient 是android中 openmax 的入口。

     

    在创建音视频解码mVideoSource、mAudioSource的时候会把OMXClient中的sp<IOMX> mOMX的实例 传给mVideoSource、mAudioSource来共享使用这个OMX的入口。

    也就是说一个AwesomePlayer对应着 一个IOMX 变量,AwesomePlayer中的音视频解码器共用这个IOMX变量来获得OMX服务。

    [cpp] view plaincopy

    1. sp<IOMX> interface() {  
    2.       return mOMX;  
    3.   }  

    [cpp] view plaincopy

    1. mAudioSource = OMXCodec::Create(  
    2.                 mClient.interface(), mAudioTrack->getFormat(),  
    3.                 false, // createEncoder  
    4.                 mAudioTrack);  

    [cpp] view plaincopy

    1. mVideoSource = OMXCodec::Create(  
    2.             mClient.interface(), mVideoTrack->getFormat(),  
    3.             false, // createEncoder  
    4.             mVideoTrack,  
    5.             NULL, flags, USE_SURFACE_ALLOC ? mNativeWindow : NULL);  

    [cpp] view plaincopy

        1.  

    通过上文知道了,每个AwesomePlayer 只有一个OMX服务的入口,但是AwesomePlayer不一定就只需要1种解码器。有可能音视频都有,或者有很多种。这个时候这些解码器都需要OMX的服务,也就是OMX那头需要建立不同的解码器的组件来对应着AwesomePlayer中不同的code。OMX中非常重要的2个成员就是 OMXMaster 和 OMXNodeInstance。OMX通过这俩个成员来创建和维护不同的openmax 解码器组件,为AwesomePlayer中不同解码提供服务。让我们看看他们是怎么实现这些工作的

    1. OMX中 OMXNodeInstance 负责创建并维护不同的实例,这些实例是根据上面需求创建的,以node作为唯一标识。这样播放器中每个OMXCodec在OMX服务端都对应有了自己的OMXNodeInstance实例。

    2.OMXMaster 维护底层软硬件解码库,根据OMXNodeInstance中想要的解码器来创建解码实体组件。

    接下来我们假设视频解码器需要的是AVC,来看看解码器创建的流程。

    (默认走软解码)

    1.准备工作初始化OMXMaster

    OMX构造函数中会进行初始化。

    [cpp] view plaincopy

    1. OMXMaster *mMaster;  

    [cpp] view plaincopy

    1. OMX::OMX()  
    2.     : mMaster(new OMXMaster),  
    3.       mNodeCounter(0) {  
    4. }  

    [cpp] view plaincopy

    1. OMXMaster::OMXMaster()  
    2.     : mVendorLibHandle(NULL) {  
    3.     addVendorPlugin();  
    4.     addPlugin(new SoftOMXPlugin);  
    5. }  

    OMXMaster 负责OMX中编解码器插件管理,软件解码和硬件解码都是使用OMX标准,挂载plugins的方式来进行管理。

    软解通过 addPlugin(new SoftOMXPlugin);会把这些编解码器的名字都放在mPluginByComponentName中。

    android 默认会提供一系列的软件解码器。目前支持这些格式的软编解码。

    [cpp] view plaincopy

    1. kComponents[] = {  
    2.     { "OMX.google.aac.decoder", "aacdec", "audio_decoder.aac" },  
    3.     { "OMX.google.aac.encoder", "aacenc", "audio_encoder.aac" },  
    4.     { "OMX.google.amrnb.decoder", "amrdec", "audio_decoder.amrnb" },  
    5.     { "OMX.google.amrnb.encoder", "amrnbenc", "audio_encoder.amrnb" },  
    6.     { "OMX.google.amrwb.decoder", "amrdec", "audio_decoder.amrwb" },  
    7.     { "OMX.google.amrwb.encoder", "amrwbenc", "audio_encoder.amrwb" },  
    8.     { "OMX.google.h264.decoder", "h264dec", "video_decoder.avc" },  
    9.     { "OMX.google.h264.encoder", "h264enc", "video_encoder.avc" },  
    10.     { "OMX.google.g711.alaw.decoder", "g711dec", "audio_decoder.g711alaw" },  
    11.     { "OMX.google.g711.mlaw.decoder", "g711dec", "audio_decoder.g711mlaw" },  
    12.     { "OMX.google.h263.decoder", "mpeg4dec", "video_decoder.h263" },  
    13.     { "OMX.google.h263.encoder", "mpeg4enc", "video_encoder.h263" },  
    14.     { "OMX.google.mpeg4.decoder", "mpeg4dec", "video_decoder.mpeg4" },  
    15.     { "OMX.google.mpeg4.encoder", "mpeg4enc", "video_encoder.mpeg4" },  
    16.     { "OMX.google.mp3.decoder", "mp3dec", "audio_decoder.mp3" },  
    17.     { "OMX.google.vorbis.decoder", "vorbisdec", "audio_decoder.vorbis" },  
    18.     { "OMX.google.vpx.decoder", "vpxdec", "video_decoder.vpx" },  
    19.     { "OMX.google.raw.decoder", "rawdec", "audio_decoder.raw" },  
    20.     { "OMX.google.flac.encoder", "flacenc", "audio_encoder.flac" },  
    21. };  

    硬件编解码是通过 addVendorPlugin();加载libstagefrighthw.so.各个芯片平台可以遵循openmax 标准,生成libstagefrighthw.so的库来提供android应用。

    [cpp] view plaincopy

    1. void OMXMaster::addVendorPlugin() {  
    2.     addPlugin("libstagefrighthw.so");  
    3. }  

    然后通过dlopen、dlsym来调用库中的函数。

    这部分准备工作是在AwesomePlayer的构造函数中

    CHECK_EQ(mClient.connect(), (status_t)OK); 已经完成了。

    2.创建mVideoSource

    有了上面的OMX,接下来会在AwesomePlayer::initVideoDecoder中创建mVideoSource 实例,下面代码只保留的主要部分:

    [cpp] view plaincopy

    1. status_t AwesomePlayer::initVideoDecoder(uint32_t flags) {  
    2.     ATRACE_CALL();  
    3.     mVideoSource = OMXCodec::Create(  
    4.             mClient.interface(), mVideoTrack->getFormat(),  
    5.             false, // createEncoder  
    6.             mVideoTrack,  
    7.             NULL, flags, USE_SURFACE_ALLOC ? mNativeWindow : NULL);  
    8.     status_t err = mVideoSource->start();  
    9.     return mVideoSource != NULL ? OK : UNKNOWN_ERROR;  
    10. }  

    保留主要部分,去除编码相关

    [cpp] view plaincopy

    1. sp<MediaSource> OMXCodec::Create(  
    2.         const sp<IOMX> &omx,  
    3.         const sp<MetaData> &meta, bool createEncoder,  
    4.         const sp<MediaSource> &source,  
    5.         const char *matchComponentName,  
    6.         uint32_t flags,  
    7.         const sp<ANativeWindow> &nativeWindow) {  
    8.     int32_t requiresSecureBuffers;  
    9.       
    10.     const char *mime;  
    11.     bool success = meta->findCString(kKeyMIMEType, &mime);  
    12.     CHECK(success);  
    13.   
    14.     Vector<String8> matchingCodecs;  
    15.     Vector<uint32_t> matchingCodecQuirks;  
    16.     findMatchingCodecs(  
    17.             mime, createEncoder, matchComponentName, flags,  
    18.             &matchingCodecs, &matchingCodecQuirks);  
    19.   
    20.     sp<OMXCodecObserver> observer = new OMXCodecObserver;  
    21.     IOMX::node_id node = 0;  
    22.   
    23.     for (size_t i = 0; i < matchingCodecs.size(); ++i) {  
    24.         const char *componentNameBase = matchingCodecs[i].string();  
    25.         uint32_t quirks = matchingCodecQuirks[i];  
    26.         const char *componentName = componentNameBase;  
    27.   
    28.         AString tmp;  
    29.      
    30.         status_t err = omx->allocateNode(componentName, observer, &node);  
    31.         if (err == OK) {  
    32.             ALOGV("Successfully allocated OMX node '%s'", componentName);  
    33.   
    34.             sp<OMXCodec> codec = new OMXCodec(  
    35.                     omx, node, quirks, flags,  
    36.                     createEncoder, mime, componentName,  
    37.                     source, nativeWindow);  
    38.   
    39.             observer->setCodec(codec);  
    40.   
    41.             err = codec->configureCodec(meta);  
    42.   
    43.             if (err == OK) {  
    44.                 if (!strcmp("OMX.Nvidia.mpeg2v.decode", componentName)) {  
    45.                     codec->mFlags |= kOnlySubmitOneInputBufferAtOneTime;  
    46.                 }  
    47.   
    48.                 return codec;  
    49.             }  
    50.   
    51.             ALOGV("Failed to configure codec '%s'", componentName);  
    52.         }  
    53.     }  
    54.   
    55.     return NULL;  
    56. }  

    1.根据mVideoTrack传进来的视频信息,查找相匹配的解码器。

    [cpp] view plaincopy

    1. bool success = meta->findCString(kKeyMIMEType, &mime);  
    2. findMatchingCodecs(  
    3.            mime, createEncoder, matchComponentName, flags,  
    4.            &matchingCodecs, &matchingCodecQuirks);  


    2. 创建OMXCodecObserver 实例,OMXCodecObserver功能后续会详细介绍。创建一个node 并初始化为0.

    [cpp] view plaincopy

    1. sp<OMXCodecObserver> observer = new OMXCodecObserver;  
    2.     IOMX::node_id node = 0;  


    3. 通过omx入口 依靠binder 机制调用OMX服务中的allocateNode(),这一步把匹配得到的解码器组件名、OMXCodecObserver实例和初始化为0的node一并传入。

    [cpp] view plaincopy

    1. status_t err = omx->allocateNode(componentName, observer, &node);  

    这个allocateNode 就是文章最开始讲的,在OMX那头创建一个和mVideoSource相匹配的解码实例。用node值作为唯一标识。
    让我们来看看真正的omx中allocateNode做了啥?

    [cpp] view plaincopy

    1. status_t OMX::allocateNode(  
    2.         const char *name, const sp<IOMXObserver> &observer, node_id *node) {  
    3.     Mutex::Autolock autoLock(mLock);  
    4.   
    5.     *node = 0;  
    6.   
    7.     OMXNodeInstance *instance = new OMXNodeInstance(this, observer);  
    8.   
    9.     OMX_COMPONENTTYPE *handle;  
    10.     OMX_ERRORTYPE err = mMaster->makeComponentInstance(  
    11.             name, &OMXNodeInstance::kCallbacks,  
    12.             instance, &handle);  
    13.   
    14.     if (err != OMX_ErrorNone) {  
    15.         ALOGV("FAILED to allocate omx component '%s'", name);  
    16.   
    17.         instance->onGetHandleFailed();  
    18.   
    19.         return UNKNOWN_ERROR;  
    20.     }  
    21.   
    22.     *node = makeNodeID(instance);  
    23.     mDispatchers.add(*node, new CallbackDispatcher(instance));  
    24.   
    25.     instance->setHandle(*node, handle);  
    26.   
    27.     mLiveNodes.add(observer->asBinder(), instance);  
    28.     observer->asBinder()->linkToDeath(this);  
    29.   
    30.     return OK;  
    31. }  


    创建一个OMXNodeInstance实例。

    通过mMaster->makeComponentInstance创建真正解码器的组件,并通过handle与OMXNodeInstance关联。

    所以说mMaster->makeComponentInstance这里是建立解码器组件的核心。会把mVideoSource需要的解码器name一直传递下去。

    [cpp] view plaincopy

    1. OMX_ERRORTYPE OMXMaster::makeComponentInstance(  
    2.         const char *name,  
    3.         const OMX_CALLBACKTYPE *callbacks,  
    4.         OMX_PTR appData,  
    5.         OMX_COMPONENTTYPE **component) {  
    6.     Mutex::Autolock autoLock(mLock);  
    7.   
    8.     *component = NULL;  
    9.   
    10.     ssize_t index = mPluginByComponentName.indexOfKey(String8(name));  
    11.   
    12.     if (index < 0) {  
    13.         return OMX_ErrorInvalidComponentName;  
    14.     }  
    15.   
    16.     OMXPluginBase *plugin = mPluginByComponentName.valueAt(index);  
    17.     OMX_ERRORTYPE err =  
    18.         plugin->makeComponentInstance(name, callbacks, appData, component);  
    19.   
    20.     if (err != OMX_ErrorNone) {  
    21.         return err;  
    22.     }  
    23.   
    24.     mPluginByInstance.add(*component, plugin);  
    25.   
    26.     return err;  
    27. }  


    最开始OMXMaster通过 addPlugin(new SoftOMXPlugin);把支持的软解码放在mPluginByComponentName中,在makeComponentInstance中通过上面传下来的解码器的name值从mPluginByComponentName找到相对应的plugin,然后调用  plugin->makeComponentInstance(name, callbacks, appData, component);

    这里的plugin 值得就是软解SoftOMXPlugin 也就是调用了

    [cpp] view plaincopy

    1. OMX_ERRORTYPE SoftOMXPlugin::makeComponentInstance(  
    2.         const char *name,  
    3.         const OMX_CALLBACKTYPE *callbacks,  
    4.         OMX_PTR appData,  
    5.         OMX_COMPONENTTYPE **component) {  
    6.     ALOGV("makeComponentInstance '%s'", name);  
    7.   
    8.     for (size_t i = 0; i < kNumComponents; ++i) {  
    9.         if (strcmp(name, kComponents[i].mName)) {  
    10.             continue;  
    11.         }  
    12.   
    13.         AString libName = "libstagefright_soft_";  
    14.         libName.append(kComponents[i].mLibNameSuffix);  
    15.         libName.append(".so");  
    16.   
    17.         void *libHandle = dlopen(libName.c_str(), RTLD_NOW);  
    18.   
    19.         if (libHandle == NULL) {  
    20.             ALOGE("unable to dlopen %s", libName.c_str());  
    21.   
    22.             return OMX_ErrorComponentNotFound;  
    23.         }  
    24.   
    25.         typedef SoftOMXComponent *(*CreateSoftOMXComponentFunc)(  
    26.                 const char *, const OMX_CALLBACKTYPE *,  
    27.                 OMX_PTR, OMX_COMPONENTTYPE **);  
    28.   
    29.         CreateSoftOMXComponentFunc createSoftOMXComponent =  
    30.             (CreateSoftOMXComponentFunc)dlsym(  
    31.                     libHandle,  
    32.                     "_Z22createSoftOMXComponentPKcPK16OMX_CALLBACKTYPE"  
    33.                     "PvPP17OMX_COMPONENTTYPE");  
    34.   
    35.         if (createSoftOMXComponent == NULL) {  
    36.             dlclose(libHandle);  
    37.             libHandle = NULL;  
    38.   
    39.             return OMX_ErrorComponentNotFound;  
    40.         }  
    41.   
    42.         sp<SoftOMXComponent> codec =  
    43.             (*createSoftOMXComponent)(name, callbacks, appData, component);  
    44.   
    45.         if (codec == NULL) {  
    46.             dlclose(libHandle);  
    47.             libHandle = NULL;  
    48.   
    49.             return OMX_ErrorInsufficientResources;  
    50.         }  
    51.   
    52.         OMX_ERRORTYPE err = codec->initCheck();  
    53.         if (err != OMX_ErrorNone) {  
    54.             dlclose(libHandle);  
    55.             libHandle = NULL;  
    56.   
    57.             return err;  
    58.         }  
    59.   
    60.         codec->incStrong(this);  
    61.         codec->setLibHandle(libHandle);  
    62.   
    63.         return OMX_ErrorNone;  
    64.     }  
    65.   
    66.     return OMX_ErrorInvalidComponentName;  
    67. }  

    通过上面传下来的解码器的name,找到对应库的名字。假如是264的话,要加载的库就是 libstagefright_soft_h264dec.so,也就是对应上层264解码的话,omx解码组件会加载对应的 libstagefright_soft_h264dec.so库。相对应的软解代码在 Android4.1.1\frameworks\av\media\libstagefright\codecs\on2\h264dec 中。

    加载完264解码库后 通过dlopen、dlsym来调用库中函数。

    通过调用 SoftAVC 中的 createSoftOMXComponent 来创建真正264解码器实例SoftOMXComponent。以后真正视频解码的工作都是通过avc 这个SoftAVC实例完成的

    [cpp] view plaincopy

    1. android::SoftOMXComponent *createSoftOMXComponent(  
    2.         const char *name, const OMX_CALLBACKTYPE *callbacks,  
    3.         OMX_PTR appData, OMX_COMPONENTTYPE **component) {  
    4.     return new android::SoftAVC(name, callbacks, appData, component);  
    5. }  


    经过这一路下来,终于完成了解码器的创建工作。简单总结一下。

    1.AwesomePlayer中通过initVideoDecoder 来创建video解码器mVideoSource

    2.mVideoSource 中通过上部分demux后的视频流 mVideoTrack来获得解码器的类型,通过类型调用omx->allocateNode 创建omx node实例与自己对应。以后都是通过node实例来操作解码器。

    3.在 omx->allocateNode中 通过mMaster->makeComponentInstance 来创建真正对应的解码器组件。这个解码器组件是完成之后解码实际工作的。

    4.在创建mMaster->makeComponentInstance过程中,也是通过上面mVideoTrack 过来的解码器类型名,找到相对应的解码器的库,然后实例化。

    展开全文
  • OMX中OMXNodeInstance负责创建并维护不同实例,这些实例是根据上面需求...1.android系统中只用openmax来做codec,所以android向上抽象了一层OMXCodec,提供给上层播放器用。播放器中音视频解码器mVideosource、...

    OMX中 OMXNodeInstance 负责创建并维护不同的实例,这些实例是根据上面需求创建的,以node作为唯一标识。这样播放器中每个OMXCodec在OMX服务端都对应有了自己的OMXNodeInstance实例。OMXMaster 维护底层软硬件解码库,根据OMXNodeInstance中想要的解码器来创建解码实体组件。

    1.android系统中只用openmax来做codec,所以android向上抽象了一层OMXCodec,提供给上层播放器用。播放器中音视频解码器mVideosource、mAudiosource都是OMXCodec的实例。

    2.OMXCodec通过IOMX 依赖binder机制 获得 OMX服务,OMX服务 才是openmax 在android中的实现。

    3. OMX把软编解码和硬件编解码统一看作插件的形式管理起来。

     

    android中支持的组件和Role

    根据pv_omxregistry.cpp,得到如下表格(其中黄绿色部分表示没有相应编码器)

    组件

    角色

    动态库名

    OMX.PV.mpeg4dec

    video_decoder.mpeg4

    libomx_m4vdec_sharedlibrary

    OMX.PV.h263dec

    video_decoder.h263

    libomx_m4vdec_sharedlibrary

    OMX.PV.avcdec

    video_decoder.avc

    libomx_avcdec_sharedlibrary

    OMX.PV.wmvdec

    video_decoder.wmv

    libomx_wmvdec_sharedlibrary

    OMX.PV.rvdec

    video_decoder.rv

    libomx_rvdec_sharedlibrary

    OMX.PV.aacdec

    audio_decoder.aac

    libomx_aacdec_sharedlibrary

    OMX.PV.amrdec

    audio_decoder.amr

    audio_decoder.amrnb

    audio_decoder.amrwb

    libomx_amrdec_sharedlibrary

    OMX.PV.mp3dec

    audio_decoder.mp3

    libomx_mp3dec_sharedlibrary

    OMX.PV.wmadec

    audio_decoder.wma

    libomx_wmadec_sharedlibrary

    OMX.PV.radec

    audio_decoder.ra

    libomx_radec_sharedlibrary

     

     

     

    OMX.PV.amrencnb

    audio_encoder.amrnb

    libomx_amrenc_sharedlibrary

    OMX.PV.mpeg4enc

    video_encoder.mpeg4

    libomx_m4venc_sharedlibrary

    OMX.PV.h263enc

    video_encoder.h263

    libomx_m4venc_sharedlibrary

    OMX.PV.avcenc

    video_encoder.avc

    libomx_avcenc_sharedlibrary

    OMX.PV.aacenc

    audio_encoder.aac

    libomx_aacenc_sharedlibrary

    OMX中非常重要的2个成员就是 OMXMaster 和 OMXNodeInstance。OMX通过这俩个成员来创建和维护不同的openmax 解码器组件,

    OMXNodeInstance 负责创建并维护不同的实例,这些实例是根据上面需求创建的,以node作为唯一标识。这样播放器中每个OMXCodec在OMX服务端都对应有了自己的OMXNodeInstance实例。

    OMXMaster 维护底层软硬件解码库,根据OMXNodeInstance中想要的解码器来创建解码实体组件。

     

    https://www.cnblogs.com/dyufei/p/8018563.html

    展开全文
  • AndroidOpenMax的适配层

    千次阅读 2011-06-21 14:41:00
    Android的OpenMax适配层的接口在frameworks/base/include/media/目录中的IOMX.h文件定义,其内容如下所示:class IOMX : public IInterface { public: DECLARE_META_INTERFACE(OMX); typedef void *buffer_...

    Android中的OpenMax适配层的接口在frameworks/base/include/media/目录中的IOMX.h文件定义,其内容如下所示:

    1. class IOMX : public IInterface {  
    2. public:  
    3.     DECLARE_META_INTERFACE(OMX);  
    4.     typedef void *buffer_id;  
    5.     typedef void *node_id;  
    6.     virtual bool livesLocally(pid_t pid) = 0;  
    7.     struct ComponentInfo {                    // 组件的信息  
    8.         String8 mName;  
    9.         List < String8 >  mRoles;  
    10.     };  
    11.     virtual status_t listNodes(List < ComponentInfo >  
      *list) = 0;  // 节点列表  
    12.     virtual status_t allocateNode(  
    13.             const char *name, const sp < IOMXObserver >  
      &observer,  // 分配节点  
    14.             node_id *node) = 0;  
    15.     virtual status_t freeNode(node_id node) = 0; 
      // 找到节点  
    16.     virtual status_t sendCommand(              
      // 发送命令  
    17.             node_id node, OMX_COMMANDTYPE cmd,
      OMX_S32 param) = 0;  
    18.     virtual status_t getParameter(             
      // 获得参数  
    19.             node_id node, OMX_INDEXTYPE index,  
    20.             void *params, size_t size) = 0;  
    21.     virtual status_t setParameter(               
      // 设置参数  
    22.             node_id node, OMX_INDEXTYPE index,  
    23.             const void *params, size_t size) = 0;  
    24.     virtual status_t getConfig(                  
      // 获得配置  
    25.             node_id node, OMX_INDEXTYPE index,  
    26.             void *params, size_t size) = 0;  
    27.     virtual status_t setConfig(                 
      // 设置配置  
    28.             node_id node, OMX_INDEXTYPE index,  
    29.             const void *params, size_t size) = 0;
    30.     virtual status_t useBuffer(                    
      // 使用缓冲区  
    31.             node_id node, OMX_U32 port_index, const 
      sp
      < IMemory >  &params,  
    32.             buffer_id *buffer) = 0;  
    33.     virtual status_t allocateBuffer(                
      // 分配缓冲区  
    34.             node_id node, OMX_U32 port_index, size_t size,  
    35.             buffer_id *buffer, void **buffer_data) = 0;  
    36.     virtual status_t allocateBufferWithBackup(      
      // 分配带后备缓冲区  
    37.             node_id node, OMX_U32 port_index, const 
      sp
      < IMemory >  &params,  
    38.             buffer_id *buffer) = 0;  
    39.     virtual status_t freeBuffer(                      
      // 释放缓冲区  
    40.             node_id node, OMX_U32 port_index,
      buffer_id buffer) = 0;  
    41.     virtual status_t fillBuffer(node_id node, 
      buffer_id buffer) = 0; // 填充缓冲区  
    42.     virtual status_t emptyBuffer(                  
      // 消耗缓冲区  
    43.             node_id node,  
    44.             buffer_id buffer,  
    45.             OMX_U32 range_offset, OMX_U32 range_length,  
    46.             OMX_U32 flags, OMX_TICKS timestamp) = 0;  
    47.     virtual status_t getExtensionIndex(  
    48.             node_id node,  
    49.             const char *parameter_name,  
    50.             OMX_INDEXTYPE *index) = 0;  
    51.     virtual sp < IOMXRenderer >  createRenderer(       
      // 创建渲染器(从ISurface)  
    52.             const sp < ISurface >  &surface,  
    53.             const char *componentName,  
    54.             OMX_COLOR_FORMATTYPE colorFormat,  
    55.             size_t encodedWidth, size_t encodedHeight,  
    56.             size_t displayWidth, size_t displayHeight) = 0;  
    57.     sp < IOMXRenderer >  createRenderer(                
      // 创建渲染器(从Surface)  
    58.             const sp < Surface >  &surface,  
    59.             const char *componentName,  
    60.             OMX_COLOR_FORMATTYPE colorFormat,  
    61.             size_t encodedWidth, size_t encodedHeight,  
    62.             size_t displayWidth, size_t displayHeight);  
    63.     sp < IOMXRenderer >  createRendererFromJavaSurface(    
      // 从Java层创建渲染器  
    64.             JNIEnv *env, jobject javaSurface,  
    65.             const char *componentName,  
    66.             OMX_COLOR_FORMATTYPE colorFormat,  
    67.             size_t encodedWidth, size_t encodedHeight,  
    68.             size_t displayWidth, size_t displayHeight);  
    69. }; 

    IOMX表示的是OpenMax的一个组件,根据Android的Binder IPC机制,BnOMX继承IOMX,实现者需要继承实现BnOMX。IOMX类中,除了和标准的OpenMax的 GetParameter,SetParameter,GetConfig,SetConfig,SendCommand,UseBuffer,AllocateBuffer,FreeBuffer,FillThisBuffer 和EmptyThisBuffer等接口之外,还包含了创造渲染器的接口createRenderer(),创建的接口为IOMXRenderer类型。

    IOMX中只有第一个createRenderer()函数是纯虚函数,第二个的createRenderer()函数和createRendererFromJavaSurface()通过调用第一个createRenderer()函数实现。

    IOMXRenderer类表示一个OpenMax的渲染器,其定义如下所示:

    1. class IOMXRenderer : public IInterface {  
    2. public:  
    3.     DECLARE_META_INTERFACE(OMXRenderer);  
    4.     virtual void render(IOMX::buffer_id 
      buffer) = 0;  // 渲染输出函数  
    5. }; 

    IOMXRenderer只包含了一个render接口,其参数类型IOMX::buffer_id实际上是void*,根据不同渲染器使用不同的类型。

    在IOMX.h文件中,另有表示观察器类的IOMXObserver,这个类表示OpenMax的观察者,其中只包含一个onMessage()函 数,其参数为omx_message接口体,其中包含Event事件类型、FillThisBuffer完成和EmptyThisBuffer完成几种类 型。

    提示:Android中OpenMax的适配层是OpenMAX IL层至上的封装层,在Android系统中被StageFright调用,也可以被其他部分调用。

    http://book.51cto.com/art/201101/243162.htm

    展开全文
  • androidopenMax的使用

    2013-04-03 16:50:07
    http://www.360doc.com/content/11/1019/09/11192_157350357.shtml
  • 3.Android中OpenMax的使用情况  Android系统的一些部分对OpenMax IL层进行使用,基本使用的是标准OpenMax IL层的接口,只是进行了简单的...标准的OpenMax IL实现很容易以插件的形式加入到Android系统中。  And
  • Android平台OpenMax多媒体引擎架构

    千次阅读 2013-07-09 17:40:29
     android的播放器的上层api接口是MediaPlayer,通过JNI调用本地服务MediaPlayrService,本地服务再调用StagefrightPlayer,接着调用AwesomePlayer,而 AwesomePlayer就是用openmax来做(code)编解码。层次结构如图...
  • 也就是说OMXClient 是androidopenmax 入口。 在创建音视频解码mVideoSource、mAudioSource时候会把OMXClient中sp<IOMX> mOMX实例 传给mVideoSource、mAudioSource来共享使用这个OMX入口。 也就是...
  • 有了上一篇AwesomePlayer基本框架及播放流程已经很清楚看到了,android AwesomePlayer就是用openmax来做(code)编解码,其实在openmax接口设计中,他不光能用来当编解码。通过他组件可以组成一个完整播放器...
  • 也就是说OMXClient 是androidopenmax 入口。   在创建音视频解码mVideoSource、mAudioSource时候会把OMXClient中sp<IOMX> mOMX实例 传给mVideoSource、mAudioSource来共享使用这个OMX入口。 也...
  • Android平台OpenMax多媒体引擎介绍

    千次阅读 2013-07-08 09:56:59
    OpenMax是一个多媒体应用程序的框架... 在Android中,OpenMax IL层,通常可以用于多媒体引擎的插件,Android的多媒体引擎OpenCore和StageFright都可以使用OpenMax作为插件,主要用于编解码(Codec)处理。  在Androi
  • Android OpenMax

    2014-03-08 21:28:00
    OpenMax是一个多媒体应用程序框架标准...在Android中,OpenMax IL层(集成层)通常可以用于多媒体引擎插件,Android多媒体引擎OpenCore和StageFright都可以使用OpenMax做为插件,主要用于编解码处理。 在And
  • OpenMax是一个多媒体应用程序的框架标准。其中,OpenMax IL(集成层)技术规格定义了媒体组件接口,以便在嵌入式器件的流媒体... 在Android中,OpenMax IL层,通常可以用于多媒体引擎的插件,Android的多媒体引擎OpenC
  • android openmax1

    2013-06-25 15:29:00
    Android的框架层,也定义了由Android封装的OpenMax接口,和标准的接口概念基本相同,但是使用C++类型的接口,并且使用了Android的Binder IPC机制。Android封装OpenMax的接口被StageFright使用,OpenCore没有使用这...
  • 也就是说OMXClient 是androidopenmax 入口。 在创建音视频解码mVideoSource、mAudioSource时候会把 OMXClient中sp<IOMX> mOMX实例 传给 mVideoSource、 mAudioSource来共享使用这个OMX入口。 ...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 179
精华内容 71
关键字:

android的openmax