AwesomePlayer

AwesomePlayer

AwesomePlayer就是用openmax来做(code)编解码,其实在openmax接口设计中，他不光能用来当编解码。通过他的组件可以组成一个完整的播放器，包括sourc、demux、decode、output

数据读取、解码流程：

1、DataSource：
数据源，source的任务就是把数据源抽象出来，为下一个demux模块提供它需要的稳定的数据流。
实现：
AwesomePlayer 通过setDataSource 指定播放器的数据源。可以是URI或者fd.可以是http:// 、rtsp://、本地地址或者本地文件描述符fd。其最终调用是将上层传递来的参数转化为DataSource，为下一步的demux提供数据支持。
2、Demux解复用：
demux的功能就是把音视频的ES流从容器中剥离出来，然后分别送到不同的解码器中。其实音频和视频本身就是2个独立的系统。容器把它们包在了一起。但是他们都是独立解码的，所以解码之前，需要把它分别 独立出来。为decoder解码提供数据流。
实现：
通过DataSource来生成extractor，得到extractor之后，通过setVideoSource() setAudioSource()产生独立的mVideoTrack(视频)、mAudioTrack(音频)数据流，分别为音视频解码器提供有各自需要的数据流。即extractor和mVideoTrack、mAudioTrack就组成了播放器模型中的demuxer部分。把封装格式里面的音视频流拆分出来，分别的送给音视频解码器
3、Decoder解码：
解码器–播放器的核心模块。分为音频和视频解码器。 音视频解码器的作用就是把这些压缩了的数据诸如MPEG1（VCD）\ MPEG2（DVD）\ MPEG4 \ H.264 等还原成原始的音视频数据. 当然, 编码解码过程基本上都是有损的 .解码器的作用就是把编码后的数据还原成原始数据。
实现：
AwesomePlayer调用initVideoDecoder() initAudioDecoder().依赖上面产生的mVideoTrack(视频)、mAudioTrack(音频)数据流。生成mVideoSource和mAudioSource这两个音视频解码器，AwesomePlayer中mVideoSource、mAudioSource组成了播放器模型中的decoder部分
4、output输出：
输出部分分为音频和视频输出。解码后的音频（pcm）和视频（yuv）的原始数据需要得到音视频的output模块的支持才能真正的让人的感官系统（眼和耳）辨识到。
实现：
AwesomePlayer分别用了mVideoRenderer做视频输出、mAudioPlayer做音频输出
AwesomePlayer调用mVideoSource->read(&mVideoBuffer, &options);读取帧数据、解码，由mVideoRenderer->render(mVideoBuffer)对经过parse和decode 处理的数据进行渲染显示

AwesomePlayer底层调用实现：

1、android系统中只用openmax来做code，所以android向上抽象了一层OMXCodec，提供给上层播放器用。播放器中音视频解码器mVideosource、mAudiosource都是OMXCodec的实例。
2、OMXCodec通过IOMX 依赖binder机制 获得 OMX服务，OMX服务 才是openmax 在android中 实现。
3、OMX把软编解码和硬件编解码统一看作插件的形式管理起来

OMXCodec的服务接口. 也就是解码时又通过Binder做了一次跨进程通信.
OMXCodec Service文件:
IOMX.h //接口定义
客户端类:
OMXCodec.cpp
OMXClient.cpp
IOMX.cpp (BpOMX类/BnOMX类)
服务端类:
OMX.cpp
OMXNodeInstance.cpp

1、调用AwesomePlayer
AwesomePlayer->OMXClient->MediaPlayerService->创建OMX的实例

AwesomePlayer.h:

