OMX Codec詳細解析

概述

---

OMX Codec是stagefrightplayer中負責解碼的模塊。

由於遵循openmax接口規范，因此結構稍微有點負責，這里就依照awesomeplayer中的調用順序來介紹。

主要分如下幾步：

1 mClient->connect

2 InitAudioDecoder & InitVideoDecoder

3 消息通信機制模型的介紹

4 解碼過程介紹

 

先看下類圖

 

這里OMX Codec是以service的方式提供服務的。Awesomeplayer中通過mOmx(IOMX) 作為客戶端通過binder方式與OMX 通信完成解碼的工作

下面一句具體代碼分析

 

1 mClient->connect

---

在awesomeplayer的構造函數中調用，具體代碼如下

 

AwesomePlayer::AwesomePlayer()
{
    ******
    CHECK_EQ(mClient.connect(), (status_t)OK);
    ******
}

 

看下具體實現

 

status_t OMXClient::connect() {
    sp<IServiceManager> sm = defaultServiceManager();
    sp<IBinder> binder = sm->getService(String16("media.player"));
    sp<IMediaPlayerService> service = interface_cast<IMediaPlayerService>(binder);

    CHECK(service.get() != NULL);

    mOMX = service->getOMX();
    CHECK(mOMX.get() != NULL);

    if (!mOMX->livesLocally(NULL /* node */, getpid())) {
        ALOGI("Using client-side OMX mux.");
        mOMX = new MuxOMX(mOMX);
    }

    return OK;
}

 

這里主要就是通過binder機制與mediaplayerservice通信來完成，具體實現看mediaplayerservice

 

sp<IOMX> MediaPlayerService::getOMX() {
    Mutex::Autolock autoLock(mLock);
    if (mOMX.get() == NULL) {
        mOMX = new OMX;
    }
    return mOMX;
}

 

 

主要就是構造一個OMX對象返回給上層保存在mClient的IOMX對象mOmx中

看下構造函數都做了啥

 

OMX::OMX()
    : mMaster(new OMXMaster),
      mNodeCounter(0) {
}

 

在構造函數中又調用了OMXMaster的構造函數，代碼如下

 

OMXMaster::OMXMaster()
    : mVendorLibHandle(NULL) {
    addVendorPlugin();
    addPlugin(new SoftOMXPlugin);
}

 

這里OMXMaster可以看成是解碼器的入口，通過makeComponentInstance建立解碼器的實例，之后就可以進行解碼操作了。

這里我們以軟件解碼器插件為例來看整個流程，主要是addPlugin(newSoftOMXPlugin);先看SoftOMXPlugin構造函數

 

SoftOMXPlugin::SoftOMXPlugin() {
}

 

是空的~~

再看下addPlugin代碼

 

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) {
            ALOGE("A component of name '%s' already exists, ignoring this one.",
                 name8.string());

            continue;
        }

        mPluginByComponentName.add(name8, plugin);
    }

    if (err != OMX_ErrorNoMore) {
        ALOGE("OMX plugin failed w/ error 0x%08x after registering %d "
             "components", err, mPluginByComponentName.size());
    }
}

 

這里傳入的plugin參數時上面SoftOMXPlugin 構造函數產生的實例

從代碼可以看出主要是將enumerateComponents枚舉出來的各種解碼器存放在成員變量mPluginByComponentName中，類型為 KeyedVector<String8, OMXPluginBase *>

看下enumerateComponents實現

 

static const struct {
    const char *mName;
    const char *mLibNameSuffix;
    const char *mRole;

} kComponents[] = {
    { "OMX.google.aac.decoder", "aacdec", "audio_decoder.aac" },
    { "OMX.google.aac.encoder", "aacenc", "audio_encoder.aac" },
    { "OMX.google.amrnb.decoder", "amrdec", "audio_decoder.amrnb" },
    { "OMX.google.amrnb.encoder", "amrnbenc", "audio_encoder.amrnb" },
    { "OMX.google.amrwb.decoder", "amrdec", "audio_decoder.amrwb" },
    { "OMX.google.amrwb.encoder", "amrwbenc", "audio_encoder.amrwb" },
    { "OMX.google.h264.decoder", "h264dec", "video_decoder.avc" },
    { "OMX.google.h264.encoder", "h264enc", "video_encoder.avc" },
    { "OMX.google.g711.alaw.decoder", "g711dec", "audio_decoder.g711alaw" },
    { "OMX.google.g711.mlaw.decoder", "g711dec", "audio_decoder.g711mlaw" },
    { "OMX.google.h263.decoder", "mpeg4dec", "video_decoder.h263" },
    { "OMX.google.h263.encoder", "mpeg4enc", "video_encoder.h263" },
    { "OMX.google.mpeg4.decoder", "mpeg4dec", "video_decoder.mpeg4" },
    { "OMX.google.mpeg4.encoder", "mpeg4enc", "video_encoder.mpeg4" },
    { "OMX.google.mp3.decoder", "mp3dec", "audio_decoder.mp3" },
    { "OMX.google.vorbis.decoder", "vorbisdec", "audio_decoder.vorbis" },
    { "OMX.google.vpx.decoder", "vpxdec", "video_decoder.vpx" },
    { "OMX.google.raw.decoder", "rawdec", "audio_decoder.raw" },
    { "OMX.google.flac.encoder", "flacenc", "audio_encoder.flac" },
};

OMX_ERRORTYPE SoftOMXPlugin::enumerateComponents(
        OMX_STRING name,
        size_t size,
        OMX_U32 index) {
    if (index >= kNumComponents) {
        return OMX_ErrorNoMore;
    }

    strcpy(name, kComponents[index].mName);

    return OMX_ErrorNone;
}

這里enumerateComponents主要就是將數組kComponents中的以為index下標的plugin傳遞出來

 

這里只是將插件名字返回最終存儲在mPluginByComponentName列表中

后面還會通過makeComponentInstance產生實際的解碼器實例，后面再詳細看

 

至此mClient->connect()就結束了。

這里的主要工作就是通過getOMX（）在mediaplayerservice端構造一個OMX實例，並返回給mClient的IOMX成員mOmx中

而且在OMX的構造函數中調用OMXMaster的構造函數，可以通過makeComponentInstance 建立實際的解碼器實例。

 

2 InitAudioDecoder & InitVideoDecoder

---

awesomeplayer構造函數結束后，在setDataSource之后會調用prepare方法，其實現中會調用initAudioDecoder和initVideoDecoder

由於在setDataSource中已經拿到了對應的解碼器信息，因此此處initAudioDecoder 便可以構造實際的解碼器了。以audio為例

 

status_t AwesomePlayer::initAudioDecoder() {
        mAudioSource = OMXCodec::Create(

                mClient.interface(), mAudioTrack->getFormat(),
                false, // createEncoder

                mAudioTrack);}

           status_t err = mAudioSource->start();

     return mAudioSource != NULL ? OK : UNKNOWN_ERROR;

}

 

