Android MediaPlayer整體架構原始碼分析 -【MediaCodec編解碼器插件模塊化注冊和創建處理流程】【Part 1】

Android native MediaCodec編解碼器模塊化注冊和創建處理流程
本系列文章分析的安卓原始碼版本：【Android 10.0 版本】

從【六】Android MediaPlayer整體架構原始碼分析 -【start請求播放處理流程】【Part 4】章節分析中涉及到了MediaCodec編解碼器創建處理流程，因此有必要此章節單獨分析編解碼器創建流程，主要會涉及到OpenMAX框架的實作和互動，
TODO 未完待續

推薦涉及到的知識點：
Binder機制實作原理：Android C++底層Binder通信機制原理分析總結【通俗易懂】
ALooper機制實作原理：Android native層媒體通信架構AHandler/ALooper機制實作原始碼分析
Binder例外關閉監聽：Android native層DeathRecipient對關聯行程（如相關Service服務行程）例外關閉通知事件的監聽實作原始碼分析

在start請求播放處理流程中有如下涉及代碼：【省略其他代碼】
有兩種創建方式，format引數表示的是音頻或視頻track的媒體元資料資訊（KV值），

// [frameworks/av/media/libmediaplayerservice/nuplayer/NuPlayerDecoder.cpp]
void NuPlayer::Decoder::onConfigure(const sp<AMessage> &format) {
    CHECK(mCodec == NULL);

	// 獲取音頻或視頻mime格式
    AString mime;
    CHECK(format->findString("mime", &mime));

    // 通過檔案擴展格式mime判斷
    mIsAudio = !strncasecmp("audio/", mime.c_str(), 6);
    // MEDIA_MIMETYPE_VIDEO_AVC："video/avc"
    mIsVideoAVC = !strcasecmp(MEDIA_MIMETYPE_VIDEO_AVC, mime.c_str());
	
	// 在該值后面添加decoder字串
    mComponentName = mime;
    mComponentName.append(" decoder");
    ALOGV("[%s] onConfigure (surface=%p)", mComponentName.c_str(), mSurface.get());
    
    // 創建MediaCodec解碼器
    
    // 第一種創建方式：根據檔案擴展格式mime值
    // 見第1小節分析
    mCodec = MediaCodec::CreateByType(
            mCodecLooper, mime.c_str(), false /* encoder */, NULL /* err */, mPid, mUid);
   
   // 第二種創建方式：根據編碼器組建名稱
   // 見第2小節分析
            ALOGI("[%s] creating", mComponentName.c_str());
            mCodec = MediaCodec::CreateByComponentName(
                    mCodecLooper, mComponentName.c_str(), NULL /* err */, mPid, mUid);
}

1、MediaCodec::CreateByType() 實作分析：
方法宣告

// [frameworks/av/media/libstagefright/include/media/stagefright/MediaCodec.h]

    static const pid_t kNoPid = -1;
    static const uid_t kNoUid = -1;

    static sp<MediaCodec> CreateByType(
            const sp<ALooper> &looper, const AString &mime, bool encoder, status_t *err = NULL,
            pid_t pid = kNoPid, uid_t uid = kNoUid);

方法實作

// [frameworks/av/media/libstagefright/MediaCodec.cpp]
// static
sp<MediaCodec> MediaCodec::CreateByType(
        const sp<ALooper> &looper, const AString &mime, bool encoder, status_t *err, pid_t pid,
        uid_t uid) {
    Vector<AString> matchingCodecs;
	// 根據方法名可知，此處為查詢匹配可處理指定mime型別格式資料的編/解碼器組件名集合，快取在[matchingCodecs]中回傳
	// 見1.1小節分析
    MediaCodecList::findMatchingCodecs(
            mime.c_str(),
            encoder,
            0,
            &matchingCodecs);

	// err為呼叫端傳入可用于接收錯誤碼
    if (err != NULL) {
        *err = NAME_NOT_FOUND;
    }
    // 回圈創建可處理組件名對應的MediaCodec物件，并執行init來判斷是否處理成功，
    // 成功則直接回傳當前編解碼器MediaCodec編解碼處理物件，
    for (size_t i = 0; i < matchingCodecs.size(); ++i) {
    	// MediaCodec類宣告和建構式，見1.2小節分析
        sp<MediaCodec> codec = new MediaCodec(looper, pid, uid);
        AString componentName = matchingCodecs[i];
        status_t ret = codec->init(componentName, true);
        if (err != NULL) {
            *err = ret;
        }
        if (ret == OK) {
            return codec;
        }
        ALOGD("Allocating component '%s' failed (%d), try next one.",
                componentName.c_str(), ret);
    }
    return NULL;
}

