camx camera initial

原创

已于 2023-09-09 14:49:01 修改 · 776 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #camera

于 2023-09-08 21:08:05 首次发布

本文介绍了QNX平台中的camera hal接口，包括HAL3Module、CAMXHAL::Init、CAMXHAL::OpenCamera等操作，还阐述了initialize方法将上层回调接口传入HAL的过程。此外，详细分析了配置相机设备数据流的流程，包括选择UsecaseId和创建Usecase两个重要阶段。

qnx 平台中的camera hal 接口

HAL3Module：chi_hal_override_entry

在android 的中使用Camx 打开com.qti.chi.override.so进行注册hal ops 操作接口

camhal3module.cpp 中的构造函数HAL3Module中

CHIHALOverrideEntry funcCHIHALOverrideEntry = reinterpret_cast<CHIHALOverrideEntry>( CamX::OsUtils::LibGetAddr(m_hChiOverrideModuleHandle, "chi_hal_override_entry"));

qnx 中的so 路径 ./camera_qcx/build/qnx/cdk_qcx/core/lib/aarch64/dll-le/com.qti.chi.override.so

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief HAL Override entry
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chi_hal_override_entry(
    chi_hal_callback_ops_t* callbacks)
{
    ExtensionModule* pExtensionModule = ExtensionModule::GetInstance();

    CHX_ASSERT(NULL != callbacks);

    if (NULL != pExtensionModule)
    {
        callbacks->chi_get_num_cameras                  = chi_get_num_cameras;
        callbacks->chi_get_camera_info                  = chi_get_camera_info;
        callbacks->chi_get_info                         = chi_get_info;
        callbacks->chi_initialize_override_session      = chi_initialize_override_session;
        callbacks->chi_finalize_override_session        = chi_finalize_override_session;
        callbacks->chi_override_process_request         = chi_override_process_request;
        callbacks->chi_teardown_override_session        = chi_teardown_override_session;
        callbacks->chi_extend_open                      = chi_extend_open;
        callbacks->chi_extend_close                     = chi_extend_close;
        callbacks->chi_remap_camera_id                  = chi_remap_camera_id;
        callbacks->chi_modify_settings                  = chi_modify_settings;
        callbacks->chi_get_default_request_settings     = chi_get_default_request_settings;
        callbacks->chi_override_flush                   = chi_override_flush;
        callbacks->chi_override_signal_stream_flush     = chi_override_signal_stream_flush;
        callbacks->chi_override_dump                    = chi_override_dump;
        callbacks->chi_get_physical_camera_info         = chi_get_physical_camera_info;
        callbacks->chi_is_stream_combination_supported  = chi_is_stream_combination_supported;

        callbacks->chi_is_concurrent_stream_combination_supported = chi_is_concurrent_stream_combination_supported;
#if CAMERA3_API_HIGH_PERF
        callbacks->chi_override_start_recurrent_capture_requests  = chi_override_start_recurrent_capture_requests;
        callbacks->chi_override_stop_recurrent_capture_requests   = chi_override_stop_recurrent_capture_requests;
        callbacks->chi_override_set_settings                      = chi_override_set_settings;
        callbacks->chi_override_activate_channel                  = chi_override_activate_channel;
#endif // CAMERA3_API_HIGH_PERF
    }
}

CAMXHAL::Init

类似于android hardware\interfaces\camera\provider\2.4\default\cameraProvider.cpp 的函数CameraProvider::initialize 对camera 进行初始化操作获取注册注册的操作接口camera_common

最终获取的是chi_hal_override_entry注册接口

