Android Camera原理之camx hal架构_libcamhal

于 2024-09-04 20:51:21 发布
阅读量879 收藏 24
点赞数 26
文章标签： android 架构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_86391981/article/details/141903724
版权

https://www.jianshu.com/p/099cc3b0ab25

typedef struct camera3_device_ops {
    int (*initialize)(const struct camera3_device *,
            const camera3_callback_ops_t *callback_ops);
    int (*configure_streams)(const struct camera3_device *,
            camera3_stream_configuration_t *stream_list);
    int (*register_stream_buffers)(const struct camera3_device *,
            const camera3_stream_buffer_set_t *buffer_set);
    const camera_metadata_t* (*construct_default_request_settings)(
            const struct camera3_device *,
            int type);
    int (*process_capture_request)(const struct camera3_device *,
            camera3_capture_request_t *request);
    void (*get_metadata_vendor_tag_ops)(const struct camera3_device*,
            vendor_tag_query_ops_t* ops);
    void (*dump)(const struct camera3_device *, int fd);
    int (*flush)(const struct camera3_device *);
 
    /* reserved for future use */
    void *reserved[8];
} camera3_device_ops_t;

这样找到在camera hal层的函数指针的映射关系。

映射到：vendor/qcom/proprietary/camx/src/core/hal/camxhal3entry.cpp 中的：

// Global dispatch
static Dispatch g_dispatchHAL3(&g_jumpTableHAL3);

看一下g_jumpTableHAL3 变量：在 vendor/qcom/proprietary/camx/src/core/hal/camxhal3.cpp 中定义的:


// Jump table for HAL3

JumpTableHAL3 g_jumpTableHAL3 =
{
    open,
    get_number_of_cameras,
    get_camera_info,
    set_callbacks,
    get_vendor_tag_ops,
    open_legacy,
    set_torch_mode,
    init,
    parallelQuery,
    setCallBack,
    get_tag_count,
    get_all_tags,
    get_section_name,
    get_tag_name,
    get_tag_type,
    close,
    initialize,
    configure_streams,
    construct_default_request_settings,
    process_capture_request,
    dump,
    flush,
    camera_device_status_change,
    torch_mode_status_change,
    process_capture_result,
    notify
};

这儿直接构成了指针函数的映射关系。

vendor/qcom/proprietary/camx/src/core/chi/camxchitypes.h中定义了CHIAppCallbacks结构体，如下：

struct CHIAppCallbacks
{
    /// @brief Called by the driver to get number of cameras
    INT(*CHIGetNumCameras)(
        UINT32* pNumFwCameras,
        UINT32* pNumLogicalCameras);
 
    /// @brief Called by the driver to get the camera info for the camera id
    CamxResult (*CHIGetCameraInfo)(
        UINT32      cameraId,
        CameraInfo* pCameraInfo);
 
    /// @brief Defines the prototype for the device status change callback method from to the framework. Please refer to
    ///        the camera_device_status_change documentation in hardware/camera_common.h.
    VOID (*CHIInitializeOverrideSession)(
        UINT32               cameraId,
        const Camera3Device* pCamera3Device,
        const HALCallbacks*  pHALCallbacks,
        Camera3StreamConfig* pStreamConfig,
        BOOL*                isOverrideEnabled,
        VOID**               ppPrivate);
 
    /// @brief Defines the prototype for the torch mode status change callback method from to the framework. Please refer to
    ///        the torch_mode_status_change documentation in hardware/camera_common.h.
    VOID (*CHIFinalizeOverrideSession)(
        const Camera3Device* pCamera3Device,
        UINT64*              pSession,
        VOID**               ppPrivate);
 
    /// @brief Called by the driver to inform about session closing
    VOID (*CHITeardownOverrideSession)(
        const Camera3Device* pCamera3Device,
        UINT64*              pSession,
        VOID*                pPrivate);
 
    /// @brief Called by the driver to pass on capture request call to CHI
    INT (*CHIOverrideProcessRequest)(
        const Camera3Device*    pCamera3Device,
        Camera3CaptureRequest*  pCaptureRequest,
        VOID*                   pPrivate);
 