1.1、MediaCodecList::findMatchingCodecs() 實作分析：

// [frameworks/av/media/libstagefright/MediaCodecList.cpp]
//static
void MediaCodecList::findMatchingCodecs(
        const char *mime, bool encoder, uint32_t flags,
        Vector<AString> *matches) {
    matches->clear();

	// 先獲取媒體編解碼器串列操作物件【單列物件】
	// 見1.1.1小節分析
    const sp<IMediaCodecList> list = getInstance();
    if (list == nullptr) {
        return;
    }

    // 回圈查詢并匹配組件串列中支持當前mime型別格式的編解碼器組件（插件）實體，
    // 因此可以知道，支持同一種mime媒體格式型別的編碼器或解碼器可能會有多個不同實作，如軟/硬編解碼器組件，
    size_t index = 0;
    for (;;) {
    	// 獲取支持該mime型別格式的編解碼器組件在組件串列中的匹配索引
    	// 見1.1.2小節分析
        ssize_t matchIndex =
            list->findCodecByType(mime, encoder, index);

        if (matchIndex < 0) {
        	// 若查詢失敗則表明串列中所有編解碼器組件都不支持該mime型別資料的編解碼
            break;
        }

        // 回圈查找下一個組件的索引
        index = matchIndex + 1;

		// 獲取對應組件串列索引的組件資訊實體
		// 見1.1.3小節分析
        const sp<MediaCodecInfo> info = list->getCodecInfo(matchIndex);
        // 此次確保一定不能為空，否則報錯
        CHECK(info != nullptr);
        // 獲取當前匹配的組件名
        AString componentName = info->getCodecName();

		// 由前面呼叫傳參可知，flags為0，而該標記位作用就是用來表示想使用的編解碼器的型別，
		// 比如此處的只匹配硬編解碼器標志位，【關于此次的&與運算子計算就不再分析了，可自行先了解位運算】
		// isSoftwareCodec() 實作，見1.1.4小節分析
        if ((flags & kHardwareCodecsOnly) && isSoftwareCodec(componentName)) {
        	// 只匹配硬編解碼器時，發現是軟編解碼器則skip跳過
            ALOGV("skipping SW codec '%s'", componentName.c_str());
        } else {
        	// 若無要求必須硬編解碼器時，快取此次回圈匹配到的組件名到引數中回傳
            matches->push(componentName);
            ALOGV("matching '%s'", componentName.c_str());
        }
    }

    // 上面匹配完成后，再檢查對匹配的編解碼器組件排序問題，若設定了軟編解碼器優先級排序，
    // 或設定了該系統屬性值為true，那么將會執行軟編解碼器優先級排序處理，
    if (flags & kPreferSoftwareCodecs ||
            property_get_bool("debug.stagefright.swcodec", false)) {
        // 軟編解碼器優先排序處理
        // 見1.1.5小節分析    
        matches->sort(compareSoftwareCodecsFirst);
    }
}

1.1.1、getInstance()實作分析：
獲取媒體編解碼器串列操作物件【單列物件】，獲取方式Binder機制實作，
通過下面的分析可知：在遠程串列物件創建失敗時，將會直接呼叫本地創建實體方法getLocalInstance()的功能訪問方式，
注意：
由下面的分析可知，其遠程獲取待實體的實作最終也是呼叫了該方法，但不同的是為什么要這么做，
其實原因就是使用不同的全域變數物件來快取訪問物件，一個是本地Bn實作端物件，一個是遠程訪問Bp代理端物件即就是實作了Binder機制的Bp代理端BpMediaCodecList物件，代理訪問Bn實作端BnMediaCodecList子類MediaCodecList實作類功能而非直接訪問物件功能，
因此若遠程訪問物件失敗后將會創建直接訪問功能的本地實體賦值給遠程物件，此時的遠程物件和本地物件將會是同一個物件，

