hal层之camera显示处理流程分析

最新推荐文章于 2025-01-18 20:55:57 发布

原创最新推荐文章于 2025-01-18 20:55:57 发布 · 1k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#音视频 #linux #图像处理 #uvc

本文详细介绍了Android硬件抽象层(HAL)中相机设备的打开流程，从`camera_device_open`开始，经过`CameraHal`实例化，到`CameraAdapter`初始化并打开相机设备。接着，阐述了相机预览的启动过程，包括`startPreview`调用，`CameraAdapter`的`startPreview`方法，以及`CameraPreviewThread`的创建和运行。在预览流程中，`DisplayAdapter`接收并处理来自相机的帧数据，并通过`ANativeWindow`将帧数据送至显示。整个流程涉及到了硬件接口、线程同步和显示逻辑等多个关键环节。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

hal层camera设备打开流程

int camera_device_open(const hw_module_t* module, const char* name, k\hardware\rockchip\camera\CameraHal\CameraHal_Module.cpp
if (name != NULL) { //获取camera的id
cameraid = atoi(name);

            camera = new android::CameraHal(cameraid);

CameraHal::CameraHal(int cameraId)-> \hardware\rockchip\camera\CameraHal\CameraHal.cpp
mCameraAdapter = new CameraUSBAdapter(cameraId);

int CameraAdapter::initialize() \hardware\rockchip\camera\CameraHal\CameraAdapter.cpp
int CameraAdapter::initialize()
{
int ret = -1;
//create focus thread
LOG_FUNCTION_NAME

if((ret = cameraCreate(mCamId)) < 0)
    return ret;

initDefaultParameters(mCamId);
LOG_FUNCTION_NAME_EXIT
return ret;

}

int CameraAdapter::cameraCreate(int cameraId)

   cameraDevicePathCur = (char*)&gCamInfos[cameraId].device_path[0];
  iCamFd = open(cameraDevicePathCur, O_RDWR);

mCamFd = iCamFd;

hal层camera预览流程梳理

int camera_start_preview(struct camera_device * device) \sdk\hardware\rockchip\camera\CameraHal\CameraHal_Module.cpp
->int CameraHal::startPreview() \sdk\hardware\rockchip\camera\CameraHal\CameraHal.cpp
if ((mCommandThread != NULL)) {
msg.command = CMD_PREVIEW_START;
msg.arg1 = NULL;
setCamStatus(CMD_PREVIEW_START_PREPARE, 1);
commandThreadCommandQ.put(&msg);

-> void CameraHal::commandThread()
case CMD_PREVIEW_START:
err=mCameraAdapter->startPreview(app_previw_w,app_preview_h,drv_w, drv_h, 0, false);调用cameraAdapter来显示
status_t CameraAdapter::startPreview(int preview_w,int preview_h,int w, int h, int fmt,bool is_capture)\hardware\rockchip\camera\CameraHal\CameraAdapter.cpp
mCameraPreviewThread = new CameraPreviewThread(this);
mCameraPreviewThread->run(“CameraPreviewThread”,ANDROID_PRIORITY_DISPLAY);

 void CameraAdapter::previewThread(){ 在这里循环去除camera帧并送到DisplayAdpter显示   \sdk\hardware\rockchip\camera\CameraHal\CameraAdapter.cpp
                        mRefDisplayAdapter->notifyNewFrame(tmpFrame);

void DisplayAdapter::notifyNewFrame(FramInfo_s* frame)\sdk\hardware\rockchip\camera\CameraHal\DisplayAdapter.cpp

void DisplayAdapter::notifyNewFrame(FramInfo_s* frame)
{
mDisplayLock.lock();
//send a frame to display
if((mDisplayRuning == STA_DISPLAY_RUNNING)
&&(mDisplayState != CMD_DISPLAY_PAUSE_PREPARE)
&&(mDisplayState != CMD_DISPLAY_PAUSE_DONE)
&&(mDisplayState != CMD_DISPLAY_STOP_PREPARE)
&&(mDisplayState != CMD_DISPLAY_STOP_DONE))
{
Message_cam msg;
msg.command = CMD_DISPLAY_FRAME;
msg.arg1 = NULL;
msg.arg2 = (void*)frame;
msg.arg3 = (void*)(frame->used_flag);
displayThreadCommandQ.put(&msg);
mDisplayCond.signal(); 发消息给DisplayAdapter开始显示
}else{
//must return frame if failed to send display
if(mFrameProvider)
mFrameProvider->returnFrame(frame->frame_index,frame->used_flag);
}
mDisplayLock.unlock();
}
void DisplayAdapter::displayThread() \hardware\rockchip\camera\CameraHal\DisplayAdapter.cpp 在这里处理显示逻辑
case CMD_DISPLAY_FRAME:

framework层传入window缓冲区过程
void initHalPreviewWindow() frameworks/av/services/camera/libcameraservice/device1/CameraHardwareInterface.h
void initHalPreviewWindow() 生成mHalPreviewWindow.对象
{
mHalPreviewWindow.nw.cancel_buffer = __cancel_buffer;
mHalPreviewWindow.nw.lock_buffer = __lock_buffer;
mHalPreviewWindow.nw.dequeue_buffer = __dequeue_buffer; 获取显示缓冲区
mHalPreviewWindow.nw.enqueue_buffer = __enqueue_buffer;
mHalPreviewWindow.nw.set_buffer_count = __set_buffer_count;
mHalPreviewWindow.nw.set_buffers_geometry = __set_buffers_geometry;
mHalPreviewWindow.nw.set_crop = __set_crop;
mHalPreviewWindow.nw.set_timestamp = __set_timestamp;
mHalPreviewWindow.nw.set_usage = __set_usage;
mHalPreviewWindow.nw.set_swap_interval = __set_swap_interval;

    mHalPreviewWindow.nw.get_min_undequeued_buffer_count =
            __get_min_undequeued_buffer_count;
}

static int __dequeue_buffer(struct preview_stream_ops* w, frameworks/av/services/camera/libcameraservice/device1/CameraHardwareInterface.h
buffer_handle_t** buffer, int *stride)
{
int rc;
ANativeWindow a = anw(w);
ANativeWindowBuffer anb;
rc = native_window_dequeue_buffer_and_wait(a, &anb);
if (!rc) {
*buffer = &anb->handle;
*stride = anb->stride;
}
return rc;
}

status_t initialize(CameraModule *module)frameworks/av/services/camera/libcameraservice/device1/CameraHardwareInterface.h
{
ALOGI(“Opening camera %s”, mName.string());
camera_info info;
status_t res = module->getCameraInfo(atoi(mName.string()), &info);
if (res != OK) {
return res;
}

    int rc = OK;
    if (module->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_3 &&
        info.device_version > CAMERA_DEVICE_API_VERSION_1_0) {
        // Open higher version camera device as HAL1.0 device.
        rc = module->openLegacy(mName.string(),
                                 CAMERA_DEVICE_API_VERSION_1_0,
                                 (hw_device_t **)&mDevice);
    } else {
        rc = module->open(mName.string(), (hw_device_t **)&mDevice);   打开摄像头模块，获得device指针
    }
    if (rc != OK) {
        ALOGE("Could not open camera %s: %d", mName.string(), rc);
        return rc;
    }
    initHalPreviewWindow();
    return rc;
}

status_t setPreviewWindow(const sp& buf) frameworks/av/services/camera/libcameraservice/device1/CameraHardwareInterface.h
{
ALOGV("%s(%s) buf %p", FUNCTION, mName.string(), buf.get());
if (mDevice->ops->set_preview_window) {
mPreviewWindow = buf;
if (buf != nullptr) {
if (mPreviewScalingMode != NOT_SET) {
setPreviewScalingMode(mPreviewScalingMode);
}
if (mPreviewTransform != NOT_SET) {
setPreviewTransform(mPreviewTransform);
}
}
mHalPreviewWindow.user = this;
ALOGV("%s &mHalPreviewWindow %p mHalPreviewWindow.user %p", FUNCTION,
&mHalPreviewWindow, mHalPreviewWindow.user);
return mDevice->ops->set_preview_window(mDevice, //调用hal层的set_preview_window把mHalPreviewWindow传递过去使用
buf.get() ? &mHalPreviewWindow.nw : 0);
}
return INVALID_OPERATION;
}
int CameraHal::setPreviewWindow(struct preview_stream_ops window) Y:\rk3288_7.1_0907\sdk\hardware\rockchip\camera\CameraHal\CameraHal.cpp
{
LOG_FUNCTION_NAME
Message_cam msg;
Semaphore sem;
Mutex::Autolock lock(mLock);
if ((mCommandThread != NULL)) {
msg.command = CMD_SET_PREVIEW_WINDOW;
sem.Create();
msg.arg1 = (void)(&sem);
msg.arg2 = (void*)window;
setCamStatus(CMD_SET_PREVIEW_WINDOW_PREPARE, 1);
commandThreadCommandQ.put(&msg);
if(msg.arg1){
sem.Wait();
}
if(mCameraStatus&CMD_SET_PREVIEW_WINDOW_DONE)
LOG1(“set preview window OK.”);
}
LOG_FUNCTION_NAME_EXIT
return 0;
}
hal层利用传入的window显示camera过程
void CameraHal::commandThread()
case CMD_SET_PREVIEW_WINDOW:
mDisplayAdapter->setPreviewWindow((struct preview_stream_ops )msg.arg2);
int DisplayAdapter::setPreviewWindow(struct preview_stream_ops window) \hardware\rockchip\camera\CameraHal\DisplayAdapter.cpp
{
//mDisplayRuning status
//mANativeWindow null?
//window null ?
LOG_FUNCTION_NAME
if(window == NULL){
LOGW(“set preview window null,stop display?”);
}
if(window == mANativeWindow){
LOGD(“preview native window is the same,so ignore it.”);
return 0;
}
if(mANativeWindow){
pauseDisplay();
}
mANativeWindow = window; 获得window
LOG_FUNCTION_NAME_EXIT
return 0;
}
int DisplayAdapter::cameraDisplayBufferCreate(int width, int height, const char fmt,int numBufs) hardware\rockchip\camera\CameraHal\DisplayAdapter.cpp
err = mANativeWindow->set_buffers_geometry(
err = mANativeWindow->dequeue_buffer(mANativeWindow, (buffer_handle_t*)&hnd, &stride);
mapper.lock((buffer_handle_t)mDisplayBufInfo[i].priv_hnd, CAMHAL_GRALLOC_USAGE, bounds, y_uv);
mDisplayBufInfo[i].vir_addr = (long)y_uv[0]; 把显示缓冲区地址赋值给vir_addr
void DisplayAdapter::displayThread() 在这个线程里处理显示相关的逻辑