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