Android Camera 元数据Matada和与3A模式_android camera 3a(1)

最新推荐文章于 2024-06-08 11:35:58 发布
最新推荐文章于 2024-06-08 11:35:58 发布
阅读量828 收藏 9
点赞数 23
分类专栏： 程序员 文章标签： android 服务器 github
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79099460/article/details/138776229
版权 
VENDOR_SECTION = 0x8000

} camera_metadata_section_t;


camera metadata可以分为三类：安卓自带（谷歌），原厂定义（高通，联发科），第三方厂商（vivo，oppo，华为，其他）。


由于在内存中，各个tag 数据都是以有序的结构体形式保存起来，各个tag 对应的偏移地址如下：

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 = ANDROID_FLASH << 16,
ANDROID_FLASH_INFO_START = ANDROID_FLASH_INFO << 16,
ANDROID_HOT_PIXEL_START = ANDROID_HOT_PIXEL << 16,
ANDROID_JPEG_START = ANDROID_JPEG << 16,
ANDROID_LENS_START = ANDROID_LENS << 16,
ANDROID_LENS_INFO_START = ANDROID_LENS_INFO << 16,
ANDROID_NOISE_REDUCTION_START = ANDROID_NOISE_REDUCTION << 16,
ANDROID_QUIRKS_START = ANDROID_QUIRKS << 16,
ANDROID_REQUEST_START = ANDROID_REQUEST << 16,
ANDROID_SCALER_START = ANDROID_SCALER << 16,
ANDROID_SENSOR_START = ANDROID_SENSOR << 16,
ANDROID_SENSOR_INFO_START = ANDROID_SENSOR_INFO << 16,
ANDROID_SHADING_START = ANDROID_SHADING << 16,
ANDROID_STATISTICS_START = ANDROID_STATISTICS << 16,
ANDROID_STATISTICS_INFO_START = ANDROID_STATISTICS_INFO << 16,
ANDROID_TONEMAP_START = ANDROID_TONEMAP << 16,
ANDROID_LED_START = ANDROID_LED << 16,
ANDROID_INFO_START = ANDROID_INFO << 16,
ANDROID_BLACK_LEVEL_START = ANDROID_BLACK_LEVEL << 16,
ANDROID_SYNC_START = ANDROID_SYNC << 16,
ANDROID_REPROCESS_START = ANDROID_REPROCESS << 16,
ANDROID_DEPTH_START = ANDROID_DEPTH << 16,
VENDOR_SECTION_START = VENDOR_SECTION << 16
} camera_metadata_section_start_t;


接下来，定义了，各个TAG 对应换详细的参数，每个 `TAG 以 ##TAG##_START` 和 `##TAG##_END` 结束。


如前文所提到，**用户只能通过调用函数接口，来访问camera\_metadata\_t里面的内容**。函数接口实现的源码位于：system/media/camera/src/camera\_metadata.c。这个文件有上千行，这里仅提到几个关键的函数。



**3.metadata关键函数接口**


如前文所提到，**用户只能通过调用函数接口，来访问camera\_metadata\_t里面的内容**。函数接口实现的源码位于：system/media/camera/src/camera\_metadata.c。这个文件有上千行，这里仅提到几个关键的函数。


**allocate\_camera\_metadata （分配metadata）**

// 传入max entry和max data，给metadata分配地址空间
camera_metadata_t *allocate_camera_metadata(size_t entry_capacity, size_t data_capacity) {
size_t memory_needed = calculate_camera_metadata_size(entry_capacity, data_capacity); // 1. 计算size
void *buffer = calloc(1, memory_needed); // 2. 分配memory
camera_metadata_t metadata = place_camera_metadata( // 3. 生成metadata
buffer, memory_needed, entry_capacity, data_capacity);
if (!metadata) {
/ This should not happen when memory_needed is the same
* calculated in this function and in place_camera_metadata.
*/
free(buffer);
}
return metadata;
}
size_t calculate_camera_metadata_size(size_t entry_count,
size_t data_count) {
size_t memory_needed = sizeof(camera_metadata_t);
// Start entry list at aligned boundary
memory_needed = ALIGN_TO(memory_needed, ENTRY_ALIGNMENT);
memory_needed += sizeof(camera_metadata_buffer_entry_t[entry_count]);
// Start buffer list at aligned boundary
memory_needed = ALIGN_TO(memory_needed, DATA_ALIGNMENT);
memory_needed += sizeof(uint8_t[data_count]);
// Make sure camera metadata can be stacked in continuous memory
memory_needed = ALIGN_TO(memory_needed, METADATA_PACKET_ALIGNMENT);
return memory_needed;
}
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;

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;
metadata->version = CURRENT_METADATA_VERSION;
metadata->flags = 0;
metadata->entry_count = 0;
metadata->entry_capacity = entry_capacity;
metadata->entries_start =
        ALIGN_TO(sizeof(camera_metadata_t), ENTRY_ALIGNMENT);
