Android Camera之CameraMetadata分析
感兴趣可以加QQ群85486140，大家一起交流相互学习下！
一、camera_metadata简介
Camera_metadata数据结构在Camera流程中起到了很大重要,可以说所有的自顶层下发给hal层的参数都是通过camera_metadata传递的。今天我们就来好好看看它到底如何保存的，以及它的数据组织形式如何表现。和Camera_metadata数据结构相关的主要有以下几个文件：
system/media/camera/include/system/Camera_metadata_tags.h
system/media/camera/src/Camera_metadata_tag_info.c
system/media/camera/src/Camera_metadata.c
system/media/camera/include/system/Camera_metadata.h
Framework/av/camera/CameraMetadata.cpp
Framework/av/include/camera/CameraMetadata.h
这些文件的调用和包含关系如下图所示。
其中camera_metadata_tag_info.h包含了所有的基本宏，其中包含了下面的section枚举类型，在代码中可以看到，每一个section的大小是64K，因为他们根据之前枚举变量向左偏移16位(64K喽)。每个段有64K，目前在本世纪够用了。根据这样层层包扎，所以说每一个tag的值都是不同的，而且有序的组织在一起。
/**
* Top level hierarchy definitions for camera metadata. *_INFO sections are for
* the static metadata that can be retrived without opening the camera device.
* New sections must be added right before ANDROID_SECTION_COUNT to maintain
* existing enumerations.
*/
typedef enum camera_metadata_section {
ANDROID_COLOR_CORRECTION,
ANDROID_CONTROL,
ANDROID_DEMOSAIC,
ANDROID_EDGE,
.............
}
<pre name="code" class="cpp">/**
* Hierarchy positions in enum space. All vendor extension tags must be
* defined with tag >= VENDOR_SECTION_START
*/
typedef enum camera_metadata_section_start {
ANDROID_COLOR_CORRECTION_START = ANDROID_COLOR_CORRECTION << 16,
ANDROID_CONTROL_START = ANDROID_CONTROL << 16,
ANDROID_DEMOSAIC_START = ANDROID_DEMOSAIC << 16,
ANDROID_EDGE_START = ANDROID_EDGE << 16,
.............
}
下图我们就以ANDROID_FLASH_START section来说事吧。由于它的枚举值为4，那么它的tag的基址就是4x64K了。它包含了6个有效的tag，如下图最右侧的tag表。最后一个标示为end结束标志。
二、camera_metadata 内存结构
在camera_metadata.c代码中有下面一副图，这里就是camera_metadata的内存分布。camera_metadata数据结构是一块连续的内存空间。在内存开始处放置的是一个struct camera_metadata的对象，这里面记录了该数据块包含的基本信息，具体大家就看下面代码中的结构体注释吧。紧接着头部下面是entry数据空间，这个空间记录了每一个tag的数据，数据大小和在数据区的偏移地址。紧接着entry下面的是真正的数据区域了，这个区域保存了所有大小大于4字节的Tag数据。具体后面代码中有详细描述。
android代码中的一个Camera_Metadata数据内存块中最小基本单元是struct camera_metadata_buffer_entry,总的entry数目等信息需要struct camera_metadata数据来维护.
/**
* A packet of metadata. This is a list of entries, each of which may point to
* its values stored at an offset in data.
*
* It is assumed by the utility functions that the memory layout of the packet
* is as follows:
*
* |-----------------------------------------------|
* | camera_metadata_t 数据结构=header |
* | |
* |-----------------------------------------------|
* | reserved for future expansion |
* |-----------------------------------------------|
* | camera_metadata_buffer_entry_t #0 |
* |-----------------------------------------------|
* | .... |
* |-----------------------------------------------|
* | camera_metadata_buffer_entry_t #entry_count-1 |
* |-----------------------------------------------|
* | free space for |
* | (entry_capacity-entry_count) entries |
* |-----------------------------------------------|
* | start of camera_metadata.data |
* | |
* |-----------------------------------------------|
* | free space for |
* | (data_capacity-data_count) bytes |
* |-----------------------------------------------|
*
* With the total length of the whole packet being camera_metadata.size bytes.
*
* In short, the entries and data are contiguous in memory after the metadata
* header.
*/
我们来回忆一下，之前我们在分析string8的时候，就是这种情况，真正的string字符串内存空间就是sharedBuffer头下面的数据空间。大家可以去参考一下博文
struct camera_metadata {
metadata_size_t size; //整个metadata数据大小
uint32_t version; //版本号，我们不用管它
uint32_t flags;
metadata_size_t entry_count; //已经添加TAG的入口数量,（即内存块中已经包含多少TAG了）
metadata_size_t entry_capacity;//最大能容纳TAG的入口数量（即最大能放多少tag）
metadata_uptrdiff_t entries_start; // Offset from camera_metadata entry数据区域相对开始处的偏移
metadata_size_t data_count; //记录数据段当前已用的内存空间
metadata_size_t data_capacity; //总的数据段内存空间
metadata_uptrdiff_t data_start; // Offset from camera_metadata data数据区相对开始处的偏移
uint8_t reserved[]; 保留
};
三、camera_metadata 代码探索
我在代码中大部分情况下，都是看到直接用camera_metadata定义一个对象的。如下简单的2行测试代码，下面的代码即是对代码的注释，也是对一个事例的跟踪探索。
struct camera_metadata static_info;
static_info.update(ANDROID_FLASH_MODE,5,1);由上面的定义，我们来看看相应的构造函数，可以看到构造函数基本什么也没做，只是初始化了两个变量mBuffer，mLocked ，有同学可能已经担心了，没有分配内存空间，怎么去更新值啊，别急我们往下接着看。
CameraMetadata::CameraMetadata() :
mBuffer(NULL), mLocked(false) {
}
下图是update()方法的整个实现，其中看起很简短，但是其中做了很多工作，我们一一来分解。那些简单的代码，我就不列出来了，大家自己查阅源代码吧。
status_t CameraMetadata::update(uint32_t tag,
const int32_t *data, size_t data_count) {
status_t res;
if (mLocked) {
ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
return INVALID_OPERATION;
}
if ( (res = checkType(tag, TYPE_INT32)) != OK) { //这里检查的是参数中传进来的tag类型是否和之前预定义的一致，以防出错。
return res;
}
return updateImpl(tag, (const void*)data, data_count); //重任的接力棒传到了这里
}
status_t CameraMetadata::updateImpl(uint32_t tag, const void *data,
size_t data_count) {
status_t res;
if (mLocked) {
ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
return INVALID_OPERATION;
}
int type = get_camera_metadata_tag_type(tag); //获取tag的Type，为后面计算内存做准备，提前剧透返回的是1，即一个字节。
//感兴趣的可以我们跳到下一个函数中，稍后回来 DOWN，DOWN
if (type == -1) {
ALOGE("%s: Tag %d not found", __FUNCTION__, tag);
return BAD_VALUE;
}
size_t data_size = calculate_camera_metadata_entry_data_size(type, //传入的参数个数1，type=Byte_Type 即1个字节。
data_count); //函数进行完毕了，我们得到data_size =0.啊，是0，继续往下看。
res = resizeIfNeeded(1, data_size); //终于我们来到了干实事的地方了。DOWN DOWN
if (res == OK) {
camera_metadata_entry_t entry;
res = find_camera_metadata_entry(mBuffer, tag, &entry);
if (res == NAME_NOT_FOUND) { //针对ANDROID_FLASH_MODE,上面返回的就是NOT_FOUND
res = add_camera_metadata_entry(mBuffer, //由于之前没有添加过，这里会将ANDROID_FLASH_MODE写入大的数据块中。
tag, data, data_count);
} else if (res == OK) {
res = update_camera_metadata_entry(mBuffer, //上一次find操作找到的话，说明这一次进行的是更新操作。
entry.index, data, data_count, NULL);
}
}
if (res != OK) {
ALOGE("%s: Unable to update metadata entry %s.%s (%x): %s (%d)",
__FUNCTION__, get_camera_metadata_section_name(tag),
get_camera_metadata_tag_name(tag), tag, strerror(-res), res);
}
IF_ALOGV() {
ALOGE_IF(validate_camera_metadata_structure(mBuffer, /*size*/NULL) !=
OK,
"%s: Failed to validate metadata structure after update %p",
__FUNCTION__, mBuffer);
}
return res;
}
int get_camera_metadata_tag_type(uint32_t tag) {
uint32_t tag_section = tag >> 16; //这里我们传进去的Tag是ANDROID_FLASH_MODE，即4<<16+2.(+2请看看开始那个长图最右边偏移)，由移动16位得到4.
if (tag_section >= VENDOR_SECTION && vendor_tag_ops != NULL) {
return vendor_tag_ops->get_camera_vendor_tag_type(
vendor_tag_ops,
tag);
}
if (tag_section >= ANDROID_SECTION_COUNT || //这里就是判断tag_section段序号是否已经超出了界限。
tag >= camera_metadata_section_bounds[tag_section][1] ) { //看看下面对应的结构体(4<<16+2) < ANDROID_FLASH_END
return -1;
}
uint32_t tag_index = tag & 0xFFFF; //这里按位与(4<<16+2) & 0xFFFF = 2;
return tag_info[tag_section][tag_index].tag_type; //这里tag_section=4 tag_index=2.请看下面的tag_info结构体喽，
//返回的tag_type = TYPE_BYTE，好了得到这个值，我们可以继续上面的分析。UP，UP
}
size_t calculate_camera_metadata_entry_data_size(uint8_t type,
size_t data_count) {
if (type >= NUM_TYPES) return 0;
size_t data_bytes = data_count *
camera_metadata_type_size[type]; //看下面结构体就知道了，这里data_bytes = 1 * 1;
return data_bytes <= 4 ? 0 : ALIGN_TO(data_bytes, DATA_ALIGNMENT); //由于这里<=4成立，返回的是0，居然是0.我们回去UP，UP
}
//下面结构体在camera_metadata.c
const size_t camera_metadata_type_size[NUM_TYPES] = {
[TYPE_BYTE] = sizeof(uint8_t),
[TYPE_INT32] = sizeof(int32_t),
[TYPE_FLOAT] = sizeof(float),
[TYPE_INT64] = sizeof(int64_t),
[TYPE_DOUBLE] = sizeof(double),
[TYPE_RATIONAL] = sizeof(camera_metadata_rational_t)
};
//下面两个结构都在camera_metadata_tag_info.c
tag_info_t *tag_info[ANDROID_SECTION_COUNT] = {
android_color_correction,
android_control,
android_demosaic,
android_edge,
android_flash, //我们ANDROID_FLASH_MODE tag的section_count=4 ,那就是这个喽。
android_flash_info,
......
}
static tag_info_t android_flash[ANDROID_FLASH_END -
ANDROID_FLASH_START] = {
[ ANDROID_FLASH_FIRING_POWER - ANDROID_FLASH_START ] =
{ "firingPower", TYPE_BYTE },
[ ANDROID_FLASH_FIRING_TIME - ANDROID_FLASH_START ] =
{ "firingTime", TYPE_INT64 },
[ ANDROID_FLASH_MODE - ANDROID_FLASH_START ] =
{ "mode", TYPE_BYTE }, //代码访问的是tag_type域，返回的就是TYPE_BYTE了。
[ ANDROID_FLASH_COLOR_TEMPERATURE - ANDROID_FLASH_START ] =
{ "colorTemperature", TYPE_BYTE },
[ ANDROID_FLASH_MAX_ENERGY - ANDROID_FLASH_START ] =
{ "maxEnergy", TYPE_BYTE },
[ ANDROID_FLASH_STATE - ANDROID_FLASH_START ] =
{ "state", TYPE_BYTE },
};
//下面这个结构保存了真实的section界限，便于查找我们目前不可能用完64K的地址空间^_^ ^_^ ^_^
unsigned int camera_metadata_section_bounds[ANDROID_SECTION_COUNT][2] = {
[ANDROID_COLOR_CORRECTION] = { ANDROID_COLOR_CORRECTION_START,
ANDROID_COLOR_CORRECTION_END },
[ANDROID_CONTROL] = { ANDROID_CONTROL_START,
ANDROID_CONTROL_END },
[ANDROID_DEMOSAIC] = { ANDROID_DEMOSAIC_START,
ANDROID_DEMOSAIC_END },
[ANDROID_EDGE] = { ANDROID_EDGE_START,
ANDROID_EDGE_END },
[ANDROID_FLASH] = { ANDROID_FLASH_START, //刚才上面我们得到section num =4，就是这里了，而且取的ANDROID_FLASH_END
ANDROID_FLASH_END },
......
}
下面这段代码算是camerametedata中最重要的，也是最不好理解的一个函数，这个函数的作用是根据传入的额外tag_entry和额外的data大小，重新计算实际的entry_count.如果新计算的new_entry >entry_cap(即之前的entry_count加上新加入的entry_count 大于之前实际的entry_cap,超额了)，那么就将new_entry_count 放大2倍。由此可见entry_count呈指数倍增加。同样DataCount也是一样的道理，这里就不多说了，我们看代码，看代码，read the fucking code。
status_t CameraMetadata::resizeIfNeeded(size_t extraEntries, size_t extraData) { //由上面可以得到extraEntries =1，extraData = 0
if (mBuffer == NULL) { //开始的地方我们看得到mBuffer被初始化成NULL
mBuffer = allocate_camera_metadata(extraEntries * 2, extraData * 2); //这里可知传入的参数是(2,0),我们看的出，它提前多申请了一个entry的空间。
if (mBuffer == NULL) {
ALOGE("%s: Can't allocate larger metadata buffer", __FUNCTION__);
return NO_MEMORY;
}
} else { //由于这里我们是第一次申请mBuffer空间，所以这里就不执行了。
size_t currentEntryCount = get_camera_metadata_entry_count(mBuffer); //获取当前metadata保存的Tag数量
size_t currentEntryCap = get_camera_metadata_entry_capacity(mBuffer); //获取当前metadata数据快能最大存放tag的数量。
size_t newEntryCount = currentEntryCount +
extraEntries; //得到更新后我们实际存放的tag数量。
newEntryCount = (newEntryCount > currentEntryCap) ?
newEntryCount * 2 : currentEntryCap; //看到了吧，如果这个实际存放的数量，已经超出它能存放的范围，那么就把能力放大2倍，指数倍增加。
size_t currentDataCount = get_camera_metadata_data_count(mBuffer); //获取当前数据区已经使用了多少字节。
size_t currentDataCap = get_camera_metadata_data_capacity(mBuffer); //数据区总的大小。
size_t newDataCount = currentDataCount + //当前已使用的数据 + 将要加入进来的数据=实际要存入数据区的数据
extraData;
newDataCount = (newDataCount > currentDataCap) ?
newDataCount * 2 : currentDataCap; //如果实际要存放的数据大于目前数据区总的大小，那么就把数据区放大2倍，同样呈指数增加
if (newEntryCount > currentEntryCap ||
newDataCount > currentDataCap) {
camera_metadata_t *oldBuffer = mBuffer;
mBuffer = allocate_camera_metadata(newEntryCount, //如果超处之前的能力，就会重新申请buffer
newDataCount);
if (mBuffer == NULL) {
ALOGE("%s: Can't allocate larger metadata buffer", __FUNCTION__);
return NO_MEMORY;
}
append_camera_metadata(mBuffer, oldBuffer); //将之前的数据拷贝到新的mbuffer中。
free_camera_metadata(oldBuffer); //释放老的mBuffer，你懂得
}
}
return OK;
}
下面第一个函数allocate_camera_metadata()是重新根据入口数和数据大小计算、申请buffer。紧接着第二个place_camera_metadata()就是对刚申请的buffer，初始化一些变量，为后面更新，插入tag数据做准备。
camera_metadata_t *allocate_camera_metadata(size_t entry_capacity,
size_t data_capacity) { //传入的参数是（2,0)
if (entry_capacity == 0) return NULL;
size_t memory_needed = calculate_camera_metadata_size(entry_capacity, //代码实现在下面，返回的是header+2*sizeof(entry)大小
data_capacity);
void *buffer = malloc(memory_needed); //malloc申请一块连续的内存。
return place_camera_metadata(buffer, memory_needed, //到这个函数就是要给header化妆了，看下面紧挨着的方法
entry_capacity,
data_capacity);
}
camera_metadata_t *place_camera_metadata(void *dst,
size_t dst_size,
size_t entry_capacity,
size_t data_capacity) {
if (dst == NULL) return NULL;
if (entry_capacity == 0) return NULL;
size_t memory_needed = calculate_camera_metadata_size(entry_capacity, //再一次计算需要的内存大小，为何？？
data_capacity);
if (memory_needed > dst_size) return NULL;
camera_metadata_t *metadata = (camera_metadata_t*)dst; //mbuffer赋成camera_metadata_t 结构体指针，用意何在
metadata->version = CURRENT_METADATA_VERSION; //版本号，
metadata->flags = 0;//没有排序标志
metadata->entry_count = 0; //初始化entry_count =0,之前一次也没有更新过吧。
metadata->entry_capacity = entry_capacity; //最大的入口数量，针对我们ANDROID_FLASH_MODE这里是2个。
metadata->entries_start =
ALIGN_TO(sizeof(camera_metadata_t), ENTRY_ALIGNMENT); //entry数据域的开始处紧挨着camera_metadata_t 头部。
metadata->data_count = 0; //初始化为0
metadata->data_capacity = data_capacity; //因为没有申请内存，这里也是0
metadata->size = memory_needed; //总的内存大小
size_t data_unaligned = (uint8_t*)(get_entries(metadata) +
metadata->entry_capacity) - (uint8_t*)metadata; //这里大家要好好考虑一下，为什么加的是metadata->entry_capacity) ^_^
metadata->data_start = ALIGN_TO(data_unaligned, DATA_ALIGNMENT); //计算data数据区域的偏移地址。数据区域紧挨着entry区域末尾。
return metadata;
//根据入口数量和实际数量，计算实际camera_metadata需要的内存块大小（header+sizeof(camera_entry)+sizeof(data）。
size_t calculate_camera_metadata_size(size_t entry_count,
size_t data_count) { //针对我们上面讲的例子，传入的参数是（2,0）
size_t memory_needed = sizeof(camera_metadata_t); //看好了，这里计算header大小了。
// Start entry list at aligned boundary
memory_needed = ALIGN_TO(memory_needed, ENTRY_ALIGNMENT); //按字节对齐后的大小，我们就不关心了。
memory_needed += sizeof(camera_metadata_buffer_entry_t[entry_count]); //紧接着是entry数据区的大小了，这里申请了2个entry内存空间。
// Start buffer list at aligned boundary
memory_needed = ALIGN_TO(memory_needed, DATA_ALIGNMENT); //同样对齐
memory_needed += sizeof(uint8_t[data_count]); //这里我们data_count = 0,这里就不加了。
return memory_needed; //返回的最后算出的大小，我们回到开始处。UP，UP
}
find_camera_metadata_entry函数非常好理解，获取对应tag的entry结构体，并将数据保存在entry传入的参数中。紧接着add_camera_metadata_entry()就是当我们没有查找到我们要查找到的tag时，这时候我们就是知道这是一个新的tag，需要添加进大数据结构中。在下面的几个函数中会遇到2个entry结构体，他们一个是内部的数据结构，用于记录tag数据的，还有一个是在外部引用。使用时，要注意啦。
struct camera_metadata_buffer_entry_t； //内部使用
struct camera_metadata_entry ； //外部使用，
int find_camera_metadata_entry(camera_metadata_t *src,
uint32_t tag,
camera_metadata_entry_t *entry) {
if (src == NULL) return ERROR;
uint32_t index;
if (src->flags & FLAG_SORTED) { //之前初始化时，flags = 0，这里不成立，跳到else处
// Sorted entries, do a binary search
camera_metadata_buffer_entry_t *search_entry = NULL;
camera_metadata_buffer_entry_t key;
key.tag = tag;
search_entry = bsearch(&key,
get_entries(src),
src->entry_count,
sizeof(camera_metadata_buffer_entry_t),
compare_entry_tags);
if (search_entry == NULL) return NOT_FOUND;
index = search_entry - get_entries(src);
} else {
// Not sorted, linear search
camera_metadata_buffer_entry_t *search_entry = get_entries(src);
for (index = 0; index < src->entry_count; index++, search_entry++) { //这里由于entry_count =0 因为根本就没有添加任何东西。
if (search_entry->tag == tag) {
break;
}
}
if (index == src->entry_count) return NOT_FOUND; //返回NOT_FOUNT
}
return get_camera_metadata_entry(src, index, //找到index的tag entry
entry);
}
int add_camera_metadata_entry(camera_metadata_t *dst,
uint32_t tag,
const void *data,
size_t data_count) { //这里传入的参数为（mBuffer，ANDROID_FLASH_MODE,5,1)
int type = get_camera_metadata_tag_type(tag);
if (type == -1) {
ALOGE("%s: Unknown tag %04x.", __FUNCTION__, tag);
return ERROR;
}
return add_camera_metadata_entry_raw(dst, //这里传入的参数为（mBuffer，ANDROID_FLASH_MODE,BYTE_TYPE,5,1) DOWN
tag,
type,
data,
data_count);
}
//下面是真正干实事的方法，这里会将外部传入的tag信息，存放到各自的家中，以及一些其它的附属信息。你懂的
static int add_camera_metadata_entry_raw(camera_metadata_t *dst,
uint32_t tag,
uint8_t type,
const void *data,
size_t data_count) {
if (dst == NULL) return ERROR;
if (dst->entry_count == dst->entry_capacity) return ERROR; //如果成立，就没有空间了。
if (data == NULL) return ERROR;
size_t data_bytes =
calculate_camera_metadata_entry_data_size(type, data_count); //计算要使用的内存大小这里1*1,但是返回的是0
if (data_bytes + dst->data_count > dst->data_capacity) return ERROR; //用的空间+当前数据位置指针，不能大于数据最大空间。
size_t data_payload_bytes =
data_count * camera_metadata_type_size[type]; //data_count =1,data_payload_bytes =1;
camera_metadata_buffer_entry_t *entry = get_entries(dst) + dst->entry_count;//得到当前空闲的entry对象。
memset(entry, 0, sizeof(camera_metadata_buffer_entry_t)); //清0
entry->tag = tag; //ANDROID_FLASH_MODE.
entry->type = type; //BYTE_TYPE
entry->count = data_count; //没有占用data数据域，这里就是0了。
if (data_bytes == 0) {
memcpy(entry->data.value, data,
data_payload_bytes); //小于4字节的，直接放到entry数据域。
} else {
entry->data.offset = dst->data_count;
memcpy(get_data(dst) + entry->data.offset, data,
data_payload_bytes);
dst->data_count += data_bytes;
}
dst->entry_count++; //入口位置记录指针+1.
dst->flags &= ~FLAG_SORTED;
return OK; //到这里ANDROID_FLASH_MODE就添加进去了。
}
4.updata流程图与find操作
1）流程图
下面流程图中有些yes和no标识，在生成图片的时候，就不见了。大家理解意思就行。最难理解是下图中红色虚线框住的区域，大家要对照着源码自己在理解一下。由于在ubutnu下使用Dia画的流程图，所以就用简单的英语描述了一下。
2）find操作
find操作也是很简单，根据传入的tag，到entry区域查找是否有该tag，有的话就该tag的数据保存到struct camera_metadata_entry 结构体中，供外部使用。
camera_metadata_entry_t CameraMetadata::find(uint32_t tag) {
status_t res;
camera_metadata_entry entry;
if (mLocked) {
ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
entry.count = 0;
return entry;
}
res = find_camera_metadata_entry(mBuffer, tag, &entry);
if (CC_UNLIKELY( res != OK )) {
entry.count = 0;
entry.data.u8 = NULL;
}
return entry;
}版权声明：本文为armwind原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。