這里只列出的主要操作，下面依次來看OMXCodec::Create和mAudioSource->start的主要工作

代碼比較多，我們這里主要將重要的代碼列出，無關代碼省略

 

sp<MediaSource> OMXCodec::Create(*）
{

        findMatchingCodecs(
            mime, createEncoder, matchComponentName, flags, &matchingCodecs);

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

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

        sp<OMXCodec> codec = new OMXCodec(
                    omx, node, quirks, flags,
                    createEncoder, mime, componentName,
                    source, nativeWindow);

        observer->setCodec(codec);

        err = codec->configureCodec(meta);

}

下面依次來看每個過程

 

2.1 findMatchingCodecs

先看下代碼

 

void OMXCodec::findMatchingCodecs(
        const char *mime,
        bool createEncoder, const char *matchComponentName,
        uint32_t flags,
        Vector<CodecNameAndQuirks> *matchingCodecs) {
    matchingCodecs->clear();

    const MediaCodecList *list = MediaCodecList::getInstance();
    if (list == NULL) {
        return;
    }

    size_t index = 0;
    for (;;) {
        ssize_t matchIndex =
            list->findCodecByType(mime, createEncoder, index);

        if (matchIndex < 0) {
            break;
        }

        index = matchIndex + 1;

        const char *componentName = list->getCodecName(matchIndex);

        // If a specific codec is requested, skip the non-matching ones.
        if (matchComponentName && strcmp(componentName, matchComponentName)) {
            continue;
        }

        // When requesting software-only codecs, only push software codecs
        // When requesting hardware-only codecs, only push hardware codecs
        // When there is request neither for software-only nor for
        // hardware-only codecs, push all codecs
        if (((flags & kSoftwareCodecsOnly) &&   IsSoftwareCodec(componentName)) ||
            ((flags & kHardwareCodecsOnly) &&  !IsSoftwareCodec(componentName)) ||
            (!(flags & (kSoftwareCodecsOnly | kHardwareCodecsOnly)))) {

            ssize_t index = matchingCodecs->add();
            CodecNameAndQuirks *entry = &matchingCodecs->editItemAt(index);
            entry->mName = String8(componentName);
            entry->mQuirks = getComponentQuirks(list, matchIndex);

            ALOGV("matching '%s' quirks 0x%08x",
                  entry->mName.string(), entry->mQuirks);
        }
    }

    if (flags & kPreferSoftwareCodecs) {
        matchingCodecs->sort(CompareSoftwareCodecsFirst);
    }
}

從代碼可以看到主要就是從MediaCodecList找到與傳入的matchComponentName對應的解碼器

 

MediaCodecList 的實現不看了，感興趣的看下，主要就是從/etc/media_codecs.xml解析出支持的解碼器並匹配出對應的解碼器

舉例：<MediaCodec name="OMX.google.mp3.decoder" type="audio/mpeg" />

這里需要注意的是在前面我們看到 kComponents 數組定義了支持的解碼器，這里/etc/media_codecs.xml 也列出了對應的解碼器，這里名字要對應上

這里找到符合條件的解碼器便通過matchingCodecs->add()添加一個項，並將各個成員賦值，主要是name

最終符合條件的插件便都放在了matchingCodecs列表中

 

2.2 allocateNode

這里主要有如下重要代碼    

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

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

observer的作用主要用於消息傳遞。

 這里allocateNode主要是調用service端的OMX類來完成工作（省略中間的binder操作）

 

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) {
        ALOGV("FAILED to allocate omx component '%s'", name);

        instance->onGetHandleFailed();

        return UNKNOWN_ERROR;
    }

    *node = makeNodeID(instance);
    mDispatchers.add(*node, new CallbackDispatcher(instance));

    instance->setHandle(*node, handle);

    mLiveNodes.add(observer->asBinder(), instance);
    observer->asBinder()->linkToDeath(this);

    return OK;
}

 

 首先構造了OMXNodeInstance，封裝了傳入的observer參數，作為消息傳遞的載體

 調用mMaster->makeComponentInstance生成實際的解碼器實例

 生成node_id

將node_id與實際的解碼器handle保存在instance中，最終instance會保存在OMX的mLiveNodes列表中

這樣OMXCodec就可以通過OMXNodeInstance與解碼器通信了，具體參考下面通信模型。

后面會介紹通信過程。這里重點講解一下與解碼器的操作

 

上面代碼中通過mMaster->makeComponentInstance創建了解碼器的實例，這里我們以android自帶的mp3 解碼器為例來講解

通過上面介紹mp3解碼器對應的項為（/etc/media_codecs.xml）：

<MediaCodec name="OMX.google.mp3.decoder" type="audio/mpeg" />

而findMatchingCodecs 傳入的字符串為：audio/mpeg 以此為依據進行匹配

這里找到對應的解碼器后，解碼器的名字為：OMX.google.mp3.decoder

這樣便可以通過查表（數組kComponents ）得到實際的解碼器了

實際的mp3解碼器代碼文件為：framework/av/media/libstagefright/codecs/mp3dec/SoftMP3.cpp

調用的方法為：mMaster->makeComponentInstance 實際代碼是

 

OMX_ERRORTYPE OMXMaster::makeComponentInstance(
        const char *name,
        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;
}

 

主要是調用插件的makeComponentInstance方法

這里插件是通過OMXMaster構造函數addPlugin(new SoftOMXPlugin);加載的插件，因此這里makeComponentInstance 是SoftOMXPlugin 的方法

看下具體實現

 

OMX_ERRORTYPE SoftOMXPlugin::makeComponentInstance(
        const char *name,
        const OMX_CALLBACKTYPE *callbacks,
        OMX_PTR appData,
        OMX_COMPONENTTYPE **component) {
    ALOGV("makeComponentInstance '%s'", name);

    for (size_t i = 0; i < kNumComponents; ++i) {
        if (strcmp(name, kComponents[i].mName)) {
            continue;
        }

        AString libName = "libstagefright_soft_";
        libName.append(kComponents[i].mLibNameSuffix);
        libName.append(".so");

        void *libHandle = dlopen(libName.c_str(), RTLD_NOW);

        if (libHandle == NULL) {
            ALOGE("unable to dlopen %s", libName.c_str());

            return OMX_ErrorComponentNotFound;
        }

        typedef SoftOMXComponent *(*CreateSoftOMXComponentFunc)(
                const char *, const OMX_CALLBACKTYPE *,
                OMX_PTR, OMX_COMPONENTTYPE **);

        CreateSoftOMXComponentFunc createSoftOMXComponent =
            (CreateSoftOMXComponentFunc)dlsym(
                    libHandle,
                    "_Z22createSoftOMXComponentPKcPK16OMX_CALLBACKTYPE"
                    "PvPP17OMX_COMPONENTTYPE");

        if (createSoftOMXComponent == NULL) {
            dlclose(libHandle);
            libHandle = NULL;

            return OMX_ErrorComponentNotFound;
        }

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

        if (codec == NULL) {
            dlclose(libHandle);
            libHandle = NULL;

            return OMX_ErrorInsufficientResources;
        }

        OMX_ERRORTYPE err = codec->initCheck();
        if (err != OMX_ErrorNone) {
            dlclose(libHandle);
            libHandle = NULL;

            return err;
        }

        codec->incStrong(this);
        codec->setLibHandle(libHandle);

        return OMX_ErrorNone;
    }

    return OMX_ErrorInvalidComponentName;
}

 