...
    mutable Mutex mLock;
    Mutex mMiscStateLock;
    mutable Mutex mStatsLock;
    Mutex mAudioLock;
   //OMXClient是android中openmax的入口 
   OMXClient mClient;
   TimedEventQueue mQueue;
   bool mQueueStarted;
   wp<MediaPlayerBase> mListener;
   bool mUIDValid;
   uid_t mUID;

   sp<ANativeWindow> mNativeWindow;
   sp<MediaPlayerBase::AudioSink> mAudioSink;

   SystemTimeSource mSystemTimeSource;
   TimeSource *mTimeSource;

   String8 mUri;
   KeyedVector<String8, String8> mUriHeaders;
   sp<DataSource> mFileSource;

   sp<MediaSource> mVideoTrack;
   sp<MediaSource> mVideoSource;
   sp<AwesomeRenderer> mVideoRenderer;
   bool mVideoRendererIsPreview;

   sp<MediaSource> mAudioTrack;
   sp<MediaSource> mAudioSource;
....

AwesomePlayer.cpp

AwesomePlayer::AwesomePlayer()
    : mQueueStarted(false),
      mUIDValid(false),
      mTimeSource(NULL),
      mVideoRendererIsPreview(false),
      mAudioPlayer(NULL),
      mDisplayWidth(0),
      mDisplayHeight(0),
      mFlags(0),
      mExtractorFlags(0),
      mVideoBuffer(NULL),
      mDecryptHandle(NULL),
      mLastVideoTimeUs(-1),
      mTextPlayer(NULL)
{
    //OMXClient::connect函数是通过binder机制获得到MediaPlayerService，
    //然后通过MediaPlayerService来创建OMX的实例
    CHECK_EQ(mClient.connect(), (status_t)OK);
    DataSource::RegisterDefaultSniffers();
    mVideoEvent = new AwesomeEvent(this, &AwesomePlayer::onVideoEvent);
    mVideoEventPending = false;
    mStreamDoneEvent = new AwesomeEvent(this, &AwesomePlayer::onStreamDone);
    mStreamDoneEventPending = false;
    mBufferingEvent = new AwesomeEvent(this, &AwesomePlayer::onBufferingUpdate);
    mBufferingEventPending = false;
    mVideoLagEvent = new AwesomeEvent(this, &AwesomePlayer::onVideoLagUpdate);
    mVideoEventPending = false;

   mCheckAudioStatusEvent = new AwesomeEvent(
            this, &AwesomePlayer::onCheckAudioStatus);
    mAudioStatusEventPending = false;
#ifdef SLSI_ULP_AUDIO
    mLibAudioHandle = NULL;
    mIsULPAudio = false;
    mUseULPAudio = false;
#endif
    reset();
}

OMXClient.h

class OMXClient {
public:
    OMXClient();
    status_t connect();
    void disconnect();
   sp<IOMX> interface() {
        return mOMX; 
    }
private:
    sp<IOMX> mOMX;   //IOMX的变量mOMX，就是和OMX服务进行binder通讯的。
    OMXClient(const OMXClient &);
    OMXClient &operator=(const OMXClient &);
};

OMXClient.cpp

status_t OMXClient::connect() {
    sp<IServiceManager> sm = defaultServiceManager();
    //通过binder机制获得到MediaPlayerService
    sp<IBinder> binder = sm->getService(String16("media.player"));
    sp<IMediaPlayerService> service = interface_cast<IMediaPlayerService>(binder);
    CHECK(service.get() != NULL);
    mOMX = service->getOMX(); //通过binder机制来获得OMX提供的服务
    CHECK(mOMX.get() != NULL);
    return OK;
}

IMediaPlayerService.cpp

virtual sp<IOMX> getOMX() {
       Parcel data, reply;        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
       remote()->transact(GET_OMX, data, &reply);
       return interface_cast<IOMX>(reply.readStrongBinder());
}

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

2、创建音视频解码mVideoSource、mAudioSource
把OMXClient中的sp mOMX的实例传给mVideoSource、mAudioSource来共享使用这个OMX的入口。也就是说一个AwesomePlayer对应着 一个IOMX 变量，AwesomePlayer中的音视频解码器共用这个IOMX变量来获得OMX服务。

sp<IOMX> interface() {  
      return mOMX;  
}  
mAudioSource = OMXCodec::Create(  
                mClient.interface(), mAudioTrack->getFormat(),  
                false, // createEncoder  
                mAudioTrack);  
