高通CamX架构实战：从零搭建调试环境到跑通第一个HAL3请求

高通CamX架构实战：从零搭建调试环境到跑通第一个HAL3请求

如果你刚接触高通Camera HAL3开发，面对庞大的CamX代码库和复杂的CHI架构，可能会感到无从下手。网上资料要么是零散的概念介绍，要么是深奥的源码分析，真正能让你动手实践的“板级”教程却很少。今天，我就带你从零开始，搭建一个可实操的CamX开发环境，并一步步跟踪第一个HAL3请求的完整流程。

我最近在调试一个基于骁龙平台的相机项目时，发现很多开发者卡在环境搭建和基础调试上。其实CamX架构虽然复杂，但只要掌握几个关键环节，就能快速上手。这篇文章不会重复那些架构图讲解，而是聚焦于实际动手操作——用Docker容器搭建开发环境、修改配置文件开启调试日志、在真实设备上跟踪请求调用链。

1. 环境准备：用Docker容器化你的CamX开发环境

传统的高通平台开发环境搭建是个头疼的问题——需要特定的Ubuntu版本、一堆依赖库、复杂的交叉编译工具链。我推荐使用Docker容器化方案，这能保证环境一致性，也方便团队共享。

1.1 Docker镜像构建与配置

首先创建一个Dockerfile，基于Ubuntu 20.04 LTS：

FROM ubuntu:20.04 # 设置时区避免apt-get交互 ENV TZ=Asia/Shanghai RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone # 安装基础工具和依赖 RUN apt-get update && apt-get install -y \ git-core gnupg flex bison build-essential zip curl zlib1g-dev \ gcc-multilib g++-multilib libc6-dev-i386 libncurses5-dev \ lib32ncurses5-dev x11proto-core-dev libx11-dev lib32z1-dev \ libgl1-mesa-dev libxml2-utils xsltproc unzip fontconfig python3 \ openjdk-11-jdk ssh rsync schedtool ccache libssl-dev \ libxml2-dev liblz4-tool libevent-dev bc kmod cpio \ libtinfo5 libncurses5-dev libncursesw5-dev \ && rm -rf /var/lib/apt/lists/* # 安装repo工具 RUN curl https://storage.googleapis.com/git-repo-downloads/repo > /usr/local/bin/repo \ && chmod a+x /usr/local/bin/repo # 创建非root用户 RUN useradd -m -s /bin/bash camxdev && echo "camxdev:camxdev" | chpasswd \ && usermod -aG sudo camxdev USER camxdev WORKDIR /home/camxdev # 设置环境变量 ENV USE_CCACHE=1 ENV CCACHE_DIR=/home/camxdev/.ccache RUN mkdir -p $CCACHE_DIR && ccache -M 50G CMD ["/bin/bash"]

构建并运行容器：

# 构建镜像 docker build -t camx-dev-env:latest . # 运行容器，挂载代码目录 docker run -it --name camx-dev \ -v /path/to/your/android/source:/home/camxdev/android \ -v /path/to/your/camx/code:/home/camxdev/camx \ camx-dev-env:latest

1.2 源码同步与编译配置

进入容器后，同步Android源码和CamX代码。这里有个关键点：CamX代码位于vendor/qcom/proprietary/目录下，但高通通常不会公开这部分源码，你需要从合作方获取或使用参考设计代码。

假设你已经有了CamX源码，目录结构大致如下：

vendor/qcom/proprietary/ ├── camx/ │ ├── src/ │ │ ├── core/ # 核心框架代码 │ │ ├── hwl/ # 硬件抽象层 │ │ ├── swl/ # 软件节点 │ │ └── chi/ # CHI接口 │ └── build/ ├── chi-cdk/ │ ├── vendor/ │ │ └── chioverride/ # OEM定制代码 │ └── topology/ # 用例配置文件 └── camera-kernel/ # 内核驱动

编译CamX需要先设置Android构建环境：

# 进入Android源码根目录 cd /home/camxdev/android # 初始化构建环境 source build/envsetup.sh # 选择目标设备（以sm8350为例） lunch qssi-userdebug # 单独编译camera模块 make -j$(nproc) camera.qcom

注意：实际编译时可能需要根据你的平台选择正确的lunch配置。如果遇到编译错误，通常是缺少依赖库，需要检查Android.bp或Android.mk文件。