這里主要是通過枚舉kComponents找到對應的解碼器記錄

{ "OMX.google.mp3.decoder", "mp3dec", "audio_decoder.mp3" },

這里可以看到每個庫都是以.so的方式提供的，命名符合如下規則：libstagefright_soft_mp3dec.so

通過dlopen加載后通過dlsym找到createSoftOMXComponent方法並執行，這里每個解碼器都應該實現此函數

這里看下mp3的具體實現

 

android::SoftOMXComponent *createSoftOMXComponent(
        const char *name, const OMX_CALLBACKTYPE *callbacks,
        OMX_PTR appData, OMX_COMPONENTTYPE **component) {
    return new android::SoftMP3(name, callbacks, appData, component);
}

 

主要工作就是構造了SoftMP3的類對象並返回，這里注意並沒有將解碼器句柄返回給上層，而是在構造函數中將這種聯系放在給定的OMX_COMPONENTTYPE **component參數中

看下構造函數

 

SoftMP3::SoftMP3(
        const char *name,
        const OMX_CALLBACKTYPE *callbacks,
        OMX_PTR appData,
        OMX_COMPONENTTYPE **component)
    : SimpleSoftOMXComponent(name, callbacks, appData, component),
      mConfig(new tPVMP3DecoderExternal),
      mDecoderBuf(NULL),
      mAnchorTimeUs(0),
      mNumFramesOutput(0),
      mNumChannels(2),
      mSamplingRate(44100),
      mSignalledError(false),
      mOutputPortSettingsChange(NONE) {
    initPorts();
    initDecoder();
}

 

這里就是基本的初始化操作，這里SoftMP3是繼承自SimpleSoftOMXComponent，因此會調用其構造函數，如下

 

SimpleSoftOMXComponent::SimpleSoftOMXComponent(
        const char *name,
        const OMX_CALLBACKTYPE *callbacks,
        OMX_PTR appData,
        OMX_COMPONENTTYPE **component)
    : SoftOMXComponent(name, callbacks, appData, component),
      mLooper(new ALooper),
      mHandler(new AHandlerReflector<SimpleSoftOMXComponent>(this)),
      mState(OMX_StateLoaded),
      mTargetState(OMX_StateLoaded) {
    mLooper->setName(name);
    mLooper->registerHandler(mHandler);

    mLooper->start(
            false, // runOnCallingThread
            false, // canCallJava
            ANDROID_PRIORITY_FOREGROUND);
}

 

這里主要是構造了Alooper 對象來處理消息，以及調用了父類也就是SoftOMXComponent的構造函數‍

關於alooper的工作原理，后面會有一篇專門的文章介紹。

 

SoftOMXComponent::SoftOMXComponent(
        const char *name,
        const OMX_CALLBACKTYPE *callbacks,
        OMX_PTR appData,
        OMX_COMPONENTTYPE **component)
    : mName(name),
      mCallbacks(callbacks),
      mComponent(new OMX_COMPONENTTYPE),
      mLibHandle(NULL) {
    mComponent->nSize = sizeof(*mComponent);
    mComponent->pComponentPrivate = this;
    mComponent->SetParameter = SetParameterWrapper;
    *********
    mComponent->UseEGLImage = NULL;
    mComponent->ComponentRoleEnum = NULL;
    *component = mComponent;

}

 

這里才是構造component的地方，並初始化了其中的方法，如

 mComponent->SetParameter = SetParameterWrapper;

 

OMX_ERRORTYPE SoftOMXComponent::SetParameterWrapper(
        OMX_HANDLETYPE component,
        OMX_INDEXTYPE index,
        OMX_PTR params) {
    SoftOMXComponent *me =
        (SoftOMXComponent *)
            ((OMX_COMPONENTTYPE *)component)->pComponentPrivate;

    return me->setParameter(index, params);
}

 

這里初始化了mComponent 的SetParameter 方法為SoftOMXComponent::SetParameterWrapper而從構造函數知道

mComponent->pComponentPrivate = this;

因此實際調用的是this->SetParameter 也就是其子類的實現

（這里很重要，請注意理解透徹）

通過上面分析可以知道，android已經為解碼器的消息傳遞通過兩個父類及SoftOMXComponent和SimpleSoftOMXComponent完成了

后面解碼器只要從SimpleSoftOMXComponent 繼承並實現對應的消息處理就可以了

在mp3的構造函數中還有如下語句

    initPorts(); 主要作用是配置解碼器的輸入輸出
    initDecoder(); 實際的解碼器

這里需要注意的是在SoftMP3的代碼里便可以調用實際解碼器的init decoder等操作了，而SoftMP3可以認為是實際解碼器的封裝

具體調用順序會在后面消息處理階段介紹。

 

到這里allocateNode 就介紹完了：主要工作就是建立與解碼器的聯系 observer nodeid，以及找到實際的解碼器並初始化

 

2.3OMXCodec構造函數

后面的執行語句如下：

sp<OMXCodec> codec = new OMXCodec(
                    omx, node, quirks, flags,
                    createEncoder, mime, componentName,
                    source, nativeWindow);

具體實現如下

 

OMXCodec::OMXCodec(
        const sp<IOMX> &omx, IOMX::node_id node,
        uint32_t quirks, uint32_t flags,
        bool isEncoder,
        const char *mime,
        const char *componentName,
        const sp<MediaSource> &source,
        const sp<ANativeWindow> &nativeWindow)
    : mOMX(omx),
      mOMXLivesLocally(omx->livesLocally(node, getpid())),
      mNode(node),
      mQuirks(quirks),
      mFlags(flags),
      mIsEncoder(isEncoder),
      mIsVideo(!strncasecmp("video/", mime, 6)),
      mMIME(strdup(mime)),
      mComponentName(strdup(componentName)),
      mSource(source),
      mCodecSpecificDataIndex(0),
      mState(LOADED),
      mInitialBufferSubmit(true),
      mSignalledEOS(false),
      mNoMoreOutputData(false),
      mOutputPortSettingsHaveChanged(false),
      mSeekTimeUs(-1),
      mSeekMode(ReadOptions::SEEK_CLOSEST_SYNC),
      mTargetTimeUs(-1),
      mOutputPortSettingsChangedPending(false),
      mSkipCutBuffer(NULL),
      mLeftOverBuffer(NULL),
      mPaused(false),
      mNativeWindow(
              (!strncmp(componentName, "OMX.google.", 11)
              || !strcmp(componentName, "OMX.Nvidia.mpeg2v.decode"))
                        ? NULL : nativeWindow) {
    mPortStatus[kPortIndexInput] = ENABLED;
    mPortStatus[kPortIndexOutput] = ENABLED;

    setComponentRole();
}

 

