Android多媒体开发-stagefright及AwesomePlayer相关知识梳理

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

sp<MediaSource> OMXCodec::Create(  
        const sp<IOMX> &omx,  
        const sp<MetaData> &meta, bool createEncoder,  
        const sp<MediaSource> &source,  
        const char *matchComponentName,  
        uint32_t flags,  
        const sp<ANativeWindow> &nativeWindow) {  
    int32_t requiresSecureBuffers;  
      
    const char *mime;  
    bool success = meta->findCString(kKeyMIMEType, &mime);  
    CHECK(success);  
  
    Vector<String8> matchingCodecs;  
    Vector<uint32_t> matchingCodecQuirks;  
    findMatchingCodecs(  
            mime, createEncoder, matchComponentName, flags,  
            &matchingCodecs, &matchingCodecQuirks);  
  
    sp<OMXCodecObserver> observer = new OMXCodecObserver;  
    IOMX::node_id node = 0;  
  
    for (size_t i = 0; i < matchingCodecs.size(); ++i) {  
        const char *componentNameBase = matchingCodecs[i].string();  
        uint32_t quirks = matchingCodecQuirks[i];  
        const char *componentName = componentNameBase;  
  
        AString tmp;  
     
        status_t err = omx->allocateNode(componentName, observer, &node);  
        if (err == OK) {  
            ALOGV("Successfully allocated OMX node ‘%s‘", componentName);  
  
            sp<OMXCodec> codec = new OMXCodec(  
                    omx, node, quirks, flags,  
                    createEncoder, mime, componentName,  
                    source, nativeWindow);  
  
            observer->setCodec(codec);  
  
            err = codec->configureCodec(meta);  
  
            if (err == OK) {  
                if (!strcmp("OMX.Nvidia.mpeg2v.decode", componentName)) {  
                    codec->mFlags |= kOnlySubmitOneInputBufferAtOneTime;  
                }  
  
                return codec;  
            }  
  
            ALOGV("Failed to configure codec ‘%s‘", componentName);  
        }  
    }  
  
    return NULL;  
}  

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;  
}  

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;  
}  

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