metadata->data_count = 0;
metadata->data_capacity = data_capacity;
metadata->size = memory_needed;
size_t data_unaligned = (uint8_t*)(get_entries(metadata) +
        metadata->entry_capacity) - (uint8_t*)metadata;
metadata->data_start = ALIGN_TO(data_unaligned, DATA_ALIGNMENT);
metadata->vendor_id = CAMERA_METADATA_INVALID_VENDOR_ID;

assert(validate_camera_metadata_structure(metadata, NULL) == OK);
return metadata;

}


**find\_camera\_metadata\_entry（从metadata中根据tag查找value）**


这个函数的基本逻辑可以参考上文描述从metadata中“查”tag的逻辑。

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) {
    // 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++) {
        if (search_entry->tag == tag) {
            break;
        }
    }
    if (index == src->entry_count) return NOT_FOUND;
}

return get_camera_metadata_entry(src, index,
        entry);

}
int get_camera_metadata_entry(camera_metadata_t *src,
size_t index,
camera_metadata_entry_t *entry) {
if (src == NULL || entry == NULL) return ERROR;
if (index >= src->entry_count) return ERROR;

camera_metadata_buffer_entry_t *buffer_entry = get_entries(src) + index;

entry->index = index;
entry->tag = buffer_entry->tag;
entry->type = buffer_entry->type;
entry->count = buffer_entry->count;
if (buffer_entry->count *
        camera_metadata_type_size[buffer_entry->type] > 4) {
    entry->data.u8 = get_data(src) + buffer_entry->data.offset;
} else {
    entry->data.u8 = buffer_entry->data.value;
}
return OK;

}


**add\_camera\_metadata\_entry（增加tag和value到metadata）**

int add_camera_metadata_entry(camera_metadata_t *dst, uint32_t tag, const void *data, size_t data_count) {
// 1.根据tag，找到该tag对应的value的type。这个函数的具体实现不再粘贴出来，里面涉及到tag section相关结构体，后文描述
int type = get_local_camera_metadata_tag_type(tag, dst);
if (type == -1) {
ALOGE(“%s: Unknown tag %04x.”, FUNCTION, tag);
return ERROR;
}
// 2.将tag和data添加到metadata中。
return add_camera_metadata_entry_raw(dst, tag, type, data, data_count);
}
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_count && data == NULL) return ERROR;

// 1. 计算size，并进行4字节判断。如果小于4字节，将返回0。
size_t data_bytes = calculate_camera_metadata_entry_data_size(type, data_count);
if (data_bytes + dst->data_count > dst->data_capacity) return ERROR;

// 2. 计算数据的size
size_t data_payload_bytes = data_count * camera_metadata_type_size[type];

// 3. 生成camera_metadata_buffer_entry_t
camera_metadata_buffer_entry_t *entry = get_entries(dst) + dst->entry_count;
memset(entry, 0, sizeof(camera_metadata_buffer_entry_t));
entry->tag = tag;
entry->type = type;
entry->count = data_count;

// 4. copy数据到entry中
if (data_bytes == 0) {
    memcpy(entry->data.value, data, data_payload_bytes);
} else {
    entry->data.offset = dst->data_count;
    memcpy(get_data(dst) + entry->data.offset, data,
            data_payload_bytes);
    dst->data_count += data_bytes;
}

// 5. 增加一个entry
dst->entry_count++;


dst->flags &= ~FLAG_SORTED;	// add后，是没有经过排序的
assert(validate_camera_metadata_structure(dst, NULL) == OK);
return OK;

}

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

return data_bytes <= 4 ? 0 : ALIGN_TO(data_bytes, DATA_ALIGNMENT);

}