// [frameworks/av/media/libstagefright/MediaCodecList.cpp]
// static
sp<IMediaCodecList> MediaCodecList::getInstance() {
	// （遠程初始化鎖）加鎖【多執行緒訪問】
    Mutex::Autolock _l(sRemoteInitMutex);
    if (sRemoteList == nullptr) {
    	// 為空時
    	// 從ServiceManager服務注冊管理中心獲取名為【media.player】服務的Binder通信服務
        sp<IBinder> binder =
            defaultServiceManager()->getService(String16("media.player"));
        // 最后使用interface_cast轉換成對應服務取得Bp代理物件，
        // 即獲取到了BpMediaPlayerService實作，此處轉換成它的父型別別回傳，
        sp<IMediaPlayerService> service =
            interface_cast<IMediaPlayerService>(binder);
        if (service.get() != nullptr) {
        	// 獲取成功時【理論上都成功】
        	// 通過該服務實作來獲取到了該遠程媒體編解碼器串列資訊管理物件
        	// 見下面的分析
            sRemoteList = service->getCodecList();
            if (sRemoteList != nullptr) {
            	// 獲取遠程訪問代理物件成功時
            	// 實作Binder例外死亡通知監聽功能，見推薦章節分析，
                sBinderDeathObserver = new BinderDeathObserver();
                binder->linkToDeath(sBinderDeathObserver.get());
            }
        }
        // 上面有可能失敗，比如獲取服務失敗等，然后直接呼叫本地創建實體方法訪問方式
        if (sRemoteList == nullptr) {
            // if failed to get remote list, create local list
            sRemoteList = getLocalInstance();
        }
    }
    return sRemoteList;
}

service->getCodecList() 實作分析：
此處不再講述Binder機制處理程序（請查看推薦章節），直接進入Bn實作端BnMediaPlayerService子類MediaPlayerService實作者該方法分析，如下
【從實作可知，其遠程獲取待實體的實作最終也是調回了MediaCodecList的getLocalInstance()該方法】

// [frameworks/av/media/libmediaplayerservice/MediaPlayerService.cpp]
sp<IMediaCodecList> MediaPlayerService::getCodecList() const {
    return MediaCodecList::getLocalInstance();
}

MediaCodecList::getLocalInstance() 本地實體物件創建實作：

// [frameworks/av/media/libstagefright/MediaCodecList.cpp]
// static
sp<IMediaCodecList> MediaCodecList::getLocalInstance() {
	// （初始化鎖）加鎖【多執行緒訪問】，注意此鎖和上面遠程獲取處理流程不同，
    Mutex::Autolock autoLock(sInitMutex);

	// sCodecList 此變數即為全域快取該物件變數
    if (sCodecList == nullptr) {
    	// 還未初始化創建時
    	// 初始化該媒體編解碼器串列管理物件，并且傳入了引數 GetBuilders()
    	// GetBuilders()實作，見1.1.1.1小節分析
    	// MediaCodecList類宣告和建構式實作，見1.1.1.2小節分析
        MediaCodecList *codecList = new MediaCodecList(GetBuilders());
        // 此處實作很簡單就是回傳建構式中 mInitCheck 初始化檢查標記值是否為OK，
        if (codecList->initCheck() == OK) {
        	// 初始化成功則快取到本地全域變數物件中
            sCodecList = codecList;

            // 是否需要異步執行列印所有可用編解碼器配置資訊分析結果到指定xml組態檔，
            // 該檔案就是前面流程中分析的MediaCodecsXmlParser::defaultProfilingResultsXmlPath，默認為false，
            // 見1.1.1.3小節分析
            if (isProfilingNeeded()) {
                ALOGV("Codec profiling needed, will be run in separated thread.");
                pthread_t profiler;
                // 若需要更新結果組態檔，那么啟動新執行緒來異步完成
                if (pthread_create(&profiler, nullptr, profilerThreadWrapper, nullptr) != 0) {
                    ALOGW("Failed to create thread for codec profiling.");
                }
            }
        } else {
            // failure to initialize may be temporary. retry on next call.
            delete codecList;
        }
    }

    return sCodecList;
}

new MediaCodecList(GetBuilders()) 實作分析：
1.1.1.1、首先需要分析引數實作，即GetBuilders()實作如下
【該方法整個實作方案相當于創建工廠設計模式或稱為建造者模式，回傳所有的編解碼器創建工廠后續使用】