這里主要就是將之前的所有工作，都保存在OMXCodec實例中，之后awesomeplayer便直接操作OMXCodec（mAudioSource）了

這里    setComponentRole();主要是設置角色（編碼器還是解碼器），后面再介紹消息傳遞時介紹。

這里還要注意的是OMXCodec繼承自MediaSource&MediaBufferObserver

因此才可以作為輸出模塊的數據源

 

 

2.4 配置解碼器

            observer->setCodec(codec);

            err = codec->configureCodec(meta);

這兩部分在我們后面介紹完消息機制之后，讀者可自行回來分析

 

上面介紹了create的操作

下面介紹mAudioSource->start 的操作

 

status_t OMXCodec::start(MetaData *meta) {

    mSource->start(params.get())；

     return init();

}

 

只列出了重要代碼，其中mSource->start是指啟動解碼器的數據源MediaSource，這里也就是extractor中通過getTrack拿到的mediaSource。比較簡單不說了

看下init實現 ，省略無關代碼

 

status_t OMXCodec::init() {
    err = allocateBuffers();
      return mState == ERROR ? UNKNOWN_ERROR : OK;
}

 

主要工作是通過allocateBuffers申請內存

 

status_t OMXCodec::allocateBuffers() {
    status_t err = allocateBuffersOnPort(kPortIndexInput);

    if (err != OK) {
        return err;
    }

    return allocateBuffersOnPort(kPortIndexOutput);
}

 

這里分別申請輸入和輸出的buffer

這里分段來看allocateBuffersOnPort函數

 

status_t OMXCodec::allocateBuffersOnPort(OMX_U32 portIndex) {

    OMX_PARAM_PORTDEFINITIONTYPE def;
    InitOMXParams(&def);
    def.nPortIndex = portIndex;

    err = mOMX->getParameter(
            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));

    size_t totalSize = def.nBufferCountActual * def.nBufferSize;
    mDealer[portIndex] = new MemoryDealer(totalSize, "OMXCodec");

 

這里開頭先通過命令OMX_IndexParamPortDefinition獲取解碼器配置的大小

然后構造MemoryDealer實例，存放buffer數量及大小信息

這里命令的傳輸過程請參考消息通訊機制模型的介紹，看完再回來理解這部分

以mp3為例，在SoftMP3的構造函數中會調用initPorts來初始化OMX_PARAM_PORTDEFINITIONTYPE對象

里面會確定buffer的大小：包括有幾個buffer，每個buffer的容量等

這里OMX_IndexParamPortDefinition主要是查詢此信息，然后就知道要申請多少內存了

 

for (OMX_U32 i = 0; i < def.nBufferCountActual; ++i) {
    sp<IMemory> mem = mDealer[portIndex]->allocate(def.nBufferSize);
    CHECK(mem.get() != NULL);

    BufferInfo info;
    info.mData = NULL;
    info.mSize = def.nBufferSize;
    err = mOMX->useBuffer(mNode, portIndex, mem, &buffer);

    if (mem != NULL) {
        info.mData = mem->pointer();
    }

    info.mBuffer = buffer;
    info.mStatus = OWNED_BY_US;
    info.mMem = mem;
    info.mMediaBuffer = NULL;

    mPortBuffers[portIndex].push(info);

    CODEC_LOGV("allocated buffer %p on %s port", buffer,
         portIndex == kPortIndexInput ? "input" : "output");
}

 

下面是一個循環（忽略了secure等無關代碼）

主要是申請內存，並為每個內存新建一個BufferInfo變量，最終都放在mPortBuffers[index]對應的棧中

 

至此InitAudioDecoder 便執行完畢了，主要做了兩件事：建立實際的解碼器+申請buffer

 

3 消息通信機制模型的介紹

---

當與解碼器的聯系建立之后，后面的工作主要就是傳遞消息由解碼器處理將處理結果返回給調用者

但前面的介紹對消息模型並不清晰，這里專門介紹一下

下面就以 OMXCodec構造函數中的   setComponentRole();為例來介紹此過程

具體代碼如下：

 

void OMXCodec::setComponentRole() {
    setComponentRole(mOMX, mNode, mIsEncoder, mMIME);
}

 

 

// static
void OMXCodec::setComponentRole(
        const sp<IOMX> &omx, IOMX::node_id node, bool isEncoder,
        const char *mime) {
    struct MimeToRole {
        const char *mime;
        const char *decoderRole;
        const char *encoderRole;
    };

    static const MimeToRole kMimeToRole[] = {
        { MEDIA_MIMETYPE_AUDIO_MPEG,
            "audio_decoder.mp3", "audio_encoder.mp3" },
        { MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_I,
            "audio_decoder.mp1", "audio_encoder.mp1" },
        { MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II,
            "audio_decoder.mp2", "audio_encoder.mp2" },
        { MEDIA_MIMETYPE_AUDIO_AMR_NB,
            "audio_decoder.amrnb", "audio_encoder.amrnb" },
        { MEDIA_MIMETYPE_AUDIO_AMR_WB,
            "audio_decoder.amrwb", "audio_encoder.amrwb" },
        { MEDIA_MIMETYPE_AUDIO_AAC,
            "audio_decoder.aac", "audio_encoder.aac" },
        { MEDIA_MIMETYPE_AUDIO_VORBIS,
            "audio_decoder.vorbis", "audio_encoder.vorbis" },
        { MEDIA_MIMETYPE_AUDIO_G711_MLAW,
            "audio_decoder.g711mlaw", "audio_encoder.g711mlaw" },
        { MEDIA_MIMETYPE_AUDIO_G711_ALAW,
            "audio_decoder.g711alaw", "audio_encoder.g711alaw" },
        { MEDIA_MIMETYPE_VIDEO_AVC,
            "video_decoder.avc", "video_encoder.avc" },
        { MEDIA_MIMETYPE_VIDEO_MPEG4,
            "video_decoder.mpeg4", "video_encoder.mpeg4" },
        { MEDIA_MIMETYPE_VIDEO_H263,
            "video_decoder.h263", "video_encoder.h263" },
        { MEDIA_MIMETYPE_VIDEO_VPX,
            "video_decoder.vpx", "video_encoder.vpx" },
        { MEDIA_MIMETYPE_AUDIO_RAW,
            "audio_decoder.raw", "audio_encoder.raw" },
        { MEDIA_MIMETYPE_AUDIO_FLAC,
            "audio_decoder.flac", "audio_encoder.flac" },
    };

    static const size_t kNumMimeToRole =
        sizeof(kMimeToRole) / sizeof(kMimeToRole[0]);

    size_t i;
    for (i = 0; i < kNumMimeToRole; ++i) {
        if (!strcasecmp(mime, kMimeToRole[i].mime)) {
            break;
        }
    }

    if (i == kNumMimeToRole) {
        return;
    }

    const char *role =
        isEncoder ? kMimeToRole[i].encoderRole
                  : kMimeToRole[i].decoderRole;

    if (role != NULL) {
        OMX_PARAM_COMPONENTROLETYPE roleParams;
        InitOMXParams(&roleParams);

        strncpy((char *)roleParams.cRole,
                role, OMX_MAX_STRINGNAME_SIZE - 1);

        roleParams.cRole[OMX_MAX_STRINGNAME_SIZE - 1] = '\0';

        status_t err = omx->setParameter(
                node, OMX_IndexParamStandardComponentRole,
                &roleParams, sizeof(roleParams));

        if (err != OK) {
            ALOGW("Failed to set standard component role '%s'.", role);
        }
    }
}