**delete\_camera\_metadata\_entry(删除tag）**


删除的逻辑相对有点复杂，因为tag对应的value可能在data数组的中间，需要后面的内容，覆盖要删除的内容。

int delete_camera_metadata_entry(camera_metadata_t *dst, size_t index) {
if (dst == NULL) return ERROR;
if (index >= dst->entry_count) return ERROR;

// 1. 根据index，找到对应的entry
camera_metadata_buffer_entry_t *entry = get_entries(dst) + index;

// 2. 获取value的size
size_t data_bytes = calculate_camera_metadata_entry_data_size(entry->type,
        entry->count);

if (data_bytes > 0) {
	// 3. data_bypes > 0，value的size>4字节，所以存储的data数组中
	// 这里开始对data数组的内容进行memmove

    // Shift data buffer to overwrite deleted data
    uint8_t *start = get_data(dst) + entry->data.offset;
    uint8_t *end = start + data_bytes;
    size_t length = dst->data_count - entry->data.offset - data_bytes;  // data_count是数组总长度，offset是value的起始位置，data_types是value的长度。相减就是value后面的数据的长度
    memmove(start, end, length); 	// value后面的数据向前移动到start位置，从end开始计算length个字节

	// 4. 更新当前tag之后的entry的offset
    // Update all entry indices to account for shift
    camera_metadata_buffer_entry_t *e = get_entries(dst);
    size_t i;
    for (i = 0; i < dst->entry_count; i++) {
        if (calculate_camera_metadata_entry_data_size(e->type, e->count) > 0 
            && e->data.offset > entry->data.offset) 
        {
            e->data.offset -= data_bytes;
        }
        ++e;
    }
    dst->data_count -= data_bytes;
}

// 5. 移动entry
// Shift entry array
memmove(entry, entry + 1, sizeof(camera_metadata_buffer_entry_t) * (dst->entry_count - index - 1) );
dst->entry_count -= 1;

assert(validate_camera_metadata_structure(dst, NULL) == OK);
return OK;

}

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

return data_bytes <= 4 ? 0 : ALIGN_TO(data_bytes, DATA_ALIGNMENT);

}