// [frameworks/av/media/libstagefright/MediaCodecList.cpp]
std::vector<MediaCodecListBuilderBase *> GetBuilders() {
	// 媒體編解碼器串列創建者集合
    std::vector<MediaCodecListBuilderBase *> builders;
    // 此處英文注釋意思就是：
    // 若StagefrightPluginLoader編解碼器插件加載器提供了輸入Surface物件即也就是提供了圖形資料生產者時，
    // 將不會使用OMX框架的視頻解碼器，在這種情況下，將依賴插件提供可用的OMX編解碼器串列，
    // 其實也就是插件也實作了加載OMX編解碼器串列資訊，
    // 插件提供輸入Surface表明不能使用視頻或影像編碼器，因為它的資料源是來自插件自身提供的Surface輸入
    // 而非OMX的輸入Surface，因此跳過該插件（組件）配置資訊，
    // if plugin provides the input surface, we cannot use OMX video encoders.
    // In this case, rely on plugin to provide list of OMX codecs that are usable.
    // 一般情況下，該物件為空，也就是說默認會加載編解碼器插件，但createInputSurface()方法空實作，因此暫不分析此處，
    // 編解碼器插件實作是在【libsfplugin_ccodec.so】庫中，該庫原始碼在【frameworks/av/media/codec2/sfplugin/】檔案夾下，
    sp<PersistentSurface> surfaceTest =
        StagefrightPluginLoader::GetCCodecInstance()->createInputSurface();
    if (surfaceTest == nullptr) {
    	// 因此會執行到此處
    	// sOmxInfoBuilder 該引數宣告是全域快取變數，
    	// 見下面的分析
        ALOGD("Allowing all OMX codecs");
        builders.push_back(&sOmxInfoBuilder);
    } else {
    	// 此處執行，因此暫不分析
        ALOGD("Allowing only non-surface-encoder OMX codecs");
        builders.push_back(&sOmxNoSurfaceEncoderInfoBuilder);
    }
    // GetCodec2InfoBuilder() 也會成功執行
    // 見下面的分析
    builders.push_back(GetCodec2InfoBuilder());
    return builders;
}

sOmxInfoBuilder和sOmxNoSurfaceEncoderInfoBuilder宣告：
目前先不分析其功能實作，后續將會分析，

// [frameworks/av/media/libstagefright/MediaCodecList.cpp]

OmxInfoBuilder sOmxInfoBuilder{true /* allowSurfaceEncoders */};
OmxInfoBuilder sOmxNoSurfaceEncoderInfoBuilder{false /* allowSurfaceEncoders */};

OmxInfoBuilderg類建構式實作

// [frameworks/av/media/libstagefright/OmxInfoBuilder.cpp]
OmxInfoBuilder::OmxInfoBuilder(bool allowSurfaceEncoders)
    : mAllowSurfaceEncoders(allowSurfaceEncoders) {
}

GetCodec2InfoBuilder() 實作分析：
獲取編解碼器創建者

// [frameworks/av/media/libstagefright/MediaCodecList.cpp]

Mutex sCodec2InfoBuilderMutex;
std::unique_ptr<MediaCodecListBuilderBase> sCodec2InfoBuilder;

MediaCodecListBuilderBase *GetCodec2InfoBuilder() {
	// 加鎖訪問
    Mutex::Autolock _l(sCodec2InfoBuilderMutex);
    // 注意 sCodec2InfoBuilder 是一個C++標準std::unique_ptr全域快取變數物件，因此有reset方法可訪問
    if (!sCodec2InfoBuilder) {
    	// 未初始化時初始化它
    	// 【關于C++的std::unique_ptr等智能指標標準庫的實作，后續有時間可以分析，
    	// 其實和安卓實作的原理類似，但是計數器模式不一樣】
    	// 見下面的分析
        sCodec2InfoBuilder.reset(
                StagefrightPluginLoader::GetCCodecInstance()->createBuilder());
    }
    // 將智能指標快取的內部實際物件指標直接放回
    return sCodec2InfoBuilder.get();
}

StagefrightPluginLoader::GetCCodecInstance()->createBuilder() 實作分析：
首先分析GetCCodecInstance()實作
如下實作可知，其實該插件加載器實際上是個so庫即 kCCodecPluginPath 值為【libsfplugin_ccodec.so】，該so庫是默認加載的，

// [frameworks/av/media/libstagefright/StagefrightPluginLoader.cpp]

constexpr const char kCCodecPluginPath[] = "libsfplugin_ccodec.so";