mVideoSource = OMXCodec::Create(  
            mClient.interface(), mVideoTrack->getFormat(),  
            false, // createEncoder  
            mVideoTrack,  
            NULL, flags, USE_SURFACE_ALLOC ? mNativeWindow : NULL);  

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

3、OMXMaster
a: OMX中 OMXNodeInstance 负责创建并维护不同的实例，这些实例是根据上面需求创建的，以node作为唯一标识。这样播放器中每个OMXCodec在OMX服务端都对应有了自己的OMXNodeInstance实例。
b: OMXMaster 维护底层软硬件解码库，根据OMXNodeInstance中想要的解码器来创建解码实体组件。接下来我们假设视频解码器需要的是AVC，来看看解码器创建的流程。

OMXMaster初始化
OMXMaster 负责OMX中编解码器插件管理，软件解码和硬件解码都是使用OMX标准，挂载plugins的方式来进行管理。
软件编解码:
—通过addPlugin(new SoftOMXPlugin);会把这些编解码器的名字都放在mPluginByComponentName中。android 默认会提供一系列的软件解码器。目前支持这些格式的软编解码。
硬件编解码:
—通过 addVendorPlugin();加载libstagefrighthw.so.各个芯片平台可以遵循openmax标准,生成libstagefrighthw.so的库来提供android应用。

OMXMaster *mMaster; //OMXMaster负责OMX中编解码器插件管理
OMX::OMX()  
    : mMaster(new OMXMaster), //OMX构造函数中进行初始化mMaster
      mNodeCounter(0) {  
}  
OMXMaster::OMXMaster()  
    : mVendorLibHandle(NULL) {  
    addVendorPlugin();  //添加硬件编解码插件
    addPlugin(new SoftOMXPlugin); //添加软件编解码插件 
}  
void OMXMaster::addVendorPlugin() {  
    addPlugin("libstagefrighthw.so");  
} 

addPlugin()通过dlopen、dlsym来调用库中的函数。这部分准备工作是在AwesomePlayer的构造函数中CHECK_EQ(mClient.connect(), (status_t)OK);已经完成了。

4、创建mVideoSource
有了上面的OMX，接下来会在AwesomePlayer::initVideoDecoder中创建mVideoSource
核心函数调用流程：
AwesomePlayer::initVideoDecoder()
=>OMXCodec::Create()
=> OMX::allocateNode()
=> OMXMaster::makeComponentInstance()
=> SoftOMXPlugin::makeComponentInstance()
=> createSoftOMXComponent()

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; 

    //1、根据mVideoTrack传进来的视频信息，查找相匹配的解码器
    findMatchingCodecs(  
            mime, createEncoder, matchComponentName, flags,  
            &matchingCodecs, &matchingCodecQuirks);  
    //2、创建OMXCodecObserver实例，创建一个node并初始化为0
    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; 
        //3、在OMX服务端创建一个和mVideoSource相匹配的解码实例，node值作为唯一标识：    
        //   通过omx入口，依靠binder机制调用OMX服务中的allocateNode()，
        //   把匹配得到的解码器组件名、OMXCodecObserver实例和node值传入
        status_t err = omx->allocateNode(componentName, observer, &node);  
        if (err == OK) {  
            ALOGV("Successfully allocated OMX node '%s'", componentName); 
            // 通过绑定omx、node值对应的编解码插件来产生具体OMXCodec实例
            sp<OMXCodec> codec = new OMXCodec(  
                    omx, node, quirks, flags,  
                    createEncoder, mime, componentName,  
                    source, nativeWindow); //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;  
}  

status_t OMX::allocateNode(const char *name, const sp<IOMXObserver> &observer, node_id *node) {  
    Mutex::Autolock autoLock(mLock);  
    *node = 0;  
    //4、创建一个OMXNodeInstance实例
    OMXNodeInstance *instance = new OMXNodeInstance(this, observer);  
    OMX_COMPONENTTYPE *handle; 
    //创建真正解码器的组件，并通过handle与OMXNodeInstance关联 
    //参数name：会把mVideoSource需要的解码器name一直传递下去
    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;  
}  