    /// @brief Called by the driver to allow for additional override processing during open()
    INT(*CHIExtendOpen)(
        UINT32  cameraId,
        VOID*   pPrivateData);
 
    /// @brief Called by the driver to allow for additional override processing during close()
    INT(*CHIExtendClose)(
        UINT32  cameraId,
        VOID*   pPrivateData);
 
    /// @brief Called by the driver to allow override to remap special camera IDs into logical camera IDs
    UINT32(*CHIRemapCameraId)(
        UINT32              frameworkCameraId,
        CameraIdRemapMode   mode);
 
    /// @brief Interface to allow various override-specific settings to be toggled.
    UINT32(*CHIModifySettings)(
        VOID*   pPrivateData);
 
    /// @brief Get any vendor tag specific request settings the override wants to get added to the default settings
    VOID (*CHIGetDefaultRequestSettings)(
        UINT32           frameworkCameraId,
        INT              requestTemplate,
        const Metadata** pAdditionalMetadata);
 
    /// @brief Called by the driver to allow for flush()
    INT(*CHIOverrideFlush)(
        const Camera3Device*    pCamera3Device);
    INT(*CHIParallelQuery) (INT num, char* list[]);
    INT(*CHISetCallback) (void*);
 
};
 
typedef VOID(*CHIHALOverrideEntry)(
    CHIAppCallbacks* pCHIAppCallbacks);

这个结构体是函数指针，如何映射的，看看下面的关系：

vendor/qcom/proprietary/camx/src/core/hal/camxhal3module.h中定义的CHIAppCallbacks m_ChiAppCallbacks;

CHIAppCallbacks m_ChiAppCallbacks; ///< CHI HAL override entry

在 vendor/qcom/proprietary/camx/src/core/hal/camxhal3module.cpp中的 HAL3Module构造函数中，存在下面的执行语句：

CHIHALOverrideEntry funcCHIHALOverrideEntry =
    reinterpret_cast<CHIHALOverrideEntry>(
        CamX::OsUtils::LibGetAddr(m_hChiOverrideModuleHandle, "chi_hal_override_entry"));
 
if (NULL != funcCHIHALOverrideEntry)
{
    funcCHIHALOverrideEntry(&m_ChiAppCallbacks);
 
    CAMX_ASSERT(NULL != m_ChiAppCallbacks.CHIGetNumCameras);
    CAMX_ASSERT(NULL != m_ChiAppCallbacks.CHIGetCameraInfo);
    CAMX_ASSERT(NULL != m_ChiAppCallbacks.CHIFinalizeOverrideSession);
    CAMX_ASSERT(NULL != m_ChiAppCallbacks.CHIInitializeOverrideSession);
    CAMX_ASSERT(NULL != m_ChiAppCallbacks.CHIOverrideProcessRequest);
    CAMX_ASSERT(NULL != m_ChiAppCallbacks.CHIOverrideFlush);
    CAMX_ASSERT(NULL != m_ChiAppCallbacks.CHITeardownOverrideSession);
    CAMX_ASSERT(NULL != m_ChiAppCallbacks.CHIExtendOpen);
    CAMX_ASSERT(NULL != m_ChiAppCallbacks.CHIExtendClose);
    CAMX_ASSERT(NULL != m_ChiAppCallbacks.CHIRemapCameraId);
    CAMX_ASSERT(NULL != m_ChiAppCallbacks.CHIModifySettings);
    CAMX_ASSERT(NULL != m_ChiAppCallbacks.CHIParallelQuery);
    CAMX_ASSERT(NULL != m_ChiAppCallbacks.CHISetCallback);
 
    if ((NULL != m_ChiAppCallbacks.CHIGetNumCameras)             &&
        (NULL != m_ChiAppCallbacks.CHIGetCameraInfo)             &&
        (NULL != m_ChiAppCallbacks.CHIFinalizeOverrideSession)   &&
        (NULL != m_ChiAppCallbacks.CHIInitializeOverrideSession) &&
        (NULL != m_ChiAppCallbacks.CHIOverrideProcessRequest)    &&
        (NULL != m_ChiAppCallbacks.CHIOverrideFlush)             &&
        (NULL != m_ChiAppCallbacks.CHITeardownOverrideSession)   &&
        (NULL != m_ChiAppCallbacks.CHIExtendOpen)                &&
        (NULL != m_ChiAppCallbacks.CHIExtendClose)               &&
        (NULL != m_ChiAppCallbacks.CHIRemapCameraId)             &&
        (NULL != m_ChiAppCallbacks.CHIModifySettings)            &&
        (NULL != m_ChiAppCallbacks.CHIParallelQuery)             &&
        (NULL != m_ChiAppCallbacks.CHISetCallback))
    {
        CAMX_LOG_WARN(CamxLogGroupHAL, "CHI Module library function pointers exchanged");
    }
}