//static
const std::unique_ptr<StagefrightPluginLoader> &StagefrightPluginLoader::GetCCodecInstance() {
    Mutex::Autolock _l(sMutex);
    if (!sInstance) {
        ALOGV("Loading library");
        // 加載so庫
        sInstance.reset(new StagefrightPluginLoader(kCCodecPluginPath));
    }
    return sInstance;
}

StagefrightPluginLoader類宣告：

// [frameworks/av/media/libstagefright/StagefrightPluginLoader.h]
class StagefrightPluginLoader {}

StagefrightPluginLoader類建構式實作：

// [frameworks/av/media/libstagefright/StagefrightPluginLoader.cpp]
StagefrightPluginLoader::StagefrightPluginLoader(const char *libPath) {
	// 默認CCodec即該so庫開啟加載的，該值通常為4，該值的作用其實就是一個編解碼器串列資訊的排序模式，規定如何排序它們，
    if (android::base::GetIntProperty("debug.stagefright.ccodec", 1) == 0) {
        ALOGD("CCodec is disabled.");
        return;
    }
    // 打開該so庫，并獲取到該so庫訪問句柄指標
    mLibHandle = dlopen(libPath, RTLD_NOW | RTLD_NODELETE);
    if (mLibHandle == nullptr) {
        ALOGD("Failed to load library: %s (%s)", libPath, dlerror());
        return;
    }
    // 讀取so庫中 CreateCodec 方法存盤記憶體的方法開始地址，快取在該方法型別的指標中
    // 該方法型別指標宣告，見下面的分析
    mCreateCodec = (CodecBase::CreateCodecFunc)dlsym(mLibHandle, "CreateCodec");
    if (mCreateCodec == nullptr) {
        ALOGD("Failed to find symbol: CreateCodec (%s)", dlerror());
    }
    // 讀取so庫中 CreateBuilder 方法存盤記憶體的方法開始地址，快取在該方法型別的指標中
    mCreateBuilder = (MediaCodecListBuilderBase::CreateBuilderFunc)dlsym(
            mLibHandle, "CreateBuilder");
    if (mCreateBuilder == nullptr) {
        ALOGD("Failed to find symbol: CreateBuilder (%s)", dlerror());
    }
    // 讀取so庫中 CreateInputSurface 方法存盤記憶體的方法開始地址，快取在該方法型別的指標中
    mCreateInputSurface = (CodecBase::CreateInputSurfaceFunc)dlsym(
            mLibHandle, "CreateInputSurface");
    if (mCreateInputSurface == nullptr) {
        ALOGD("Failed to find symbol: CreateInputSurface (%s)", dlerror());
    }
}

CreateCodec方法型別指標宣告

// [frameworks/av/media/libstagefright/include/media/stagefright/CodecBase.h]
typedef CodecBase *(*CreateCodecFunc)(void);

// 類宣告【省略其他代碼】
// [frameworks/av/media/libstagefright/include/media/stagefright/CodecBase.h]
struct CodecBase : public AHandler, /* static */ ColorUtils {}

// [frameworks/av/media/libstagefright/foundation/include/media/stagefright/foundation/ColorUtils.h]
// 該類其主要定義色彩空間型別值等
struct ColorUtils {}

CreateBuilder方法型別指標宣告

// [frameworks/av/media/libstagefright/include/media/stagefright/MediaCodecListWriter.h]

/**
 * This interface is to be used by `MediaCodecList` to fill its members with
 * appropriate information. `buildMediaCodecList()` will be called from a
 * `MediaCodecList` object during its construction.
 */
struct MediaCodecListBuilderBase {
    typedef MediaCodecListBuilderBase *(*CreateBuilderFunc)(void);
};

CreateInputSurface方法型別指標宣告
將會創建一個持久化Surface，

// [frameworks/av/media/libstagefright/include/media/stagefright/CodecBase.h]
    typedef PersistentSurface *(*CreateInputSurfaceFunc)(void);

// [frameworks/av/media/libstagefright/include/media/stagefright/PersistentSurface.h]
	struct PersistentSurface : public RefBase {}

再分析createBuilder()實作：

// [frameworks/av/media/libstagefright/StagefrightPluginLoader.cpp]
MediaCodecListBuilderBase *StagefrightPluginLoader::createBuilder() {
    if (mLibHandle == nullptr || mCreateBuilder == nullptr) {
        ALOGD("Handle or CreateBuilder symbol is null");
        return nullptr;
    }
    // 由建構式分析可知，此處就是直接執行so庫中對應的方法，
    return mCreateBuilder();
}