OMX_ERRORTYPE OMXMaster::makeComponentInstance(  
        const char *name,   //解码器的name值
        const OMX_CALLBACKTYPE *callbacks,  
        OMX_PTR appData,  
        OMX_COMPONENTTYPE **component) {  
    Mutex::Autolock autoLock(mLock);  
    *component = NULL;  
    //mPluginByComponentName支持的软解码插件
    ssize_t index = mPluginByComponentName.indexOfKey(String8(name)); 
    if (index < 0) {  
        return OMX_ErrorInvalidComponentName;  
    } 
    OMXPluginBase *plugin = mPluginByComponentName.valueAt(index); 
    //5、创建真正的软解码插件实例
    OMX_ERRORTYPE err =  
    plugin->makeComponentInstance(name, callbacks, appData, component);  
    if (err != OMX_ErrorNone) {  
        return err;  
    }  
    mPluginByInstance.add(*component, plugin);  
    return err;  
}  

//组件信息
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::makeComponentInstance(  
        const char *name, //上层传下来的解码器name，根据该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");  
        //通过dlopen、dlsym来调用库中函数
        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;  
        } 
        //6、创建真正的解码器实例
        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);  
}  

5、mVideoRenderer
AwesomePlayer中得到这个OMXCodec后，首先调用mVideoSource->start()进行初始化。 OMXCodec初始化主要是做两件事：
a： 向OpenMAX发送开始命令。mOMX->sendCommand(mNode, OMX_CommandStateSet, OMX_StateIdle)
b： 调用allocateBuffers()分配两个缓冲区，存放在Vector mPortBuffers[2]中，分别用于输入和输出。

AwesomePlayer开始播放后，通过mVideoSource->read(&mVideoBuffer, &options)读取数据，实际调用OMXCodec.read来读取数据。而OMXCodec.read主要分两步来实现数据的读取：
a：通过调用drainInputBuffers()对mPortBuffers[kPortIndexInput]进行填充，这一步完成 parse。由OpenMAX从数据源把demux后的数据读取到输入缓冲区，作为OpenMAX的输入。
b：通过fillOutputBuffers()对mPortBuffers[kPortIndexOutput]进行填充，这一步完成 decode。由OpenMAX对输入缓冲区中的数据进行解码，然后把解码后可以显示的视频数据输出到输出缓冲区。

AwesomePlayer通过mVideoRenderer->render(mVideoBuffer)对经过parse和decode 处理的数据进行渲染。一个mVideoRenderer其实就是一个包装了IOMXRenderer的AwesomeRemoteRenderer：

mVideoRenderer = new AwesomeRemoteRenderer(
                mClient.interface()->createRenderer(
                        mISurface, component,
                        (OMX_COLOR_FORMATTYPE)format,
                        decodedWidth, decodedHeight,
                                    mVideoWidth, mVideoHeight,
                        rotationDegrees));

数据读取解码流程总结：
1、AwesomePlayer中通过initVideoDecoder 来创建video解码器mVideoSource
2、mVideoSource 中通过上部分demux后的视频流 mVideoTrack来获得解码器的类型，通过类型调用omx->allocateNode创建omx node实例与自己对应。以后都是通过node实例来操作解码器。
3、在 omx->allocateNode中 通过mMaster->makeComponentInstance
来创建真正对应的解码器组件。这个解码器组件是完成之后解码实际工作的。
4、在创建mMaster->makeComponentInstance过程中，也是通过上面mVideoTrack
过来的解码器类型名，找到相对应的解码器的库，然后实例化。
5、通过mVideoSource->read(&mVideoBuffer, &options)读取数据，实际调用OMXCodec.read来读取数据。
6、通过mVideoRenderer->render(mVideoBuffer)对经过parse和decode 处理的数据进行渲染