m_ChiAppCallbacks 通过 funcCHIHALOverrideEntry 映射到 chi_hal_override_entry
这个 chi_hal_override_entry 就是指 vendor/qcom/proprietary/chi-cdk/vendor/chioverride/default/chxextensioninterface.cpp 中的 chi_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_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_parallelquery                = chi_parallelquery;
        callbacks->chi_setcallback                  = chi_setcallback;
    }
}

这样就建立了 CHIAppCallbacks 中函数指针的一一映射关系。

camx_code.jpg

vendor/qcom/proprietary/chi-cdk/vendor/chioverride/default/chxextensionmodule.cpp 中的 ExtensionModule::OverrideProcessRequest 函数中执行了 m_pUsecaseFactory->CreateUsecaseObject，如下：

m_pSelectedUsecase[logicalCameraId] =
            m_pUsecaseFactory->CreateUsecaseObject(&m_logicalCameraInfo[logicalCameraId],
                static_cast<UsecaseId>(m_SelectedUsecaseId[logicalCameraId]),
                m_pStreamConfig[logicalCameraId]);

直接调用到： vendor/qcom/proprietary/chi-cdk/vendor/chioverride/default/chxusecaseutils.cpp 中的 UsecaseFactory::CreateUsecaseObject 函数：

Usecase* UsecaseFactory::CreateUsecaseObject(
    LogicalCameraInfo*              pLogicalCameraInfo,     ///< camera info
    UsecaseId                       usecaseId,              ///< Usecase Id
    camera3_stream_configuration_t* pStreamConfig)          ///< Stream config
{
    Usecase* pUsecase  = NULL;
    UINT     camera0Id = pLogicalCameraInfo->ppDeviceInfo[0]->cameraId;
    CHX_LOG_ERROR("UsecaseFactory::CreateUsecaseObject id = %d", usecaseId);
    switch (usecaseId)
    {
        case UsecaseId::PreviewZSL:
            pUsecase = AdvancedCameraUsecase::Create(pLogicalCameraInfo, pStreamConfig, usecaseId);
            break;
        case UsecaseId::MultiCamera:
            pUsecase = UsecaseMultiCamera::Create(pLogicalCameraInfo, pStreamConfig);
            break;
        case UsecaseId::MultiCameraVR:
            pUsecase = UsecaseMultiVRCamera::Create(pLogicalCameraInfo, pStreamConfig);
            break;
        case UsecaseId::MFNR:
            pUsecase = UsecaseMFNR::Create(camera0Id, pStreamConfig);
            break;
        case UsecaseId::QuadCFA:
            pUsecase = UsecaseQuadCFA::Create(pLogicalCameraInfo, pStreamConfig);
            break;
        case UsecaseId::Torch:
            pUsecase = UsecaseTorch::Create(camera0Id, pStreamConfig);
            break;
        default:
            pUsecase = AdvancedCameraUsecase::Create(pLogicalCameraInfo, pStreamConfig, usecaseId);
            break;
    }
 
    return pUsecase;
}