另外還有下面兩個實作，也和上面這個相同處理：

// [frameworks/av/media/libstagefright/StagefrightPluginLoader.cpp]

CodecBase *StagefrightPluginLoader::createCodec() {
    if (mLibHandle == nullptr || mCreateCodec == nullptr) {
        ALOGD("Handle or CreateCodec symbol is null");
        return nullptr;
    }
    return mCreateCodec();
}

PersistentSurface *StagefrightPluginLoader::createInputSurface() {
    if (mLibHandle == nullptr || mCreateInputSurface == nullptr) {
        ALOGD("Handle or CreateInputSurface symbol is null");
        return nullptr;
    }
    return mCreateInputSurface();
}

此時我們再分析一下"libsfplugin_ccodec.so"該庫實作中對應的"CreateBuilder"名稱的方法實作，如下
【注意：由下面的實作可知，若是想要加載到so庫的指的方法名稱的方法訪問地址指標，那么必現要保證該方法名不被C++編譯器以C++編譯方式來編譯，因此必現使用C代碼編譯方式來編譯即不會改變方法名】

// [frameworks/av/media/codec2/sfplugin/Codec2InfoBuilder.cpp]

// 標記該方法在C++編譯器編譯時必須使用C編譯方式來編譯到so庫中，
extern "C" android::MediaCodecListBuilderBase *CreateBuilder() {
    return new android::Codec2InfoBuilder;
}

Codec2InfoBuilder類宣告及其建構式實作：【省略其他代碼】

// [frameworks/av/media/codec2/sfplugin/Codec2InfoBuilder.h]
class Codec2InfoBuilder : public MediaCodecListBuilderBase {
public:
	// default修飾符表示該建構式為默認無參構造實作，并沒有重寫自己實作，
    Codec2InfoBuilder() = default;
    ~Codec2InfoBuilder() override = default;
}

// [frameworks/av/media/libstagefright/include/media/stagefright/MediaCodecListWriter.h]
/**
 * This interface is to be used by `MediaCodecList` to fill its members with
 * appropriate information. `buildMediaCodecList()` will be called from a
 * `MediaCodecList` object during its construction.
 */
struct MediaCodecListBuilderBase {}

因此由上面分析可知，getBuilders() 方法就創建好了可用于訪問不同編解碼器配置的”編解碼器創建工廠“，

1.1.1.2、再分析MediaCodecList類宣告和建構式實作
由于該部分內容篇幅過長，因此放入另一章節分析，請查看：
Android MediaPlayer整體架構原始碼分析 -【MediaCodec編解碼器插件模塊化注冊和創建處理流程】【Part 2】

1.1.1.3、isProfilingNeeded()實作分析：
是否需要異步執行列印所有可用編解碼器配置結果資訊到指定xml組態檔，該檔案就是前面流程中分析的MediaCodecsXmlParser::defaultProfilingResultsXmlPath，默認為false，

// [frameworks/av/media/libstagefright/include/media/stagefright/MediaCodecList.h]
static constexpr char const* defaultProfilingResultsXmlPath =
            "/data/misc/media/media_codecs_profiling_results.xml";
            
// [frameworks/av/media/libstagefright/MediaCodecList.cpp]
constexpr const char* kProfilingResults =
        MediaCodecsXmlParser::defaultProfilingResultsXmlPath;

// [frameworks/av/media/libstagefright/MediaCodecList.cpp]
bool isProfilingNeeded() {
	// 該屬性作用：控制是否將系統中可用編解碼器配置資訊結果輸出到指定xml組態檔中，默認未設定該屬性
    int8_t value = property_get_bool("debug.stagefright.profilecodec", 0);
    if (value == 0) {
        return false;
    }

    bool profilingNeeded = true;
    // 打開該檔案
    // 警告：此次檔案訪問模式為"r"即打開一個用于讀取的檔案，但該檔案必須存在，
    // 默認該檔案是不存在的，因此若想要查看結果資訊必須自己創建該檔案，
    FILE *resultsFile = fopen(kProfilingResults, "r");
    if (resultsFile) {
    	// 若打開成功
    	// 獲取系統版本資訊
        AString currentVersion = getProfilingVersionString();
        size_t currentVersionSize = currentVersion.size();
        char *versionString = new char[currentVersionSize + 1];
        fgets(versionString, currentVersionSize + 1, resultsFile);
        if (strcmp(versionString, currentVersion.c_str()) == 0) {
        	// 此次判斷是否已是最新，是根據系統版本來判斷的，升級后就會更新它
            // profiling result up to date
            profilingNeeded = false;
        }
        fclose(resultsFile);
        delete[] versionString;
    }
    return profilingNeeded;
}

