Hal需要实现的接口就是 libhardware\include\hardware\camera3.h
#ifndef ANDROID_INCLUDE_CAMERA3_H
#define ANDROID_INCLUDE_CAMERA3_H
#include <system/camera_metadata.h>
#include "camera_common.h"
......
/**********************************************************************
*
* Camera device definition
*
*/
typedef struct camera3_device {
/**
* common.version must equal CAMERA_DEVICE_API_VERSION_3_0 to identify this
* device as implementing version 3.0 of the camera device HAL.
*
* Performance requirements:
*
* Camera open (common.module->common.methods->open) should return in 200ms, and must return
* in 500ms.
* Camera close (common.close) should return in 200ms, and must return in 500ms.
*
*/
hw_device_t common;
camera3_device_ops_t *ops;
void *priv;
} camera3_device_t;
在rk目录中hal\rockchip\camera\AAL是实现上层定义的接口,
hal\rockchip\camera\AAL\Camera3HAL.cpp
static camera3_device_ops hal_dev_ops = {
NAMED_FIELD_INITIALIZER(initialize) hal_dev_initialize,
NAMED_FIELD_INITIALIZER(configure_streams) hal_dev_configure_streams,
NAMED_FIELD_INITIALIZER(register_stream_buffers) nullptr,
NAMED_FIELD_INITIALIZER(construct_default_request_settings) hal_dev_construct_default_request_settings,
NAMED_FIELD_INITIALIZER(process_capture_request) hal_dev_process_capture_request,
NAMED_FIELD_INITIALIZER(get_metadata_vendor_tag_ops) nullptr,
NAMED_FIELD_INITIALIZER(dump) hal_dev_dump,
NAMED_FIELD_INITIALIZER(flush) hal_dev_flush,
NAMED_FIELD_INITIALIZER(reserved) {0},
};
定义了camera3_device_ops_t交互接口
其实这些接口相较hal1有所减少,但是根据pipeline特性,hal代码实际变得更加复杂。
看一下赋值流程
hardware\rockchip\camera\Camera3HALModule.cpp
这个函数定义camerahal的接口
camera_module_t VISIBILITY_PUBLIC HAL_MODULE_INFO_SYM = {
NAMED_FIELD_INITIALIZER(common) {
……
NAMED_FIELD_INITIALIZER(methods) &hal_module_methods,
……
}
static struct hw_module_methods_t hal_module_methods = {
NAMED_FIELD_INITIALIZER(open) hal_dev_open
};
也就是camerahal模块的open函数是hal_dev_open
static int hal_dev_open(const hw_module_t* module, const char* name,
hw_device_t** device)
{
……
return openCameraHardware(camera_id, module, device);
}
int openCameraHardware(int id, const hw_module_t* module, hw_device_t** device)
{
……
Camera3HAL* halDev = new Camera3HAL(id, module);
if (halDev->init() != NO_ERROR) {//init的时候会new mRequestThread
……
}
Camera3HAL::Camera3HAL(int cameraId, const hw_module_t* module) :
mCameraId(cameraId),
mCameraHw(nullptr),
mRequestThread(nullptr)
{
……
mDevice.common.tag = HARDWARE_DEVICE_TAG;
mDevice.common.version = info.device_version;
mDevice.common.module = (hw_module_t *)(module);
// hal_dev_close is kept in the module for symmetry with dev_open
// it will be set there
mDevice.common.close = nullptr;
mDevice.ops = &hal_dev_ops;//赋值接口函数定义
mDevice.priv = this;//记住这个私有指针就是Camera3HAL
}
这种是通用做法,将设备(camera3_device)包含在各家厂商实现的类(Camera3HAL)中,设备的私有指针又指向Camera3HAL,这样,设备camera3_device里的函数又可以通过priv调用Camera3HAL中的函数。
这样比较绕,比如
Camera3HAL* camera_priv = (Camera3HAL*)(dev->priv);
static int
hal_dev_initialize(const struct camera3_device * dev,
const camera3_callback_ops_t *callback_ops)
{
……
return camera_priv->initialize(callback_ops);
}
正常来说接口函数就只到这里,继续要看这几个接口函数的实现。
先接着看这个initialize函数的实现把
callback_ops是在Camera3Device::Camera3Device上层就已经初始化好了。
hal_dev_initialize(camera3_device-> camera3_device_ops-> initialize) 实际执行的是Camera3HAL中的initialize函数
int Camera3HAL::initialize(const camera3_callback_ops_t *callback_ops)
{
……
status = mRequestThread->init(callback_ops);
……
}
通过发现几个接口函数都是执行mRequestThread下面的对应函数
函数定义在RequestThread.cpp 关注下对应几个函数做了什么
status_t
RequestThread::init(const camera3_callback_ops_t *callback_ops)
{
……// ItemPool<Camera3Request> mRequestsPool 定义
//看init函数是分配MAX_REQUEST_IN_PROCESS_NUM个Camera3Request
status = mRequestsPool.init(MAX_REQUEST_IN_PROCESS_NUM);
……//new结果处理类,然后注册错误返回
mResultProcessor = new ResultProcessor(this, callback_ops);
mCameraHw->registerErrorCallback(mResultProcessor);
mInitialized = true;
return NO_ERROR;
}
RequestThread::configureStreams(camera3_stream_configuration_t *stream_list)
{
Message msg;
msg.id = MESSAGE_ID_CONFIGURE_STREAMS;
msg.data.streams.list = stream_list;
//只是向mMessageQueue队列发送消息,之后看处理函数
return mMessageQueue.send(&msg, MESSAGE_ID_CONFIGURE_STREAMS);
}
同理constructDefaultRequest,processCaptureRequest也是发送到消息队列
register_stream_buffers,get_metadata_vendor_tag_ops函数因为是3.2的版本,只需要为空即可
对应看看接受消息的处理
mRequestThread 里的mMessageQueue消息处理
mRequestThread 的构造函数,这个线程就跑起来了
RequestThread::messageThreadLoop是循环loop函数,里面接受消息。
switch (msg.id) {
case MESSAGE_ID_CONFIGURE_STREAMS:
status = handleConfigureStreams(msg);
break;
case MESSAGE_ID_CONSTRUCT_DEFAULT_REQUEST:
status = handleConstructDefaultRequest(msg);
break;
case MESSAGE_ID_PROCESS_CAPTURE_REQUEST:
status = handleProcessCaptureRequest(msg);
replyImmediately = (mBlockAction == REQBLK_NONBLOCKING);
break;
case MESSAGE_ID_REQUEST_DONE:
status = handleReturnRequest(msg);
break;
case MESSAGE_ID_FLUSH:
break;
default:
LOGE("ERROR @%s: Unknow message %d", __FUNCTION__, msg.id);
status = BAD_VALUE;
break;
}
这就是上层的接口都是发消息到mRequestThread,然后mRequestThread接收消息处理上层事件,所有调用统一到这里。然后处理这些消息。