enum class UsecaseId
{
    NoMatch         = 0,
    Default         = 1,
    Preview         = 2,
    PreviewZSL      = 3,
    MFNR            = 4,
    MFSR            = 5,
    MultiCamera     = 6,
    QuadCFA         = 7,
    RawJPEG         = 8,
    MultiCameraVR   = 9,
    Torch           = 10,
    YUVInBlobOut    = 11,
    MaxUsecases     = 12,
};

前置摄像头的UsecaseId是 PreviewZSL，是单摄，后置摄像头的UsecaseId是 MultiCamera，是多摄。

camx-usecase

camx_usecase.jpg

vendor/qcom/proprietary/camx/src/core/chi/camxchi.cpp中的 ChiEntry函数如下：


/// ChiEntry

CAMX_VISIBILITY_PUBLIC VOID ChiEntry(
    ChiContextOps* pChiContextOps)
{
    if (NULL != pChiContextOps)
    {
        pChiContextOps->size                       = sizeof(ChiContextOps);
 
        pChiContextOps->majorVersion               = CHI_API_MAJOR_VERSION;
        pChiContextOps->minorVersion               = CHI_API_MINOR_VERSION;
        pChiContextOps->pOpenContext               = CamX::ChiOpenContext;
        pChiContextOps->pCloseContext              = CamX::ChiCloseContext;
        pChiContextOps->pGetNumCameras             = CamX::ChiGetNumCameras;
        pChiContextOps->pGetCameraInfo             = CamX::ChiGetCameraInfo;
        pChiContextOps->pEnumerateSensorModes      = CamX::ChiEnumerateSensorModes;
        pChiContextOps->pCreatePipelineDescriptor  = CamX::ChiCreatePipelineDescriptor;
        pChiContextOps->pDestroyPipelineDescriptor = CamX::ChiDestroyPipelineDescriptor;
        pChiContextOps->pCreateSession             = CamX::ChiCreateSession;
        pChiContextOps->pDestroySession            = CamX::ChiDestroySession;
        pChiContextOps->pFlushSession              = CamX::ChiFlushSession;
        pChiContextOps->pActivatePipeline          = CamX::ChiActivatePipeline;
        pChiContextOps->pDeactivatePipeline        = CamX::ChiDeactivatePipeline;
        pChiContextOps->pSubmitPipelineRequest     = CamX::ChiSubmitPipelineRequest;
        pChiContextOps->pTagOps                    = CamX::ChiGetTagOps;
    }
 
    // This is the workaround for presil HAL3test on Windows
    // On Device, set_camera_metadata_vendor_ops will be call the set the
    // static vendor tag operation in camera_metadata.c
    //
    // On Windows side, theoretically hal3test should mimic what Android framework
    // does and call the set_camera_metadata_vendor_ops function in libcamxext library
    // However, in Windows, if both hal3test.exe and hal.dll link to libcamxext library,
    // there are two different instance of static varibles sit in different memory location.
    // Even if set_camera_metadata_vendor_ops is called in hal3test, when hal try to
    // access to vendor tag ops, it is still not set.
    //
    // This is also a workaround to call vendor tag ops in Chi at GetNumCameras which happens to get called before
    // GetVendorTagOps
    CamX::g_vendorTagOps.get_all_tags     = CamX::ChiGetAllTags;
    CamX::g_vendorTagOps.get_section_name = CamX::ChiGetSectionName;
    CamX::g_vendorTagOps.get_tag_count    = CamX::ChiGetTagCount;
    CamX::g_vendorTagOps.get_tag_name     = CamX::ChiGetTagName;
    CamX::g_vendorTagOps.get_tag_type     = CamX::ChiGetTagType;
 
    set_camera_metadata_vendor_ops(&(CamX::g_vendorTagOps));
}

这个函数映射关系很重要，也在camx chi中比较常见，直接映射在此文件的CamxChi类中。都是从 vendor/qcom/proprietary/chi-cdk/vendor/chioverride/default/chxextensionmodule.cpp中调用过来的。

下面是预览时capture request 处理流程图：

camx_pipeline流程.jpg