1.3 开发板连接与刷机

有了编译好的镜像，接下来需要刷到参考手机上。我使用的是基于骁龙888的参考设计板（RD）。刷机步骤：

# 进入fastboot模式 adb reboot bootloader # 刷入boot镜像 fastboot flash boot boot.img # 刷入vendor镜像（包含CamX） fastboot flash vendor vendor.img # 刷入system镜像 fastboot flash system system.img # 重启设备 fastboot reboot

刷机完成后，验证Camera HAL是否正常加载：

adb shell lshal | grep camera # 应该看到类似输出： # android.hardware.camera.provider@2.4::ICameraProvider/qcom/camera alive

2. 深入CamX架构：理解HAL3请求的完整路径

在开始调试前，我们需要理清HAL3请求在CamX中的流转路径。这不像看架构图那么简单，得知道代码实际怎么跑。

2.1 HAL3接口到CamX的映射关系

Android Camera HAL3定义了一套标准接口，高通在CamX中实现了这些接口。关键映射在camxhal3entry.cpp中：

// vendor/qcom/proprietary/camx/src/core/hal/camxhal3entry.cpp static camera3_device_ops_t g_camera3DeviceOps = { .initialize = CamX::initialize, .configure_streams = CamX::configure_streams, .register_stream_buffers = NULL, // HAL3.2已废弃 .construct_default_request_settings = CamX::construct_default_request_settings, .process_capture_request = CamX::process_capture_request, // 重点！ .get_metadata_vendor_tag_ops = NULL, .dump = CamX::dump, .flush = CamX::flush, .reserved = {0}, };

当Camera Service调用process_capture_request时，实际执行的是CamX::process_capture_request。这个函数在camxhal3.cpp中实现，是请求进入CamX世界的入口。

2.2 请求在CamX-CHI间的跳转

CamX和CHI（Camera Hardware Interface）通过动态库互相调用。这是高通设计的精妙之处：CamX处理通用流程，CHI处理厂商定制。

看看这个跳转关系：

Camera Framework ↓ Camera HAL3 Interface (camera3_device_ops_t) ↓ CamX::process_capture_request() // camxhal3.cpp ↓ HAL3Module::ProcessCaptureRequest() // camxhal3module.cpp ↓ CHI Override (chi_hal_override_entry) // chxextensioninterface.cpp ↓ ExtensionModule::ProcessRequest() // chxextensionmodule.cpp ↓ Usecase::ExecuteCaptureRequest() // chxadvancedcamerausecase.cpp

关键数据结构CHIAppCallbacks定义了CHI需要实现的回调函数：

// vendor/qcom/proprietary/camx/src/core/chi/camxchitypes.h struct CHIAppCallbacks { INT(*CHIGetNumCameras)(UINT32* pNumFwCameras, UINT32* pNumLogicalCameras); CamxResult (*CHIGetCameraInfo)(UINT32 cameraId, CameraInfo* pCameraInfo); VOID (*CHIInitializeOverrideSession)(...); VOID (*CHIFinalizeOverrideSession)(...); INT (*CHIOverrideProcessRequest)(...); // 处理请求的核心回调 // ... 其他回调 };

2.3 UseCase与Pipeline的选择机制

不同的拍摄场景对应不同的UseCase。比如前置单摄预览使用PreviewZSL，后置多摄使用MultiCamera。选择逻辑在UsecaseSelector::GetMatchingUsecase()中：

// vendor/qcom/proprietary/chi-cdk/vendor/chioverride/default/chxusecaseutils.cpp UsecaseId UsecaseSelector::GetMatchingUsecase( const LogicalCameraInfo* pCamInfo, camera3_stream_configuration_t* pStreamConfig) { UsecaseId usecaseId = UsecaseId::Default; // 根据流配置选择UseCase if (pStreamConfig->num_streams == 1) { // 单流场景 if (/* 判断是否为ZSL */) { usecaseId = UsecaseId::PreviewZSL; } else if (/* 判断是否为视频 */) { usecaseId = UsecaseId::Video; } } else if (pCamInfo->numPhysicalCameras > 1) { // 多摄场景 usecaseId = UsecaseId::MultiCamera; } CHX_LOG_INFO("Selected usecase ID: %d", static_cast<int>(usecaseId)); return usecaseId; }

UseCase确定后，会创建对应的Pipeline。Pipeline在XML中定义，编译时生成g_pipelines.h。以titan17x_usecases.xml为例：