這里是解碼器因此role == audio_decoder.mp3

 

這里主要執行了如下步驟：

InitOMXParams(&roleParams);

status_t err = omx->setParameter(
                node, OMX_IndexParamStandardComponentRole,
                &roleParams, sizeof(roleParams));

其中InitOMXParams主要是初始化roleParams變量

主要是靠setParameter來完成工作：記錄下傳遞進來的參數：OMX_IndexParamStandardComponentRole 是具體命令 roleParams 是具體參數，而node 則是與service的橋梁

具體調用的是OMX的方法（service端的，不了解可參考第一部分mClient->connect的介紹）

 

status_t OMX::setParameter(
        node_id node, OMX_INDEXTYPE index,
        const void *params, size_t size) {
    return findInstance(node)->setParameter(
            index, params, size);
}

 

首先是通過nodeID得到了OMXNodeInstance（這里OMXNodeInstance是封裝了observer的實例）

繼續進入instance

 

status_t OMXNodeInstance::setParameter(
        OMX_INDEXTYPE index, const void *params, size_t size) {
    Mutex::Autolock autoLock(mLock);

    OMX_ERRORTYPE err = OMX_SetParameter(
            mHandle, index, const_cast<void *>(params));

    return StatusFromOMXError(err);
}

 

看下 OMX_SetParameter實現

 

#define OMX_SetParameter(                                   \
        hComponent,                                         \
        nParamIndex,                                        \
        pComponentParameterStructure)                        \
    ((OMX_COMPONENTTYPE*)hComponent)->SetParameter(         \
        hComponent,                                         \
        nParamIndex,                                        \
        pComponentParameterStructure)    /* Macro End */

 

這里可以看到主要是通過OMX_COMPONENTTYPE對象（也就是SoftMP3父類構造函數初始化過的對象）來完成工作

這里在SoftOMXComponent沒有具體實現，在SimpleSoftOMXComponent中，如下

 

OMX_ERRORTYPE SimpleSoftOMXComponent::setParameter(
        OMX_INDEXTYPE index, const OMX_PTR params) {
    Mutex::Autolock autoLock(mLock);

    CHECK(isSetParameterAllowed(index, params));

    return internalSetParameter(index, params);
}

OMX_ERRORTYPE SoftMP3::internalSetParameter(
        OMX_INDEXTYPE index, const OMX_PTR params) {
    switch (index) {
        case OMX_IndexParamStandardComponentRole:
        {
            const OMX_PARAM_COMPONENTROLETYPE *roleParams =
                (const OMX_PARAM_COMPONENTROLETYPE *)params;

            if (strncmp((const char *)roleParams->cRole,
                        "audio_decoder.mp3",
                        OMX_MAX_STRINGNAME_SIZE - 1)) {
                return OMX_ErrorUndefined;
            }

            return OMX_ErrorNone;
        }

        default:
            return SimpleSoftOMXComponent::internalSetParameter(index, params);
    }
}

這里需要注意的是調用的internalSetParameter是SoftMP3的實現，而不是SimpleSoftOMXComponent 中的，代碼如下

 

傳入的命令為：OMX_IndexParamStandardComponentRole，處理完畢后返回OMX_ErrorNone

 

這里通過OMXCodec變量借由OMXNodeInstance得到OMX_COMPONENTYPE句柄，就獲得了與解碼器實際通信的能力。

 

4 解碼過程介紹

---

下面介紹如何通過OMXCodec驅動解碼一幀數據

這里建立了OMXCodec實例之后，在awesomeplayer中的audioplayer的fillbuffer中