/**
* @brief
* Initialize CAMX HAL and CSL.
*
* @return
* Status as defined in CamStatus_e.
*/
CamStatus_e CAMXHAL::Init()
{
    CamStatus_e rc = CAMERA_SUCCESS;
    const hw_module_t* hw_module = NULL;

    CAM_TRACE_LOG(STREAM_MGR, "CAMXHAL::Init");
    int ret = hw_get_module(CAMERA_HARDWARE_MODULE_ID, &hw_module);
    if (0 != ret)
    {
        QCX_LOG(STREAM_MGR, ERROR, "Camera module not found");
        rc = CAMERA_EFAILED;
    }
    else
    {
        m_CameraModule = reinterpret_cast<const camera_module_t*>(hw_module);
        m_CameraModule->get_vendor_tag_ops(&m_Vtags);
        ret = m_CameraModule->init();
        if (0 != ret)
        {
            QCX_LOG(STREAM_MGR, ERROR, "Camera module init failed");
            rc = CAMERA_EFAILED;
        }
        else
        {
            ret = set_camera_metadata_vendor_ops(const_cast<vendor_tag_ops_t*>(&m_Vtags));
            if (0 != ret)
            {
                QCX_LOG(STREAM_MGR, ERROR, "set vendor tag ops failed (ret = %d)", ret);
                rc = CAMERA_EFAILED;
            }
            else
            {
                MetaData metaData(&m_Vtags);
                const char sectionName[] = "org.quic.camera.qtimer";
                const char tagName[]     = "timestamp";
                uint32_t   tagId         = 0;
                rc = metaData.GetTagId(tagName, sectionName, &tagId);
                if (CAMERA_SUCCESS != rc)
                {
                    QCX_LOG(STREAM_MGR, ERROR, "GetTagId failed, tagName = %s (result = 0x%x)",
                            tagName, rc);
                }
                else
                {
                    QCX_LOG(STREAM_MGR, DEBUG, "GetTagId successful, time stamp tagId = %u", tagId);
                    m_TimeStampTagId = tagId;
                }
            }
        }
        if (CAMERA_SUCCESS == rc)
        {
            m_NumOfCameras = m_CameraModule->get_number_of_cameras();
            if (m_NumOfCameras < 0)
            {
                QCX_LOG(STREAM_MGR, ERROR, "No camera found");
                rc = CAMERA_EFAILED;
            }
            else
            {
                QCX_LOG(STREAM_MGR, HIGH, "Camera module init success, no. of camera: %u",
                        m_NumOfCameras);
            }
        }

        if (CAMERA_SUCCESS == rc)
        {
            rc = BuildCameraIdMap();
            if (CAMERA_SUCCESS != rc)
            {
                QCX_LOG(STREAM_MGR, ERROR, "Populating logical camera Ids failed(result = 0x%x)",
                        rc);
            }
            else
            {
                QCX_LOG(STREAM_MGR, DEBUG, "Logical camera Ids obtained");
            }
        }
    }
    CAM_TRACE_LOG(STREAM_MGR, "CAMXHAL::Init : End");
    return rc;
}

CAMXHAL::OpenCamera

调用的是 chi_extend_open函数进行camera的open

Android 中与之对应的是hardware\qcom\camera\qcamera2\QCamera2Factory.cpp

QCamera2Factory::cameraDeviceOpen

/**
 * @brief
 *   Open camera corresponding Stream Session.
 *
 * @param pSession [in, out]
 *   pointer to Stream Session.
 *
 * @return
 *   Status as defined in CamStatus_e.
 */
CamStatus_e CAMXHAL::OpenCamera(StreamSession* pSession)
{
    CamStatus_e rc      = CAMERA_SUCCESS;
    CamStatus_e rcMutex = CAMERA_SUCCESS;
    rcMutex = OSAL_CriticalSectionEnter(m_CamxMutex);
    CAM_TRACE_LOG(STREAM_MGR, "CAMXHAL::OpenCamera");
    if (CAMERA_SUCCESS != rcMutex)
    {
        QCX_LOG(STREAM_MGR, ERROR, "Failed in OSAL_CriticalSectionEnter(rc=%u)", rcMutex);
        rc = rcMutex;
    }
    else
    {
        hw_device_t* localDevice = nullptr;

        uint32_t logicalId = 0xFFFFFFFFU;
        for (uint32_t i = 0; i < pSession->m_NumInputs; i++)
        {
            if (m_CamIdMap.find(pSession->m_InputId[i]) == m_CamIdMap.end())
            {
                QCX_LOG(STREAM_MGR, ERROR, "Logical camera Id not found for physical CamId=%u",
                        pSession->m_InputId[i]);
                rc = CAMERA_EBADPARAM;
                break;
            }
            else
            {
                if (0xFFFFFFFFU == logicalId)
                {
                    logicalId = m_CamIdMap[pSession->m_InputId[i]];
                }
                else
                {
                    if (m_CamIdMap[pSession->m_InputId[i]] != logicalId)
                    {
                        QCX_LOG(STREAM_MGR, ERROR, "Logical camera Id %u for input Id %u is invalid",
                                logicalId, pSession->m_InputId[i]);
                        rc = CAMERA_EBADPARAM;
                        break;
                    }
                }
            }
        }
        if (CAMERA_SUCCESS == rc)
        {
            pSession->m_logicalCameraId = logicalId;
            int ret = m_CameraModule->common.methods->open((const hw_module_t*)m_CameraModule,
                std::to_string(logicalId).c_str(), &localDevice);

            if ((0 != ret) || (nullptr == localDevice))
            {
                QCX_LOG(STREAM_MGR, ERROR, "Camera open failed for camera id: %u", logicalId);