<!-- vendor/qcom/proprietary/chi-cdk/vendor/topology/default/titan17x_usecases.xml --> <Usecase name="UsecaseZSL"> <Targets> <Target id="Display" type="Sink" width="1920" height="1080" format="YUV420"/> <Target id="Video" type="Sink" width="3840" height="2160" format="YUV420"/> </Targets> <Pipeline name="RealtimeZSLPreview"> <NodeList> <Node name="IFE" type="IFE" instance="IFE0"/> <Node name="IPE" type="IPE" instance="IPE0"/> <Node name="JPEG" type="JPEG" instance="JPEG0"/> </NodeList> <PortLinkages> <Link src="IFE:OutputPort0" dst="IPE:InputPort0"/> <Link src="IPE:OutputPort0" dst="JPEG:InputPort0"/> </PortLinkages> </Pipeline> </Usecase>

3. 实战调试：修改配置与跟踪请求

理论讲得再多，不如动手调试一次。我们通过修改配置文件开启详细日志，然后跟踪一个简单预览请求的完整路径。

3.1 开启CamX调试日志

CamX的日志系统很完善，但默认只输出错误信息。要开启详细日志，需要修改camxsettings.xml：

<!-- vendor/qcom/proprietary/camx/src/core/camxsettings.xml --> <Settings> <!-- 日志级别：0=无, 1=错误, 2=警告, 3=信息, 4=详细, 5=性能 --> <Log> <LogLevel value="5"/> <!-- 改为5开启所有日志 --> <LogInfoMask value="0xFFFFFFFF"/> <!-- 信息掩码：全开 --> <LogVerboseMask value="0xFFFFFFFF"/> <!-- 详细掩码：全开 --> <OverrideLogLevels value="0x1F"/> <!-- 覆盖所有组 --> </Log> <!-- 特定模块日志控制 --> <LogGroups> <Group name="HAL" level="4"/> <Group name="CORE" level="4"/> <Group name="CSL" level="3"/> <!-- Camera Subsystem Layer --> <Group name="NODE" level="4"/> <Group name="PIPELINE" level="4"/> <Group name="SESSION" level="4"/> </LogGroups> </Settings>

修改后重新编译vendor镜像并刷机。查看日志：

adb logcat -s CAMX # 或更详细的过滤 adb logcat -s CAMX:* -s CHI:* -s "CameraService"

你会看到大量调试信息。关键日志标记如下：

3.2 跟踪process_capture_request调用链

现在打开相机预览，观察请求的完整路径。我写了一个简单的Python脚本来自动化日志分析：

#!/usr/bin/env python3 """ CamX请求跟踪脚本 实时分析logcat输出，标记请求流转的关键节点 """ import subprocess import re import sys class RequestTracker: def __init__(self): self.request_id = None self.stages = [] def process_line(self, line): # 检测新的请求 if "process_capture_request" in line and "requestId" in line: match = re.search(r'requestId\[(\d+)\]', line) if match: self.request_id = match.group(1) self.stages = [] print(f"\n🔍 开始跟踪请求 #{self.request_id}") self.stages.append(("HAL3入口", line.strip())) # 跟踪请求在CamX中的流转 elif self.request_id and f"requestId[{self.request_id}]" in line: if "CAMX: [VERB]" in line: # 提取关键阶段 if "Session::ProcessCaptureRequest" in line: self.stages.append(("Session处理", line.strip())) elif "Pipeline::ProcessRequest" in line: self.stages.append(("Pipeline分发", line.strip())) elif "Node::ExecuteProcessRequest" in line: # 提取节点名 node_match = re.search(r'Node\[([^\]]+)\]', line) node_name = node_match.group(1) if node_match else "Unknown" self.stages.append((f"Node执行: {node_name}", line.strip())) # 请求完成 elif self.request_id and "ProcessCaptureResult" in line and f"frameNum[{self.request_id}]" in line: print(f"\n✅ 请求 #{self.request_id} 完成") print("流转路径:") for i, (stage, detail) in enumerate(self.stages, 1): print(f" {i}. {stage}") if i <= 3: # 只显示前3个详细日志 print(f" {detail[:100]}...") print("-" * 80) self.request_id = None def main(): # 启动logcat进程 cmd = ["adb", "logcat", "-s", "CAMX:V", "CHI:V", "CameraService:V"] proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) tracker = RequestTracker() try: for line in proc.stdout: sys.stdout.write(line) tracker.process_line(line) except KeyboardInterrupt: print("\n停止跟踪") finally: proc.terminate() if __name__ == "__main__": main()