mAudioPlayer便通過mSource->read(&mInputBuffer, &options來讀取pcm數據

這里mSource為mAudioSource

看下read函數

具體代碼在OMXCodec.cpp中，我們分段來看

 

status_t OMXCodec::read(

       MediaBuffer **buffer, const ReadOptions *options) {

 status_t err = OK;

   *buffer = NULL;

   Mutex::Autolock autoLock(mLock);

   if (mState != EXECUTING && mState != RECONFIGURING) {

       return UNKNOWN_ERROR;

}

 

前面設置好參數后，會經過幾次回調將狀態設置成EXECUTING

這里需要注意的是mInitialBufferSubmit默認是true

 

if (mInitialBufferSubmit) {
      mInitialBufferSubmit = false;
      drainInputBuffers();
    fillOutputBuffers();
}

 

drainInputBuffers可以認為從extractor讀取一包數據

fillOutputBuffers是解碼一包數據並放在輸出buffer中

忽略seek代碼     

 

size_t index = *mFilledBuffers.begin();   mFilledBuffers.erase(mFilledBuffers.begin());
   BufferInfo *info = &mPortBuffers[kPortIndexOutput].editItemAt(index);
   CHECK_EQ((int)info->mStatus, (int)OWNED_BY_US);
   info->mStatus = OWNED_BY_CLIENT;
   info->mMediaBuffer->add_ref();
   if (mSkipCutBuffer != NULL) {
       mSkipCutBuffer->submit(info->mMediaBuffer);
   }
   *buffer = info->mMediaBuffer;
   return OK;
}

 

這里我們將輸出緩沖區中的bufferinfo取出來，並將其中的mediabuffer賦值給傳遞進來的參數buffer，當decoder解碼出來數據后會將存放數據的buffer放在mFilledBuffers中，因此audioplayer每次從omxcodec讀取數據時，會從mFilledBuffers中取。區別在於，當mFilledBuffers為空時會等待解碼器解碼並填充數據，如果有數據，則直接取走數據。

 

在audioplayer->start代碼中用到這里返回的mediabuffer做了一些事情，后面設置了一些參數如

info->mStatus = OWNED_BY_CLIENT;

說明此info歸client所有，client釋放后會歸還的，這里多啰嗦一句，通過設置mStatus可以讓這一塊內存由不同的模塊來支配，如其角色有如下幾個：

 

   enum BufferStatus {

       OWNED_BY_US,

       OWNED_BY_COMPONENT,

       OWNED_BY_NATIVE_WINDOW,

       OWNED_BY_CLIENT,

   };

顯然component是解碼器的，client是外部比如audioplayer的。

info->mMediaBuffer->add_ref();是增加一個引用，估計release的時候用~~

下面着重分析下如何從extractor讀數據，和如何解碼數據

 

4.1 看下  drainInputBuffers();實現

 

<pre name="code" class="html">void OMXCodec::drainInputBuffers() {
       for (size_t i = 0; i < buffers->size(); ++i) {
           BufferInfo *info = &buffers->editItemAt(i);
           if (info->mStatus != OWNED_BY_US) {
               continue;
           }
           if (!drainInputBuffer(info)) {
               break;
           }
           if (mFlags & kOnlySubmitOneInputBufferAtOneTime) {
               break;
           }
       }
}</pre>

 

這里解釋下，我們可能申請了多個輸入緩沖區，因此是一個循環，先檢查我們有沒有權限使用即OWNED_BY_US，這一緩沖區獲取完數據后會檢測

kOnlySubmitOneInputBufferAtOneTime即每次只允許讀一個包，否則循環都讀滿。

下面繼續跟進drainInputBuffer(info),忽略無關代碼：

 

bool OMXCodec::drainInputBuffer(BufferInfo *info) {
       **********
   status_t err;
   bool signalEOS = false;
   int64_t timestampUs = 0;
   size_t offset = 0;
   int32_t n = 0;
for (;;) {
       MediaBuffer *srcBuffer;
err = mSource->read(&srcBuffer);
       size_t remainingBytes = info->mSize - offset;
      下面是判斷從extractor讀取到的數據是不是超過了總大小
      if (srcBuffer->range_length() > remainingBytes) {
           if (offset == 0) {
               srcBuffer->release();
               srcBuffer = NULL;

      setState(ERROR);
               return false;
           }
           mLeftOverBuffer = srcBuffer;
           break;
       }                 memcpy((uint8_t *)info->mData + offset,
                       (const uint8_t *)srcBuffer->data()
                           + srcBuffer->range_offset(),
                       srcBuffer->range_length());
                 offset += srcBuffer->range_length();
if (releaseBuffer) {
           srcBuffer->release();
           srcBuffer = NULL;
       }
                 數據讀取完畢后將srcBufferrelease掉
}
   err = mOMX->emptyBuffer(
           mNode, info->mBuffer, 0, offset,
           flags, timestampUs);
   info->mStatus = OWNED_BY_COMPONENT;
}

這里讀取完畢后將緩沖區的狀態設置成OWNED_BY_COMPONENT 解碼器就可以解碼了

 

這里可以看出來讀取數據時實現了一次拷貝~~，而不是用的同一塊緩沖區，注意下

讀取數據可以參考前面介紹的extractor的內容，比較簡單不說了。

下面看讀取數據完畢后調用mOMX->emptyBuffer都干了些啥

通過前面我們很容易的理解實際調用的是

omx::emptybufferèOMXNodeInstance::emptyBuffer,

從代碼可以看到最終調用的是

((OMX_COMPONENTTYPE*)hComponent)->EmptyThisBuffer()

實際代碼在SimpleSoftOMXComponent.cpp中，具體如下

 

OMX_ERRORTYPE SimpleSoftOMXComponent::emptyThisBuffer(
       OMX_BUFFERHEADERTYPE *buffer) {
   sp<AMessage> msg = new AMessage(kWhatEmptyThisBuffer, mHandler->id());
   msg->setPointer("header", buffer);
   msg->post();
   return OMX_ErrorNone;
}

 

可以看到就是發了一條命令kWhatEmptyThisBuffer

通過handler->id確定了自己發的還得自己收，處理函數如下：

 

void SimpleSoftOMXComponent::onMessageReceived(const sp<AMessage> &msg) {
   Mutex::Autolock autoLock(mLock);
   uint32_t msgType = msg->what();
   ALOGV("msgType = %d", msgType);
   switch (msgType) {
********
       case kWhatEmptyThisBuffer:
       case kWhatFillThisBuffer:
       {
           OMX_BUFFERHEADERTYPE *header;
           CHECK(msg->findPointer("header", (void **)&header));
           CHECK(mState == OMX_StateExecuting && mTargetState == mState);
           bool found = false;
           size_t portIndex = (kWhatEmptyThisBuffer == msgType)?                   header->nInputPortIndex: header->nOutputPortIndex;
           PortInfo *port = &mPorts.editItemAt(portIndex);
           for (size_t j = 0; j < port->mBuffers.size(); ++j) {
               BufferInfo *buffer = &port->mBuffers.editItemAt(j);

               if (buffer->mHeader == header) {
                   CHECK(!buffer->mOwnedByUs);
                   buffer->mOwnedByUs = true;
                   CHECK((msgType == kWhatEmptyThisBuffer
                           && port->mDef.eDir == OMX_DirInput)|| (port->mDef.eDir == OMX_DirOutput));
                   port->mQueue.push_back(buffer);
                   onQueueFilled(portIndex);
               found = true;
                   break;
               }
           }
           CHECK(found);
           break;
       }
       default:
           TRESPASS();
           break;
   }
}

 

從代碼這里來看這兩個case都走同一套代碼，而且都是通過onQueueFilled來處理，這樣我們就引出了實際的處理函數，也就是onQueueFilled，

以mp3為例這里具體實現在SoftMP3中。

具體解釋看代碼中注釋

 

void SoftMP3::onQueueFilled(OMX_U32 portIndex) {
    if (mSignalledError || mOutputPortSettingsChange != NONE) {
        return;
    }

    獲取輸入輸出鏈表

    List<BufferInfo *> &inQueue = getPortQueue(0);
    List<BufferInfo *> &outQueue = getPortQueue(1);

    while (!inQueue.empty() && !outQueue.empty()) {

        各自取輸入輸出緩沖區中的第一個緩沖區
        BufferInfo *inInfo = *inQueue.begin();
        OMX_BUFFERHEADERTYPE *inHeader = inInfo->mHeader;

        BufferInfo *outInfo = *outQueue.begin();
        OMX_BUFFERHEADERTYPE *outHeader = outInfo->mHeader;

        判斷緩沖區是不是沒有數據，若果第一個都沒有那就是沒有

        if (inHeader->nFlags & OMX_BUFFERFLAG_EOS) {
            inQueue.erase(inQueue.begin());
            inInfo->mOwnedByUs = false;
            notifyEmptyBufferDone(inHeader);

            if (!mIsFirst) {
                // pad the end of the stream with 529 samples, since that many samples
                // were trimmed off the beginning when decoding started
                outHeader->nFilledLen =
                    kPVMP3DecoderDelay * mNumChannels * sizeof(int16_t);

                memset(outHeader->pBuffer, 0, outHeader->nFilledLen);
            } else {
                // Since we never discarded frames from the start, we won't have
                // to add any padding at the end either.
                outHeader->nFilledLen = 0;
            }

            outHeader->nFlags = OMX_BUFFERFLAG_EOS;

            outQueue.erase(outQueue.begin());
            outInfo->mOwnedByUs = false;
            notifyFillBufferDone(outHeader);
            return;
        }



        如果offset==0說明是第一包的開頭，需要讀取pts，請結合extractor理解

        if (inHeader->nOffset == 0) {
            mAnchorTimeUs = inHeader->nTimeStamp;
            mNumFramesOutput = 0;
        }

        mConfig->pInputBuffer =
            inHeader->pBuffer + inHeader->nOffset;

        mConfig->inputBufferCurrentLength = inHeader->nFilledLen;
        mConfig->inputBufferMaxLength = 0;
        mConfig->inputBufferUsedLength = 0;

        mConfig->outputFrameSize = kOutputBufferSize / sizeof(int16_t);

        mConfig->pOutputBuffer =
            reinterpret_cast<int16_t *>(outHeader->pBuffer);

        ERROR_CODE decoderErr;

        上面是配置參數 下面調用自己的解碼器進行解碼
        if ((decoderErr = pvmp3_framedecoder(mConfig, mDecoderBuf))
                != NO_DECODING_ERROR) {
           ***出錯處理*

            這里注意如果解碼失敗，則填充0數據，也就是靜音幀
            // play silence instead.
            memset(outHeader->pBuffer,
                   0,
                   mConfig->outputFrameSize * sizeof(int16_t));

            mConfig->inputBufferUsedLength = inHeader->nFilledLen;
        } else if (mConfig->samplingRate != mSamplingRate
                || mConfig->num_channels != mNumChannels) {

            這里說明參數發生了改變，即采樣率等改變了，需要重新設置輸出
            mSamplingRate = mConfig->samplingRate;
            mNumChannels = mConfig->num_channels;

            notify(OMX_EventPortSettingsChanged, 1, 0, NULL);
            mOutputPortSettingsChange = AWAITING_DISABLED;
            return;
        }

        if (mIsFirst) {
            mIsFirst = false;
            // The decoder delay is 529 samples, so trim that many samples off
            // the start of the first output buffer. This essentially makes this
            // decoder have zero delay, which the rest of the pipeline assumes.
            outHeader->nOffset =
                kPVMP3DecoderDelay * mNumChannels * sizeof(int16_t);

            outHeader->nFilledLen =
                mConfig->outputFrameSize * sizeof(int16_t) - outHeader->nOffset;
        } else {
            outHeader->nOffset = 0;
            outHeader->nFilledLen = mConfig->outputFrameSize * sizeof(int16_t);
        }

        outHeader->nTimeStamp =
            mAnchorTimeUs
                + (mNumFramesOutput * 1000000ll) / mConfig->samplingRate;

        outHeader->nFlags = 0;

        CHECK_GE(inHeader->nFilledLen, mConfig->inputBufferUsedLength);

        inHeader->nOffset += mConfig->inputBufferUsedLength;
        inHeader->nFilledLen -= mConfig->inputBufferUsedLength;

        mNumFramesOutput += mConfig->outputFrameSize / mNumChannels;

        如果輸入緩沖區數據都解碼完了，則調用notifyEmptyBufferDone

        if (inHeader->nFilledLen == 0) {
            inInfo->mOwnedByUs = false;
            inQueue.erase(inQueue.begin());
            inInfo = NULL;
            notifyEmptyBufferDone(inHeader);
            inHeader = NULL;
        }

        outInfo->mOwnedByUs = false;
        outQueue.erase(outQueue.begin());
        outInfo = NULL;

        這是將解碼出來的數據告訴外部，通過調用notifyFillBufferDone

        notifyFillBufferDone(outHeader);
        outHeader = NULL;
    }
}

 

下面分析下，如何將輸入緩沖區釋放和將輸出緩沖區中的數據傳遞出去

A、輸入部分的清空

 

void SoftOMXComponent::notifyEmptyBufferDone(OMX_BUFFERHEADERTYPE *header) {

   (*mCallbacks->EmptyBufferDone)(

           mComponent, mComponent->pApplicationPrivate, header);

}

 

通知外面我們emptythisbuffer完工了，具體調用的是OMXNodeInstance中的方法，具體怎么傳進去的，大家可以自己分析下：

 

OMX_ERRORTYPE OMXNodeInstance::OnEmptyBufferDone(
       OMX_IN OMX_HANDLETYPE hComponent,
       OMX_IN OMX_PTR pAppData,
       OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) {
   OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData);
   if (instance->mDying) {
       return OMX_ErrorNone;
   }
   return instance->owner()->OnEmptyBufferDone(instance->nodeID(), pBuffer);
}

 

