【Android】从libavenhancements.so的调用分析高通封装

72 阅读 0 评论 48 点赞

我是靠谱客的博主英勇唇膏，最近开发中收集的这篇文章主要介绍【Android】从libavenhancements.so的调用分析高通封装，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

写在前面：
在学习高通多媒体架构的代码的过程中间，很多地方跑着跑着，就找不到调用的地方了，通过堆栈发现，很多找不到的东西，就被如下几个不开源的库文件给打包调用了，所以这里记录下，高通Android是如何封装调用的，以及最重要的，这个封装的包到底是什么。

封装库文件：
vendor/qcom/proprietary/prebuilt_HY11/target/product/msm8909/system/vendor/lib/下面：
libExtendedExtractor.so
libmmparser_lite.so
libmmparser.so
libavenhancements.so(会调用上面三个库文件)
。。。

下面以libavenhancements.so库为例，分析这个封装的包里面到底是什么？：


//frameworks/av/media/libavextensions/common/AVExtensionsCommon.h
typedef void *(*createFunction_t)(void);//函数指针
template <typename T>
struct ExtensionsLoader {
//根据封装库中的工厂方法名字，创建被封装的扩展类实例，返回类型是 T
static T *createInstance(const char *createFunctionName);
private:
static void loadLib();
//从封装库中间，通过名字映射方法，返回一个盒函数指针
static createFunction_t loadCreateFunction(const char *createFunctionName);
static void *mLibHandle;
};
//==============================================
//模板类，声明一个单态的模版类
/*
* Boiler-plate to declare the class as a singleton (with a static getter)
* which can be loaded (dlopen'd) via ExtensionsLoader
*/
#define DECLARE_LOADABLE_SINGLETON(className)

protected:

className();

virtual ~className();

static className *sInst;

private:

className(const className&);

className &operator=(className &);

public:

//get方法，返回一个实例
static className *get() {

return sInst;

}

friend struct ExtensionsLoader<className>;
//下面看具体的函数实现：
//frameworks/av/media/libavextensions/common/ExtensionsLoader.hpp
template <typename T>
T *ExtensionsLoader<T>::createInstance(const char *createFunctionName) {
ALOGV("createInstance(%lubit) : %s", (unsigned long)sizeof(intptr_t)*8, createFunctionName);
// create extended object if extensions-lib is available and
// AV_ENHANCEMENTS is enabled
#if ENABLE_AV_ENHANCEMENTS
createFunction_t createFunc = loadCreateFunction(createFunctionName);
if (createFunc) {
return reinterpret_cast<T *>((*createFunc)());
}
#endif
// Else, create the default object
return new T;
}
//=======================================================
//接下来，看如何操作库文件
template <typename T>
createFunction_t ExtensionsLoader<T>::loadCreateFunction(const char *createFunctionName) {
loadLib();
if (!mLibHandle) {
return NULL;
}
//dlsym方法映射
createFunction_t func = (createFunction_t)dlsym(mLibHandle, createFunctionName);
if (!func) {
ALOGE("symbol %s not found:
%s",createFunctionName, dlerror());
}
return func;
}

上面的代码，主要就是做两件事情：
1，加载库文件，根据工厂方法名字，查找封装库文件，返回一个模板类
2，通过宏，声明一个单态类

其中1,2两点如何联系起来？可以看下如下例子：

struct AVFactory{
//...
DECLARE_LOADABLE_SINGLETON(AVFactory)
}
//static
AVFactory *AVFactory::sInst =
ExtensionsLoader<AVFactory>::createInstance("createExtendedFactory");

通过上面的分析，我们可以通过如下的关键字搜索全局，看看这个库里面有什么。关键字如下：
T *ExtensionsLoader::createInstance(const char *createFunctionName)

搜索结果：

frameworks/av/media/libavextensions/stagefright/AVFactory.cpp
frameworks/av/media/libavextensions/stagefright/AVUtils.cpp
frameworks/av/media/libavextensions/mediaplayerservice/AVNuUtils.cpp
frameworks/av/media/libavextensions/mediaplayerservice/AVMediaServiceFactory.cpp
frameworks/av/media/libavextensions/mediaplayerservice/AVMediaServiceUtils.cpp
frameworks/av/media/libavextensions/mediaplayerservice/AVNuFactory.cpp
frameworks/av/media/libavextensions/media/AVMediaUtils.cpp

搜索 DECLARE_LOADABLE_SINGLETON：

DECLARE_LOADABLE_SINGLETON(AVFactory)
DECLARE_LOADABLE_SINGLETON(AVUtils);
DECLARE_LOADABLE_SINGLETON(AVNuFactory);
DECLARE_LOADABLE_SINGLETON(AVNuUtils);
DECLARE_LOADABLE_SINGLETON(AVMediaServiceFactory);
DECLARE_LOADABLE_SINGLETON(AVMediaServiceUtils);
DECLARE_LOADABLE_SINGLETON(AVMediaUtils);

分析到这里，可见libavenhancements.so中间存在这些类的扩展子类，这些子类有什么功能呢？需要去看声明接口的地方，仍然以AVFactory为例。

struct AVFactory {
virtual sp<ACodec> createACodec();
//创建解析音视频的拆分器
virtual MediaExtractor* createExtendedExtractor(
const sp<DataSource> &source, const char *mime, const sp<AMessage> &meta,
const uint32_t flags);
virtual ElementaryStreamQueue* createESQueue(
ElementaryStreamQueue::Mode mode, uint32_t flags = 0);
virtual CameraSource *CreateCameraSourceFromCamera(
const sp<hardware::ICamera> &camera,
const sp<ICameraRecordingProxy> &proxy,
int32_t cameraId,
const String16& clientName,
uid_t clientUid,
pid_t clientPid,
Size videoSize,
int32_t frameRate,
const sp<IGraphicBufferProducer>& surface,
bool storeMetaDataInVideoBuffers = true);
virtual CameraSourceTimeLapse *CreateCameraSourceTimeLapseFromCamera(
const sp<hardware::ICamera> &camera,
const sp<ICameraRecordingProxy> &proxy,
int32_t cameraId,
const String16& clientName,
uid_t clientUid,
pid_t clientPid,
Size videoSize,
int32_t videoFrameRate,
const sp<IGraphicBufferProducer>& surface,
int64_t timeBetweenFrameCaptureUs,
bool storeMetaDataInVideoBuffers = true);
virtual AudioSource* createAudioSource(
audio_source_t inputSource,
const String16 &opPackageName,
uint32_t sampleRate,
uint32_t channels,
uint32_t outSampleRate = 0,
uid_t clientUid = -1,
pid_t clientPid = -1);
virtual MPEG4Writer *CreateMPEG4Writer(int fd);
// ----- NO TRESSPASSING BEYOND THIS LINE ------
DECLARE_LOADABLE_SINGLETON(AVFactory);
};