运行这个脚本，你会看到类似这样的输出：

🔍 开始跟踪请求 #42 ✅ 请求 #42 完成 流转路径: 1. HAL3入口: CAMX: [INFO] process_capture_request: requestId[42], numOutputBuffers=1 2. Session处理: CAMX: [VERB] Session::ProcessCaptureRequest: requestId[42], pipeline=0x7a8b3c00 3. Pipeline分发: CAMX: [VERB] Pipeline::ProcessRequest: requestId[42], numNodes=5 4. Node执行: IFE: CAMX: [VERB] IFENode::ExecuteProcessRequest: requestId[42], portId=0 5. Node执行: IPE: CAMX: [VERB] IPENode::ExecuteProcessRequest: requestId[42], portId=1 6. Node执行: JPEG: CAMX: [VERB] JPEGEncNode::ExecuteProcessRequest: requestId[42]

3.3 关键节点调试技巧

在跟踪过程中，有几个关键节点值得特别关注：

3.3.1 IFE节点（图像前端）

IFE是Sensor数据进入CamX的第一站。调试IFE可以了解原始数据情况：

# 查看IFE配置 adb shell dumpsys media.camera | grep -A 20 "IFE" # 查看Sensor模式 adb shell "cat /sys/kernel/debug/camera/ife/status"

在代码中，IFE节点的关键函数是IFENode::ExecuteProcessRequest()。可以添加自定义日志：

// 在vendor/qcom/proprietary/camx/src/hwl/ife/ifenfode.cpp中 CAMX_LOG_VERBOSE(CamxLogGroupISP, "IFE[%s] 处理请求 %llu, 分辨率: %dx%d", GetNodeIdentifierString(), requestId, width, height);

3.3.2 IPE节点（图像处理引擎）

IPE负责图像质量增强（降噪、锐化、色彩校正等）。调试IPE可以了解图像处理流水线：

// 在vendor/qcom/proprietary/camx/src/hwl/ipe/ipenfode.cpp中 // 添加性能监控 UINT64 startTime = OsUtils::GetNanoSeconds(); // ... 处理逻辑 ... UINT64 endTime = OsUtils::GetNanoSeconds(); CAMX_LOG_PERF(CamxLogGroupISP, "IPE处理耗时: %llu ns", endTime - startTime);

3.3.3 内存与Buffer管理

CamX使用复杂的Buffer管理机制。调试Buffer问题：

# 查看Camera Buffer使用情况 adb shell dumpsys media.camera | grep -i buffer # 查看GraphicBuffer内存 adb shell "cat /d/ion/heaps/qcom_system"

在代码中，Buffer分配在ImageBufferManager::Allocate()中：

// vendor/qcom/proprietary/camx/src/core/camximagebuffermanager.cpp CAMX_LOG_VERBOSE(CamxLogGroupMem, "分配Buffer: 大小=%u, 格式=%d, 对齐=%u", size, format, alignment);

4. 常见问题排查与性能优化

在实际开发中，你会遇到各种问题。这里总结几个常见场景的排查方法。

4.1 相机启动失败

如果相机无法启动，按这个顺序排查：

1. 检查HAL加载：

   adb shell lshal | grep -A 5 -B 5 camera.qcom

2. 查看Camera Provider日志：

   adb logcat -s "CameraProvider" --pid=$(adb shell pidof android.hardware.camera.provider@2.4-service)

3. 检查权限：

   adb shell "ls -l /dev/video*" adb shell "getenforce" # 应该是Permissive或对应SELinux策略

4. 查看CamX初始化日志：

   adb logcat -s CAMX | grep -i "initialize\|init"

4.2 预览卡顿或掉帧

预览性能问题通常与Pipeline配置有关：

1. 检查帧率：

   # 查看Camera Service帧率统计 adb shell dumpsys media.camera | grep -i fps

2. 分析Pipeline延迟： 修改camxsettings.xml，开启性能日志：

   <Log> <EnablePerfLog value="TRUE"/> <PerfLogLevel value="2"/> <!-- 1=基本, 2=详细, 3=带时间戳 --> </Log>