OMXNodeInstance的ownner是OMX，因此代碼為

 

OMX_ERRORTYPE OMX::OnEmptyBufferDone(

       node_id node, OMX_IN OMX_BUFFERHEADERTYPE *pBuffer) {

   ALOGV("OnEmptyBufferDone buffer=%p", pBuffer);

   omx_message msg;

   msg.type = omx_message::EMPTY_BUFFER_DONE;

   msg.node = node;

   msg.u.buffer_data.buffer = pBuffer;

   findDispatcher(node)->post(msg);

   return OMX_ErrorNone;

}

 

 其中findDispatcher定義如下

 

sp<OMX::CallbackDispatcher> OMX::findDispatcher(node_id node) {
    Mutex::Autolock autoLock(mLock);
    ssize_t index = mDispatchers.indexOfKey(node);
    return index < 0 ? NULL : mDispatchers.valueAt(index);
}

 

這里mDispatcher在之前allocateNode中通過mDispatchers.add(*node, new CallbackDispatcher(instance)); 創建的

看下實際的實現可知道，CallbackDispatcher的post方法最終會調用dispatch

 

void OMX::CallbackDispatcher::dispatch(const omx_message &msg) {
    if (mOwner == NULL) {
        ALOGV("Would have dispatched a message to a node that's already gone.");
        return;
    }
    mOwner->onMessage(msg);
}

 

而owner是OMXNodeInstance，因此消息饒了一圈還是到了OMXNodeInstance的OnMessage方法接收了

 

void OMXNodeInstance::onMessage(const omx_message &msg) {
    if (msg.type == omx_message::FILL_BUFFER_DONE) {
        OMX_BUFFERHEADERTYPE *buffer =
            static_cast<OMX_BUFFERHEADERTYPE *>(
                    msg.u.extended_buffer_data.buffer);

        BufferMeta *buffer_meta =
            static_cast<BufferMeta *>(buffer->pAppPrivate);

        buffer_meta->CopyFromOMX(buffer);
    }

    mObserver->onMessage(msg);
}

 