**update\_camera\_metadata\_entry(更新tag的value值）**


在调用 update\_camera\_metadata\_entry() 更新tag前，一定要通过 find\_camera\_metadata\_entry() 找到对应的entry，通过该entry获取其index（即entry在metadata的index）。  
 PS：参数updated\_entry，是用于获取update之后的tag。  
  

int update_camera_metadata_entry(camera_metadata_t *dst,
size_t index,
const void *data,
size_t data_count,
camera_metadata_entry_t *updated_entry) {
if (dst == NULL) return ERROR;
if (index >= dst->entry_count) return ERROR;

// 1. 根据index找到对应的entry
camera_metadata_buffer_entry_t *entry = get_entries(dst) + index;

// 2. data_bytes是新的value的size，如果小于4，就是0； 
//    data_payload_bytes是新的value真正的size；
//    entry_bytes是就的value的size
size_t data_bytes = calculate_camera_metadata_entry_data_size(entry->type, data_count);
size_t data_payload_bytes = data_count * camera_metadata_type_size[entry->type];
size_t entry_bytes = calculate_camera_metadata_entry_data_size(entry->type, entry->count);

if (data_bytes != entry_bytes) {
	// 新的value和旧的value的size不同时，需要进行下述操作

	// 3. 确定data的容量是否可以满足新的value
    // May need to shift/add to data array
    if (dst->data_capacity < dst->data_count + data_bytes - entry_bytes) {
        // No room
        return ERROR;
    }

	// 4. 删除旧的tag对应的value，实现类似delete函数
    if (entry_bytes != 0) {
        // Remove old data
        uint8_t *start = get_data(dst) + entry->data.offset;
        uint8_t *end = start + entry_bytes;
        size_t length = dst->data_count - entry->data.offset - entry_bytes;
        memmove(start, end, length);
        dst->data_count -= entry_bytes;

        // Update all entry indices to account for shift
        camera_metadata_buffer_entry_t *e = get_entries(dst);
        size_t i;
        for (i = 0; i < dst->entry_count; i++) {
            if (calculate_camera_metadata_entry_data_size(
                    e->type, e->count) > 0 &&
                    e->data.offset > entry->data.offset) {
                e->data.offset -= entry_bytes;
            }
            ++e;
        }
    }

	// 5. 将新的tag对应的value插入到最后方
    if (data_bytes != 0) {
        // Append new data
        entry->data.offset = dst->data_count;

        memcpy(get_data(dst) + entry->data.offset, data, data_payload_bytes);
        dst->data_count += data_bytes;
    }
} else if (data_bytes != 0) {
	// 6. data的size相等时直接override

    // data size unchanged, reuse same data location
    memcpy(get_data(dst) + entry->data.offset, data, data_payload_bytes);
}

if (data_bytes == 0) {
    // Data fits into entry
    memcpy(entry->data.value, data,
            data_payload_bytes);
}

entry->count = data_count;

if (updated_entry != NULL) {
    get_camera_metadata_entry(dst,
            index,
            updated_entry);
}

assert(validate_camera_metadata_structure(dst, NULL) == OK);
return OK;

}



**4.Camera 3A 状态与模式**


虽然实际的3A算法取决于HAL的实现，但是HAL接口定义了高级状态机描述，以允许HAL设备和框架就3A的当前状态进行通信并触发3A事件。


## 最后

**自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**

**深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。**

**因此收集整理了一份《2024年嵌入式&物联网开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**

![img](https://img-blog.csdnimg.cn/img_convert/ede3e501c2668e2a9cb9e94207f3a2db.png)

![img](https://img-blog.csdnimg.cn/img_convert/9fa27290acff042fa7d44572defd5a6c.jpeg)

![img](https://img-blog.csdnimg.cn/img_convert/9ec7c056eda06261d9cfd4de72fd6037.png)

 ![img](https://img-blog.csdnimg.cn/img_convert/6a1fe5859eb7a9649359e3ccbae92b46.png)

![img](https://img-blog.csdnimg.cn/img_convert/a87cc538290f9397ea8368da1aff789b.png)

![img](https://img-blog.csdnimg.cn/img_convert/c5dd259205fe53a1939aad5014bd1893.png)

![](https://img-blog.csdnimg.cn/img_convert/5feabf55ee667d5acb79529eb3725fdb.png)

 

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上嵌入式&物联网开发知识点，真正体系化！**

[**如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！**](https://bbs.csdn.net/topics/618654289)

**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**！！


aktF-1715537797794)]

 [外链图片转存中...(img-ov9H5HX4-1715537797794)]

[外链图片转存中...(img-mAvBkAE6-1715537797795)]

[外链图片转存中...(img-E9GyD75s-1715537797795)]

[外链图片转存中...(img-kL06cNGV-1715537797796)]

 

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上嵌入式&物联网开发知识点，真正体系化！**

[**如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！**](https://bbs.csdn.net/topics/618654289)

**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**！！
2301_79099460
关注
  • 23
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
camera 3A 算法
07-27
camera 3Acamera 3Acamera 3Acamera 3Acamera 3Acamera 3A
android camera系列(Camera1、Camera2、CameraX)的使用以及输出的图像格式
知识共享，你我皆是知识的搬运工
01-25 2588
android中camera的预览和数据操作
Android Camera 元数据Matada和与3A模式
weixin_49303682的博客
08-27 722
1.元数据 要支持通过 Android 框架保存原始图片文件，需要具有大量有关传感器特性的元数据，包括 色彩空间和镜头遮蔽功能等信息。 其中大多数信息是相机子系统的静态属性，因此可以在配置任何输出流水线或提交任何请求 之前进行查询。新的相机 API 极大地扩展了getCameraInfo()方法提供的信息，以便将此类 信息提供给应用。 此外，手动控制相机子系统需要各种设备提供的有关其当前状态的反馈，以及在捕获指定帧时 使用的实际参数。必须在输出元数据中包含硬件实际使用的控制（曝光时间、帧时..
Android Camera HAL3-metadata
YellowMax
03-28 3910
Metadata 是整个 Android camera 中类似于高楼大厦中的管道系统一样，贯穿了整个 Camera 的 Framework 和 vendor HAL，Metadata 里面几乎包含了所有的控制、参数、返回值等等，总线型的设计使得这个玩意儿承担的任务不可谓不重。本文从几个角度来学习一下 Metadata 的设计、使用、可优化的点，并不准备特别特别细节去介绍代码的每一行，主要是注重其想...
Android Camera 元数据Matada和与3A模式_android camera 3a
WJud11的博客
05-13 291
在调用 update_camera_metadata_entry() 更新tag前，一定要通过 find_camera_metadata_entry() 找到对应的entry，通过该entry获取其index（即entry在metadata的index）。camera metadata可以分为三类：安卓自带（谷歌），原厂定义（高通，联发科），第三方厂商（vivo，oppo，华为，其他）。删除的逻辑相对有点复杂，因为tag对应的value可能在data数组的中间，需要后面的内容，覆盖要删除的内容。
Android Camera 元数据Matada和与3A模式_android camera 3a(2)
2401_84009130的博客
05-13 941
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年嵌入式&物联网开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上嵌入式&物联网开发知识点，真正体系化！
android camera 3a,android camera系统3A模式及其状态转换（一）
weixin_39528029的博客
05-27 269
虽然HAL层负责实现3A算法，但HAL interface定义了一个高层次的状态机描述，允许HAL层设备和framework层交流3A当前状态和3A事件的触发情况。当设备被打开时，所有3A状态都应该是STATE_INACTIVE。码流配置不需重置3A。例如，需要通过调用configure()来修改固定焦点。要触发3A行为，需要为下一个请求简单地设置相关触发器实体，以引导触发器的启动。例如，启动自动...
Android Camera（五）3A 模式和状态转换
书山有路勤为径
02-04 1673
3A 模式和状态转换 目录 3A 模式和状态转换 自动对焦设置与结果条目 自动曝光设置与结果条目 自动白平衡设置和结果条目 一般状态机转换说明 AF 状态机 AE 和 AWB 状态机 启用手动控制 虽然实际的 3A 算法取决于 HAL 实现，但高级状态机的说明由 HAL 接口定义，以支持 HAL 设备和框架就 3A 的当前状态进行通信并触发 3A 事件。 当设备开启时，所有单...
cts cameraFov 3A规格
02-24
cts cameraFov 3A规格
Pixel 3 binaries for Android 10.0.0 (QQ3A.200805.001)
04-24
Pixel 3 binaries for Android 10.0.0 (QQ3A.200805.001)驱动 Hardware Component：Vendor image-Google Company：（google） SHA-256 Checksum：5141f8840df3989384767b121ebe28856fc382bd7c799b8e066f283c4122833...
android拍照录像demo
06-20
源于CameraKit-Android和compressor的android拍照录像demo，含有拍照，压缩，录像，照明，闪光灯，摄像头切换，图片质量切换等功能，可以在项目中直接使用。博客地址：...
meteor-camera:在桌面和移动设备上调用一次函数的照片
06-13
使用meteor add num3a:camera将其添加到您的应用程序中。 api 非常简单 - 只有一个函数可以调用。 MeteorCamera.getPicture([options], 回调) 提示用户用他们的设备拍照，并以 JPEG 格式的数据 URI 的形式获取图片...
Android 上层的View透传/不透传 点击事件 到下层
Goals1989的博客
06-06 286
点击事件 透传/不透传到下层控件
Android输入法IME（三）之 管理端（IMMS）启动流程
薛文旺
06-05 664
Android输入法IME（三）之 管理端（IMMS）启动流程
从 Android 恢复已删除的备份录
最新发布
Geeker55的博客
06-08 1020
但是，对于您拍摄的任何照片，如果您有 Google Photos，则备份已启用多年，因此您可能会对其中存储的内容感到惊讶。没有像 Windows 上的回收站或 Mac 上的垃圾箱那样的地方，删除的文件会保留一定天数，然后才真正删除它们。如果您的手机预装了 Google Drive，它已经备份了您的消息，否则，只需启用它即可保留文本。如果您想要一个功能齐全的工具，又不涉及弄乱您的手机，请尝试 Helium，它使用您的台式计算机并保存特定消息以及来自您的 Android 的数据。首先，尝试保留数据。
Android防抖
kqz2014的博客
06-05 265
null) {@Overridetask.run();
20240606更新Toybrick的TB-RK3588开发板在Android12下的内核
南岭笑笑生之家
06-06 919
20240606更新Toybrick的TB-RK3588开发板在Android12下的内核。使用RKDevTool_v3.15_for_window即可刷机了！
android camera api2与api1对比
06-02
Android相机API 2相对于API 1的主要改进： 1. 更好的性能和控制：API 2提供了更好的性能和更精细的控制，可以实现更高的帧率和更高的图像质量。 2. 更灵活的摄像机控制：API 2提供了更灵活的摄像机控制，包括手动对焦、曝光和白平衡控制等功能。这使得开发人员可以更好地控制相机的行为，并提供更好的用户体验。 3. RAW图像支持：API 2支持RAW图像捕捉，这使得开发人员可以更好地控制图像的后处理，从而实现更好的图像质量。 4. 支持多摄像头：API 2支持多摄像头，这使得开发人员可以更好地利用多个摄像头进行创意拍摄。 5. 更好的视频录制：API 2提供了更好的视频录制功能，包括更高的视频质量、更高的帧率和更好的音频捕捉。 总之，Android相机API 2相对于API 1提供了更好的性能、更精细的控制、更好的用户体验和更好的图像质量。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值