getProfilingVersionString()實作：
也就是讀取系統版本屬性值

// [frameworks/av/media/libstagefright/MediaCodecListOverrides.cpp]
AString getProfilingVersionString() {
    char val[PROPERTY_VALUE_MAX];
    if (property_get("ro.build.display.id", val, NULL) && (strlen(val) > 0)) {
        return AStringPrintf("<!-- Profiled-with: %s -->", val);
    }

    return "<!-- Profiled-with: UNKNOWN_BUILD_ID -->";
}

1.1.2、list->findCodecByType(mime, encoder, index)實作分析：
獲取支持給mime型別處理的編解碼器組件在組件串列中的匹配索引
方法宣告：

// [frameworks/av/media/libstagefright/include/media/stagefright/MediaCodecList.h]
struct MediaCodecList : public BnMediaCodecList {
    virtual ssize_t findCodecByType(
            const char *type, bool encoder, size_t startIndex = 0) const;
}

方法實作：

// [frameworks/av/media/libstagefright/MediaCodecList.cpp]
// legacy method for non-advanced codecs
ssize_t MediaCodecList::findCodecByType(
        const char *type, bool encoder, size_t startIndex) const {
    // （編解碼器）高級特性屬性值    
    static const char *advancedFeatures[] = {
        "feature-secure-playback",
        "feature-tunneled-playback",
    };

    // 回圈處理startIndex索引開始位置及其之后的所有編解碼器組件資訊
    size_t numCodecInfos = mCodecInfos.size();
    for (; startIndex < numCodecInfos; ++startIndex) {
        const MediaCodecInfo &info = *mCodecInfos[startIndex];

        // 判斷請求的是編碼器還是解碼器處理
        if (info.isEncoder() != encoder) {
        	// 不相同則跳過
            continue;
        }
        // 獲取encoder指定型別的編碼器或解碼器的能力資訊
        // 參數type就是mime型別即編解碼器格式資訊，匹配成功則回傳該能力資訊，否則為空
        // 見下面的分析
        sp<MediaCodecInfo::Capabilities> capabilities = info.getCapabilitiesFor(type);
        if (capabilities == nullptr) {
            continue;
        }
        // 然后獲取其詳細能力資訊屬性值，對應于前面流程中分析的addDetails()方法添加的屬性資料
        const sp<AMessage> &details = capabilities->getDetails();

        // 判斷當前組件的支持屬性值串列中是否包含上面兩個高級特性屬性值中其中任意一個，若包含則表示其為高級編解碼器組件實作
        int32_t required;
        bool isAdvanced = false;
        for (size_t ix = 0; ix < ARRAY_SIZE(advancedFeatures); ix++) {
        	// required值就是該高級屬性對應的值
            if (details->findInt32(advancedFeatures[ix], &required) &&
                    required != 0) {
                isAdvanced = true;
                break;
            }
        }

        if (!isAdvanced) {
        	// 若沒有設定啟用這兩個高級特性屬性值的任意一個，
        	// 那么直接回傳當前匹配到的組件在組件串列中的索引，
        	// NOTE：也就是說該方法查找的編解碼器不應該支持這兩個高級特性屬性，若支持將被跳過，
        	// 并且若上面呼叫端處理成功后將會再次呼叫該方法，那么將會從此次組件位置的下一個組件開始匹配，
        	// 因為前面已匹配過的編解碼器組件不用再次匹配了.
            return startIndex;
        }
    }

	// 若上面for回圈查找未執行到那個return陳述句，也就表明沒有可支持指定mime型別的編解碼器組件
    return -ENOENT;
}

info.getCapabilitiesFor(type)實作分析：
從下面兩個方法的實作可知，其實就是獲取此前初始化創建編解碼器時執行的MediaCodecInfoWriter::addMediaType()，決議后獲取的當前組件支持的mime格式型別，若匹配上則回傳，并且匹配mime格式型別值是不分大小的，

// [frameworks/av/media/libmedia/MediaCodecInfo.cpp]
const sp<MediaCodecInfo::Capabilities>
MediaCodecInfo::getCapabilitiesFor(const char *mediaType) const {
    ssize_t ix = getCapabilityIndex(mediaType);
    if (ix >= 0) {
        return mCaps.valueAt(ix);
    }
    return NULL;
}