而onMessage又將消息傳遞到 mObserver中，也就是在OMXCodec::Create中構造的OMXCodecObserver對象，其OnMessage實現如下

 

virtual void onMessage(const omx_message &msg) {
    sp<OMXCodec> codec = mTarget.promote();

    if (codec.get() != NULL) {
        Mutex::Autolock autoLock(codec->mLock);
        codec->on_message(msg);
        codec.clear();
    }
}

 

最終還是傳遞給了OMXCodec里，具體看下：

 

void OMXCodec::on_message(const omx_message &msg) {
switch (msg.type) {
************
       case omx_message::EMPTY_BUFFER_DONE:
       {
           IOMX::buffer_id buffer = msg.u.extended_buffer_data.buffer;
           Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexInput];
           size_t i = 0;
           while (i < buffers->size() && (*buffers)[i].mBuffer != buffer) {
               ++i;
           }
           BufferInfo* info = &buffers->editItemAt(i);
           info->mStatus = OWNED_BY_US;
           // Buffer could not be released until empty buffer done is called.
           if (info->mMediaBuffer != NULL) {
               info->mMediaBuffer->release();
               info->mMediaBuffer = NULL;
           }
           drainInputBuffer(&buffers->editItemAt(i));
           break;
       }
****************
}

這部分很繞，但搞清楚就好了，請大家仔細閱讀，此處雖然調用了info->mMediaBuffer->release();但是由於其引用始終大於0，因此不會真正的release

 

二是當release完畢后，會調用drainInputBuffer(&buffers->editItemAt(i));來填充數據

也就是說當我們啟動一次解碼播放后，會在此處循環讀取數和據解碼數據。而輸出數據在后面的filloutbuffer中。

 

B、輸出數據的清空notifyFillBufferDone(outHeader);

 

void SoftOMXComponent::notifyFillBufferDone(OMX_BUFFERHEADERTYPE *header) {
   (*mCallbacks->FillBufferDone)(
           mComponent, mComponent->pApplicationPrivate, header);
}

 

 

OMX_ERRORTYPE OMX::OnFillBufferDone(
       node_id node, OMX_IN OMX_BUFFERHEADERTYPE *pBuffer) {
   ALOGV("OnFillBufferDone buffer=%p", pBuffer);
   omx_message msg;
   msg.type = omx_message::FILL_BUFFER_DONE;
   msg.node = node;
   msg.u.extended_buffer_data.buffer = pBuffer;
   msg.u.extended_buffer_data.range_offset = pBuffer->nOffset;
   msg.u.extended_buffer_data.range_length = pBuffer->nFilledLen;
   msg.u.extended_buffer_data.flags = pBuffer->nFlags;
   msg.u.extended_buffer_data.timestamp = pBuffer->nTimeStamp;
   msg.u.extended_buffer_data.platform_private = pBuffer->pPlatformPrivate;
   msg.u.extended_buffer_data.data_ptr = pBuffer->pBuffer;
   findDispatcher(node)->post(msg);
   return OMX_ErrorNone;
}

 

最終處理在OMXCodec.cpp中

 

void OMXCodec::on_message(const omx_message &msg) {
{
case omx_message::FILL_BUFFER_DONE:
               info->mStatus = OWNED_BY_US;
               mFilledBuffers.push_back(i);
               mBufferFilled.signal();
           break;
       }
}

主體就這么幾句，先將mStatus設置成OWNED_BY_US，這樣component便不能操作了，后面將這個buffer push到mFilledBuffers中。

 

 

4.2 fillOutputBuffers

 

void OMXCodec::fillOutputBuffers() {
   CHECK_EQ((int)mState, (int)EXECUTING);
   Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexOutput];
   for (size_t i = 0; i < buffers->size(); ++i) {
       BufferInfo *info = &buffers->editItemAt(i);
       if (info->mStatus == OWNED_BY_US) {
           fillOutputBuffer(&buffers->editItemAt(i));
       }
   }
}

 

找到一個輸出緩沖區bufferinfo，啟動輸出

 

void OMXCodec::fillOutputBuffer(BufferInfo *info) {
   **************
   status_t err = mOMX->fillBuffer(mNode, info->mBuffer);
   info->mStatus = OWNED_BY_COMPONENT;
}

 

下面和解碼流程類似，我們依次來看：

 

status_t OMXNodeInstance::fillBuffer(OMX::buffer_id buffer) {
   Mutex::Autolock autoLock(mLock);
   OMX_BUFFERHEADERTYPE *header = (OMX_BUFFERHEADERTYPE *)buffer;
   header->nFilledLen = 0;
   header->nOffset = 0;
   header->nFlags = 0;
   OMX_ERRORTYPE err = OMX_FillThisBuffer(mHandle, header);
   return StatusFromOMXError(err);
}

 

進行一些初始化后，調用進入了softMP3中，也就是

 

OMX_ERRORTYPE SimpleSoftOMXComponent::fillThisBuffer(
       OMX_BUFFERHEADERTYPE *buffer) {
   sp<AMessage> msg = new AMessage(kWhatFillThisBuffer, mHandler->id());
   msg->setPointer("header", buffer);
   msg->post();
   return OMX_ErrorNone;
}

 

同理，接收程序也在本文件中：

 

void SimpleSoftOMXComponent::onMessageReceived(const sp<AMessage> &msg) {
   Mutex::Autolock autoLock(mLock);
   uint32_t msgType = msg->what();
   ALOGV("msgType = %d", msgType);
   switch (msgType) {
       case kWhatEmptyThisBuffer:
       case kWhatFillThisBuffer:
       {
           OMX_BUFFERHEADERTYPE *header;
           CHECK(msg->findPointer("header", (void **)&header));
           CHECK(mState == OMX_StateExecuting && mTargetState == mState);
           bool found = false;
           size_t portIndex = (kWhatEmptyThisBuffer == msgType)?
                   header->nInputPortIndex: header->nOutputPortIndex;
           PortInfo *port = &mPorts.editItemAt(portIndex);
           for (size_t j = 0; j < port->mBuffers.size(); ++j) {
               BufferInfo *buffer = &port->mBuffers.editItemAt(j);
               if (buffer->mHeader == header) {
                   CHECK(!buffer->mOwnedByUs);
                   buffer->mOwnedByUs = true;
                CHECK((msgType == kWhatEmptyThisBuffer
                           && port->mDef.eDir == OMX_DirInput)
                           || (port->mDef.eDir == OMX_DirOutput));
                   port->mQueue.push_back(buffer);
                 onQueueFilled(portIndex);
                   found = true;
                   break;
               }
           }
           CHECK(found);
           break;
       }
       default:
           TRESPASS();
           break;
   }

}

也會調用void SoftMP3::onQueueFilled執行一次解碼操作，然后再通過

 

notifyEmptyBufferDone(inHeader);

notifyFillBufferDone(outHeader);

兩個函數來推進播放進度。

 

【結束】