check这段流程的时候我们最关注应该是5个重要的处理类型：

  • 1.UseCase ， vendor/qcom/proprietary/chi-cdk/vendor/chioverride/default/chxusecase.h 上面有介绍类图。UseCase在camx中很有很多衍生类，这是camx针对不同的stream来建立不同的usecase对象，用来管理选择feature，并且创建 pipeline以及session
  • 2.ChiFeature， vendor/qcom/proprietary/chi-cdk/vendor/chioverride/default/chxfeature.h， usecase选择相应的feature，关联一组pipeline，收到request请求，根据request选择对应的feature
  • 3.Node ， vendro/qcom/propriatary/camx/src/core/camxnode.h ，下面有类图。Node是camx中非常重要的一个父类，是camx中处理camera 请求的一个中间节点，用于处理pipeline下发的请求，下面有类图介绍，比较重要**的Node子类已经标出来了。
  • 4.pipeline ， 一连串node的集合，通过pipeline下发给各个node处理。
  • 5.session ， 若干个有关联的pipeline的集合，用来管理pipeline，使用pipeline处理请求。
    Node 节点在camx chi架构中至关重要，数据的处理都是通过封装好的Node节点来进行的。

camxnode结构图

camx_node.jpg

node节点的创建地方在vendor/qcom/proprietary/camx/src/hwl/titian17x/camxtitian17xfactory.cpp

Node* Titan17xFactory::HwCreateNode(
    const NodeCreateInputData* pCreateInputData,
    NodeCreateOutputData*      pCreateOutputData
    ) const
{
    Node* pNode = NULL;
 
    switch (pCreateInputData->pNodeInfo->nodeId)
    {
        case AutoFocus:
            pNode = AutoFocusNode::Create(pCreateInputData, pCreateOutputData);
            break;
        case BPS:
            pNode = BPSNode::Create(pCreateInputData, pCreateOutputData);
            break;
        case IFE:
            pNode = IFENode::Create(pCreateInputData, pCreateOutputData);
            break;
        case IPE:
            pNode = IPENode::Create(pCreateInputData, pCreateOutputData);
            break;
        case Sensor:
            pNode = SensorNode::Create(pCreateInputData, pCreateOutputData);
            break;
        case StatsProcessing:
            pNode = StatsProcessingNode::Create(pCreateInputData, pCreateOutputData);
            break;
        case JPEG:
            pNode = JPEGEncNode::Create(pCreateInputData, pCreateOutputData);
            break;
        case JPEGAggregator:
            pNode = JPEGAggrNode::Create(pCreateInputData, pCreateOutputData);
            break;
        case StatsParse:
            pNode = StatsParseNode::Create(pCreateInputData, pCreateOutputData);
            break;
        case ChiExternalNode:
            pNode = ChiNodeWrapper::Create(pCreateInputData, pCreateOutputData);
            break;
        case FDHw:
            pNode = FDHwNode::Create(pCreateInputData, pCreateOutputData);
            break;
        case FDManager:
            pNode = FDManagerNode::Create(pCreateInputData, pCreateOutputData);
            break;
        case OfflineStats:
            pNode = OfflineStatsNode::Create(pCreateInputData, pCreateOutputData);
            break;
        case Torch:
            pNode = TorchNode::Create(pCreateInputData, pCreateOutputData);
            break;
        case LRME:
            pNode = LRMENode::Create(pCreateInputData, pCreateOutputData);
            break;
        case RANSAC:
            pNode = RANSACNode::Create(pCreateInputData, pCreateOutputData);
            break;
        default:
            CAMX_ASSERT_ALWAYS_MESSAGE("Unexpected node type");
            break;
    }
 
    return pNode;
}

Feature类图.jpg

camx_feature.jpg

在 vendor/qcom/proprietary/chi-cdk/vendor/chioverride/default/chxadvancedcamerausecase.cpp中的SelectFeatures(…)函数中有这些feature的创建代码，接下来讲解拍照的时候会详细分析一下。