3. 优化Node处理顺序： 在Pipeline XML中调整Node顺序，减少数据拷贝：

   <Pipeline name="PreviewPipeline"> <NodeList> <!-- IFE应该在最前面 --> <Node name="IFE" type="IFE" instance="IFE0"/> <!-- 降噪在色彩校正之前 --> <Node name="ASF" type="ASF" instance="ASF0"/> <Node name="LTM" type="LTM" instance="LTM0"/> <!-- 显示处理在最后 --> <Node name="Display" type="Display" instance="Display0"/> </NodeList> </Pipeline>

4.3 内存泄漏排查

CamX中的内存泄漏通常与Buffer管理有关：

1. 监控Buffer分配：

   // 在camxsettings.xml中开启内存调试 <Memory> <EnableMemoryLog value="TRUE"/> <MemoryLogLevel value="3"/> </Memory>

2. 使用Valgrind或AddressSanitizer： 对于模拟器或带GDB支持的设备：

   # 编译时开启ASan export SANITIZE_TARGET=address make -j$(nproc) camera.qcom # 运行相机并检查报告 adb shell setprop wrap.com.android.camera2 '"LIBC_DEBUG_MALLOC_OPTIONS=backtrace"'

3. 检查Node资源释放： 每个Node应该在Node::Destroy()中释放所有资源：

   VOID MyCustomNode::Destroy() { if (NULL != m_pInternalBuffer) { CAMX_FREE(m_pInternalBuffer); m_pInternalBuffer = NULL; } // 调用父类Destroy Node::Destroy(); }

4.4 自定义Node开发

有时需要添加自定义处理节点。创建自定义Node的基本步骤：

1. 定义Node类：

   // vendor/qcom/proprietary/chi-cdk/vendor/node/mycustomnode/MyCustomNode.h class MyCustomNode : public ChiNode { public: static ChiNode* Create(); virtual VOID Destroy() override; virtual CDKResult ProcessRequest(CHINODEPROCESSREQUESTINFO* pInfo) override; virtual CDKResult SetNodeInterface(ChiNodeInterface* pNodeInterface) override; private: MyCustomNode(); virtual ~MyCustomNode(); ChiNodeInterface* m_pNodeInterface; VOID* m_pInternalData; };

2. 实现核心方法：

   // MyCustomNode.cpp CDKResult MyCustomNode::ProcessRequest(CHINODEPROCESSREQUESTINFO* pInfo) { CAMX_LOG_VERBOSE(CamxLogGroupCore, "MyCustomNode处理请求 %llu", pInfo->frameNum); // 处理输入Buffer CHINODEBUFFERHANDLE hInput = pInfo->phInputBuffer[0]; CHINODEBUFFERHANDLE hOutput = pInfo->phOutputBuffer[0]; // 执行自定义算法 ProcessImage(hInput, hOutput, pInfo->pDependency); return CDKResultSuccess; }

3. 注册Node到CHI：

   // 在chioverride模块中注册 static ChiNodeInterface g_MyCustomNodeInterface = { .pGetCaps = MyCustomNode::GetCaps, .pCreate = MyCustomNode::Create, .pDestroy = MyCustomNode::Destroy, .pQueryVendorTag = MyCustomNode::QueryVendorTag }; VOID RegisterMyCustomNode() { ExtensionModule::GetInstance()->RegisterNode("MyCustomNode", &g_MyCustomNodeInterface); }

4. 在Pipeline XML中使用：

   <Node name="MyCustomNode" type="Custom" instance="MyCustom0"> <Property name="AlgorithmParam" value="123"/> </Node>

5. 高级调试技巧与工具

掌握了基础调试后，这些高级技巧能帮你更深入地理解CamX。

5.1 使用GDB调试Camera HAL

在开发板上使用GDB调试：

# 在设备上启动gdbserver adb shell setprop wrap.com.android.camera2 '"gdbserver :5039"' # 在主机上连接 adb forward tcp:5039 tcp:5039 gdb-multiarch out/target/product/xxx/symbols/vendor/lib64/hw/camera.qcom.so # 在GDB中 (gdb) target remote :5039 (gdb) break CamX::process_capture_request (gdb) continue

5.2 性能分析工具

高通提供了一些性能分析工具：

1. CamX Profiler：

   # 启用性能分析 adb shell setprop persist.camera.global.debug 0x3 adb shell setprop persist.camera.perf.debug 1 # 运行相机测试 adb shell am start -n com.android.camera2/.CameraActivity # 收集性能数据 adb pull /data/misc/camera/camx_perf.log

2. 使用Perfetto进行系统级跟踪：

   # 录制trace adb shell perfetto --txt -c - --out /data/misc/perfetto-traces/trace.perfetto-trace <<EOF buffers: { size_kb: 63488 } data_sources: { config { name: "linux.ftrace" ftrace_config { ftrace_events: "camera/*" ftrace_events: "gpu/*" buffer_size_kb: 2048 } } } EOF # 拉取trace文件 adb pull /data/misc/perfetto-traces/trace.perfetto-trace

5.3 自定义日志系统

CamX的日志系统可以扩展，添加自定义日志组：

// 在camxsettings.xml中添加 <LogGroups> <Group name="MY_CUSTOM" level="4"/> </LogGroups> // 在代码中使用 CAMX_LOG_INFO(CamxLogGroupCustom, "自定义日志: 参数=%d, 状态=%s", param, status);

要启用这个日志组，需要在运行时设置属性：

adb shell setprop persist.vendor.camera.log.mask 0x1000 # MY_CUSTOM组的掩码

5.4 实时监控Camera状态

创建一个简单的监控脚本：

#!/usr/bin/env python3 """ 实时监控Camera状态：帧率、延迟、内存使用 """ import subprocess import time import json from collections import deque class CameraMonitor: def __init__(self): self.frame_times = deque(maxlen=60) # 保存最近60帧时间 self.last_frame_time = None def get_camera_stats(self): """获取Camera统计信息""" stats = {} # 从dumpsys获取信息 result = subprocess.run( ["adb", "shell", "dumpsys", "media.camera"], capture_output=True, text=True ) # 解析帧率 for line in result.stdout.split('\n'): if "fps" in line.lower(): parts = line.split(':') if len(parts) > 1: stats['fps'] = float(parts[1].strip()) elif "active" in line.lower() and "camera" in line.lower(): stats['active_cameras'] = line.strip() # 从proc文件系统获取更多信息 try: mem_info = subprocess.run( ["adb", "shell", "cat", "/proc/meminfo"], capture_output=True, text=True ) for line in mem_info.stdout.split('\n'): if "MemFree" in line: stats['free_memory'] = line.split()[1] + " kB" except: pass return stats def monitor_loop(self, interval=1.0): """监控循环""" print("开始监控Camera状态...") print("按Ctrl+C停止") print("-" * 60) try: while True: stats = self.get_camera_stats() current_time = time.time() # 计算实时帧率 if self.last_frame_time: frame_interval = current_time - self.last_frame_time self.frame_times.append(frame_interval) if len(self.frame_times) > 1: avg_interval = sum(self.frame_times) / len(self.frame_times) real_fps = 1.0 / avg_interval if avg_interval > 0 else 0 stats['real_fps'] = f"{real_fps:.2f}" self.last_frame_time = current_time # 显示统计信息 print(f"\n[{time.strftime('%H:%M:%S')}] Camera状态:") for key, value in stats.items(): print(f" {key}: {value}") time.sleep(interval) except KeyboardInterrupt: print("\n监控停止") if __name__ == "__main__": monitor = CameraMonitor() monitor.monitor_loop()

这个脚本可以实时显示相机帧率、内存使用情况，帮助你快速发现性能瓶颈。

调试CamX确实需要耐心，特别是第一次跟踪请求调用链时，可能会被大量的日志淹没。我的经验是：先理解整体流程，再深入细节。不要试图一次性理解所有代码，而是从一个简单的预览请求开始，逐步添加日志点，观察数据如何在不同组件间流动。

记得每次修改后都要重新编译刷机，这个过程可能很耗时。建议在虚拟机或开发板上先验证基础功能，再上真机调试。另外，高通的文档和代码注释其实很有用，只是需要花时间挖掘。多看看camx/src/core下的头文件，里面有很多关键数据结构的定义和说明。

最后，保持好奇心也很重要。CamX架构虽然复杂，但设计得很精妙。理解它的设计思想，不仅能帮你解决眼前的问题，还能提升你对整个相机系统的认知。下次遇到Camera相关的问题时，你就能更快地定位到根本原因，而不是盲目地试错。