getCapabilityIndex()實作：

// [frameworks/av/media/libmedia/MediaCodecInfo.cpp]
ssize_t MediaCodecInfo::getCapabilityIndex(const char *mediaType) const {
    if (mediaType) {
        for (size_t ix = 0; ix < mCaps.size(); ix++) {
            if (mCaps.keyAt(ix).equalsIgnoreCase(mediaType)) {
                return ix;
            }
        }
    }
    return -1;
}

1.1.3、list->getCodecInfo(matchIndex)實作分析：
獲取對應組件串列索引的組件資訊實體，其實就是串列下標訪問即可，可能為空

// [frameworks/av/media/libstagefright/include/media/stagefright/MediaCodecList.h]
    virtual sp<MediaCodecInfo> getCodecInfo(size_t index) const {
        if (index >= mCodecInfos.size()) {
            ALOGE("b/24445127");
            return NULL;
        }
        return mCodecInfos[index];
    }

1.1.4、isSoftwareCodec(componentName)實作分析：
判斷是否是軟編解碼器組件，
因此注意后續想要知道安卓編解碼的軟硬實作的判斷，則可以看下這個實作，該實作也是隨著版本不停變化的，
如下判斷，若是該（插件編解碼器）組件名開頭字串滿足一下任意一個條件： “OMX.google.” 或 “c2.android.” 或 【非"OMX."】 或【非"c2."】，匹配字串不分大小寫，只要滿足任意一個條件那么將被認為是軟編解碼器，
注意：前面流程中我們看到過組件名開頭為 “OMX.qti” 的組件名配置資訊，那么它將被認為是硬編解碼器，而非xml組態檔中所描述的英文注釋【video software】，關于這一點可以自行驗證，

// [frameworks/av/media/libstagefright/MediaCodecList.cpp]
//static
bool MediaCodecList::isSoftwareCodec(const AString &componentName) {
    return componentName.startsWithIgnoreCase("OMX.google.")
            || componentName.startsWithIgnoreCase("c2.android.")
            || (!componentName.startsWithIgnoreCase("OMX.")
                    && !componentName.startsWithIgnoreCase("c2."));
}

1.1.5、matches->sort(compareSoftwareCodecsFirst)實作分析：
軟編解碼器優先排序處理，如下英文注釋三種排序處理，不再分析，

// [frameworks/av/media/libstagefright/MediaCodecList.cpp]
static int compareSoftwareCodecsFirst(const AString *name1, const AString *name2) {
    // sort order 1: software codecs are first (lower)
    bool isSoftwareCodec1 = MediaCodecList::isSoftwareCodec(*name1);
    bool isSoftwareCodec2 = MediaCodecList::isSoftwareCodec(*name2);
    if (isSoftwareCodec1 != isSoftwareCodec2) {
        return isSoftwareCodec2 - isSoftwareCodec1;
    }

    // sort order 2: Codec 2.0 codecs are first (lower)
    bool isC2_1 = name1->startsWithIgnoreCase("c2.");
    bool isC2_2 = name2->startsWithIgnoreCase("c2.");
    if (isC2_1 != isC2_2) {
        return isC2_2 - isC2_1;
    }

    // sort order 3: OMX codecs are first (lower)
    bool isOMX1 = name1->startsWithIgnoreCase("OMX.");
    bool isOMX2 = name2->startsWithIgnoreCase("OMX.");
    return isOMX2 - isOMX1;
}

1.2、new MediaCodec(looper, pid, uid)實作分析：
MediaCodec類宣告【省略其他代碼】

MediaCodec類建構式實作

1.3、實作分析：
由于該部分內容篇幅過長，因此放入另一章節分析，請查看：
Android MediaPlayer整體架構原始碼分析 -【MediaCodec編解碼器插件模塊化注冊和創建處理流程】【Part 6】
TODO

2、MediaCodec::CreateByComponentName() 實作分析：
方法宣告

// [frameworks/av/media/libstagefright/include/media/stagefright/MediaCodec.h]
    static sp<MediaCodec> CreateByComponentName(
            const sp<ALooper> &looper, const AString &name, status_t *err = NULL,
            pid_t pid = kNoPid, uid_t uid = kNoUid);

方法實作

// [frameworks/av/media/libstagefright/MediaCodec.cpp]