现在说下拍照的场景，拍照的场景分为前置和后置，前置是单摄，后置是多摄，前面也有介绍，单摄和多摄使用的usecase是不同的，我们先讲解一下单摄。

2401_86391981
关注
Android Camera Qcom Camx架构
weixin_49303682的博客
08-28 1488
1.Camx-CHI基本目录结构 Camx 代表通用功能性接口的代码集合， chi-cdk 代表可定制化需求的代码实现集合， Camx 部分对上作为 HAL3 接口的实现， 对下通过 v4l2 框架与 Kernel 保持通讯， 中间通过互相 dlopen so 库并获取对方操作接口的方式保持着与 CHI 的交互。 2.Camx/下主要目录： core/： 存放 camx 的核心实现模块， 还包含主要用于实现 hal3 接口的 hal/目录， 以及负责 与 CHI 进行交互的 chi/目录
Android Camera--hw_get_module获取camx模块接口
weixin_49303682的博客
05-17 649
我们知道，google为了保护硬件厂商的信息，在Android中添加了一层，也就是大名鼎鼎的HAL 层。 在看HAL的编写方法的过程中，会发现整个模块貌似没有一个入口。一般说来模块都要有个入口， 比如应用程序有main函数，可以为加载器进行加载执行，dll文件有dllmain，而对于我们自己写的 动态链接库，我们可以对库中导出的任何符号进行调用。 问题来了，Android中的HAL是比较具有通用性的，需要上层的函数对其进行加载调用，Android的 HAL加载器是如何实现对不同的Hardware
Android camera 架构HAL3
10-18
Android camera 架构HAL3及其演进，V4L2介绍 PPT
Android Camera原理之camx hal架构
zmjames2000 Just record
09-26 2681
come from :https://www.jianshu.com/p/cfb1da9d4217 之前看过F7A与D2T的camera hal层源码，这两个手机的camera hal层源码结构是相当清晰的，都是放在hardware/目录中，就是通常说说的QCamera2架构，整体结构也比较简单，脉络比较清晰，但是代码糅合在一起，看上去很繁杂，分层思想体现的不明显。 目前主流的机型都使用ca...
Android Camera原理之camx hal架构之cam chi
zmjames2000 Just record
03-25 4304
come from :https://www.jianshu.com/p/80de4a6e478c 一、CAM CHI API功能介绍： Android开发了相机硬件接口，允许OEM生产 为最终用户提供高质量的相机解决方案。 Camera2 java API的组合 使用HAL3接口进行相机应用程序开发可以提供足够的灵活性 支持各种用例。大多数用例都可以实现 Camera2 / HAL3。但是...
Android Camera HAL浅析
热门推荐
crycheng的专栏
07-24 5万+
1、Camera成像原理介绍 Camera工作流程图 Camera的成像原理可以简单概括如下： 景物(SCENE)通过镜头（LENS）生成的光学图像投射到图像传感器(Sensor)表面上，然后转为电信号，经过A/D（模数转换）转换后变为数字图像信号，再送到数字信号处理芯片（DSP）中加工处理，再通过IO接口传输到CPU中处理，通过D
Android Camera从App层到framework层到HAL层的初始化过程
xiaowang_lj的博客
07-21 1534
Camera2.0首先启动的是CameraActivity，而它继承自QuickActivity，在代码中你会发现没有重写OnCreate等生命周期方法，因为此处采用的是模板方法的设计模式，在QuickActivity中的onCreate方法调用的是onCreateTasks等方法，所以要看onCreate方法就只须看onCreateTasks方法即可。该方法又调用mm_camera_channel.c的mm_channel_init方法，进入mm_camera_channel.c的该方法;
Android Camera--hw_get_module获取camx模块接口_hw_module_exists
2401_84132544的博客
04-04 290
dlopen camera.qcom.so，dlsym获取HAL_MODULE_INFO_SYM符号的地址，即camx模块的入口。：rawModule类型为camera_module_t，被强制转换为hw_module_t类型去获取结构体。是camera_module_t的第一个成员变量即为hw_module_t类型，所以地址相同，获取到该成员变量。问题来了，Android中的HAL是比较具有通用性的，需要上层的函数对其进行加载调用，Android的。cameraserver 进程启动，注册，初始化；
CamX-Chi 高通Android Camera HAL框架学习2-configure_streams
AuvKaixin的博客
05-04 338
25.chxadvancedcamerausecase.cpp: 主要做如下两件事\n1.ConfigureStream(pCameraInfo, pStreamConfig);//chxusecaseutils.cpp :1.enum class UsecaseId{\nNoMatch= 0,\nDefault= 1,\nPreview= 2,\n…//chxusecaseutils.cpp : 获取usecaseId, 返回selectedUsecaseId。
Camx架构-Camera kernel Driver & debugging
我的博客
06-03 2850
Camx架构-Camera kernel Driver & debugging
camera hal
John_chaos的博客
05-12 474
https://www.cnblogs.com/blogs-of-lxl/p/10651611.html
Android 13 Camera HAL启动流程（1）
weixin_41678668的博客
05-30 2243
Android Camera系统开发的开篇，先介绍Camera HAL启动流程
android camera client、CameraService及camera hal调用流程
kk3087961的博客
02-02 1960
这里的 hardware::camera::provider::V2_4::ICameraProvider 对应 android.hardware.camera.provider@2.4 .so模块，CameraProvider就是与HAL层so的交互。因为 Camera 也继承 ::android::hardware::BnCameraClient 所以可以将 Camera 赋值给 TCamCallbacks（即 TCam为::android::hardware::ICameraClient）
相机HAL
许浑的博客
09-13 833
该相机框架还支持 HIDL 相机 HAL，不过，在 Android 13 或更高版本中添加的相机功能只能通过 AIDL 相机 HAL 接口使用。如需在升级到 Android 13 或更高版本的设备上实现此类功能，设备制造商必须将其 HAL 进程从使用 HIDL 相机接口迁移到使用 AIDL 相机接口。借助额外的控制能力，您可以更轻松地在 Android 设备上构建高品质的相机应用，这些应用可在多种产品上稳定运行，同时仍会尽可能使用设备专用算法来最大限度地提升质量和性能。捕获的优先级高于重复请求的优先级。
Camera HAL（Camera Preview）
hong
02-22 5182
看看Android系统，高通camera hal（camera3）当中camera preview数据是怎么从kernel一层一层传递，最终发给SurfaceView的。 高通的Camera HAL的module在QualcommCamera.cpp[android/hardware/qcom/camera/qcamera2/hal/wrapper] 这个Camera HAL被加载是在Cam
Android Camera hal
帅的没拼音
11-03 1474
一：CameraService 加载camera.imx6.so 源码位置：android6.0/frameworks/av/services/camera/libcameraservice/CameraService.cpp void CameraService::onFirstRef() { ALOGI("CameraService process starting"); BnCameraService::onFirstRef(); // Update ...
camx-打开相机预览hal3接口流程
AuvKaixin的博客
06-17 734
flush会在所有的buffer都得以释放，所有request都成功返回后才真正返回，该方法需要在100ms内返回，最长不能超过1000ms。并未开始进行流转的request会直接返回，并携带错误信息。任何无法进行打断的硬件操作会在当前状态下进行休眠。所有的还在流转的request会尽可能快的返回。任何可以打断的硬件操作会立即被停止。关闭相机的时候，也会调用这个方法。
车载相机 HAL
最新发布
weixin_48213783的博客
07-19 1188
Android 的汽车 HIDL 硬件抽象层 (HAL) 可用于在 Android 启动过程的初期拍摄并显示图像，且可在系统的整个生命周期内持续运行。HAL 包含外景系统 (EVS) 堆栈，且通常用于在搭载基于 Android 的车载信息娱乐 (IVI) 系统的汽车上为后视摄像头和环绕视图显示提供支持。EVS 还支持在用户应用中实现高级功能。Android 还包含一个 EVS 专用的拍摄和显示驱动程序接口（位于。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值