【Android FrameWork】第三十三天：Camera视频流写入SurfaceView的机制

Camera视频流写入SurfaceView的机制

应用层通过SurfaceView实现Camera预览时，仅需几行API调用即可看到视频流，但底层是Android系统多模块协同的复杂过程——从Camera硬件采集帧数据，到缓冲区流转，再到屏幕合成渲染，核心依赖BufferQueue的“生产者-消费者”模型。

本文将从系统源码视角，完整拆解“视频流写入Surface并绘制到界面”的全链路，并附上AOSP（Android开源项目）中的核心系统代码，揭示底层运行逻辑。

核心系统组件

在分析流程前，需先明确支撑视频流流转的核心系统组件，它们构成了“Camera→Surface→屏幕”的基础骨架：

核心设计思想：
Android通过BufferQueue解耦“数据生产（Camera采集）”与“数据消费（屏幕渲染）”：Camera HAL作为生产者将视频帧写入缓冲区，SurfaceFlinger作为消费者读取缓冲区并合成，二者通过ANativeWindow（应用Surface的系统层抽象）关联，全程基于硬件缓冲区复用，最大化渲染性能。

系统层视频流写入Surface的完整链路

整个过程可拆解为6个核心阶段，从应用层Surface创建到最终屏幕显示，每个阶段对应系统层的关键调用与数据流转：

阶段1：应用层Surface映射为系统层ANativeWindow

应用层SurfaceView创建后，通过SurfaceHolder.getSurface()获取的Surface是Java层抽象，系统层需将其转换为ANativeWindow（原生窗口），才能让Camera HAL操作缓冲区。

系统代码片段1：ANativeWindow_fromSurface实现（Surface→ANativeWindow）

// 路径：frameworks/native/libs/gui/NativeWindow.cpp#include<gui/Surface.h>#include<jni.h>#include<android/log.h>#defineALOGE(...)__android_log_print(ANDROID_LOG_ERROR,"NativeWindow",__VA_ARGS__)ANativeWindow*ANativeWindow_fromSurface(JNIEnv*env,jobject surfaceObj){if(surfaceObj==nullptr){ALOGE("ANativeWindow_fromSurface: surfaceObj is null");returnnullptr;}// 1. 通过JNI获取Java层Surface对应的原生Surface对象// android_view_Surface_getNativeSurface是系统JNI方法，返回Surface*sp<Surface>surface=android::android_view_Surface_getNativeSurface(env,surfaceObj);if(surface==nullptr){ALOGE("ANativeWindow_fromSurface: native Surface is null");returnnullptr;}// 2. Surface继承自ANativeWindow，直接强转ANativeWindow*window=static_cast<ANativeWindow*>(surface.get());// 3. 增加引用计数，防止Surface被提前释放ANativeWindow_acquire(window);returnwindow;}

核心逻辑：
Java层Surface的原生实现是frameworks/native/libs/gui/Surface.cpp，其内部持有BufferQueue的生产者接口（IGraphicBufferProducer）。ANativeWindow本质是对该接口的封装，为后续Camera HAL写入缓冲区提供入口。

阶段2：Camera Service绑定ANativeWindow到Camera HAL

应用层调用Camera.setPreviewDisplay(Surface)（或C++层mCamera->setPreviewDisplay(ANativeWindow)）后，最终通过Binder通信触发CameraService将ANativeWindow绑定到Camera HAL，让HAL知道“往哪个缓冲区写数据”。

系统代码片段2：CameraService绑定预览窗口

// 路径：frameworks/native/services/camera/libcameraservice/CameraService.cpp#include<camera/CameraService.h>#include<gui/ANativeWindow.h>namespaceandroid{status_t CameraService::Client::setPreviewWindow(constsp<ANativeWindow>&window){ALOGD("CameraService::Client::setPreviewWindow: window=%p",window.get());Mutex::Autolock_l(mLock);// 1. 校验Camera状态：必须处于预览就绪状态if(mState!=CAMERA_STATE_PREVIEW){ALOGE("setPreviewWindow: invalid state %d (expected PREVIEW)",mState);returnINVALID_OPERATION;}// 2. 释放旧窗口资源if(mPreviewWindow!=nullptr){mPreviewWindow->release();mPreviewWindow=nullptr;}// 3. 绑定新ANativeWindow，并传递给Camera HALif(window!=nullptr){mPreviewWindow=window;mPreviewWindow->acquire();// 核心：将ANativeWindow传递给Camera HAL，HAL成为BufferQueue生产者status_t res=mHardware->setPreviewWindow(mPreviewWindow);if(res!=NO_ERROR){ALOGE("setPreviewWindow: HAL set failed, res=%d",res);mPreviewWindow->release();mPreviewWindow=nullptr;returnres;}}returnNO_ERROR;}}// namespace android

核心逻辑：
CameraService作为系统服务，承接应用层的预览窗口绑定请求，将ANativeWindow（即Surface的系统层实例）转发给Camera HAL。此时，Camera HAL与BufferQueue的生产者接口完成绑定，具备了写入缓冲区的能力。

阶段3：Camera HAL采集视频帧（从硬件驱动到内存）

应用层调用Camera.startPreview()后，最终触发Camera HAL启动预览线程，从Camera硬件驱动读取原始YUV帧数据（如YUV420SP），为写入缓冲区做准备。

系统代码片段3：Camera HAL预览线程与帧采集

// 路径：hardware/libhardware/modules/camera/3_0/Camera.cpp（Camera HAL 3.0示例）#include<hardware/camera3.h>#include<utils/Thread.h>namespaceandroid{classCamera:publicRefBase{public:status_tstartPreview();voidstopPreview();private:// 预览线程：循环从Camera驱动读取帧数据classPreviewThread:publicThread{public:PreviewThread(sp<Camera>camera):mCamera(camera){}virtualboolthreadLoop()override;private:wp<Camera>mCamera;};sp<camera3_device_t>mDevice;// Camera驱动设备指针sp<PreviewThread>mPreviewThread;boolmIsPreviewing;sp<ANativeWindow>mPreviewWindow;// 绑定的预览窗口};// 启动预览：配置驱动并启动预览线程status_tCamera::startPreview(){Mutex::Autolock_l(mLock);if(mIsPreviewing)returnNO_ERROR;// 1. 配置Camera驱动的预览参数（分辨率、格式、帧率）camera_stream_configuration_t config={.stream_count=1,.streams=&mPreviewStream,// 预览流：1920x1080 YUV420SP.operation_mode=CAMERA3_TEMPLATE_PREVIEW};intres=mDevice->ops->configure_streams(mDevice,&config);if(res!=OK){ALOGE("startPreview: configure streams failed, res=%d",res);returnres;}// 2. 启动预览线程mPreviewThread=newPreviewThread(this);if(mPreviewThread->run("CameraPreviewThread",PRIORITY_URGENT_DISPLAY)!=OK){ALOGE("startPreview: start thread failed");mPreviewThread.clear();returnUNKNOWN_ERROR;}mIsPreviewing=true;returnNO_ERROR;}// 预览线程主逻辑：循环读取驱动帧数据并写入缓冲区boolCamera::PreviewThread::threadLoop(){sp<Camera>camera=mCamera.promote();if(camera==nullptr||!camera->mIsPreviewing)returnfalse;camera3_capture_result_t*result;// 1. 从Camera驱动阻塞等待一帧数据intres=camera->mDevice->ops->wait_for_frame(camera->mDevice,&result);if(res!=OK){ALOGE("PreviewThread: wait_for_frame failed, res=%d",res);returntrue;// 继续循环，不退出线程}// 2. 将驱动返回的YUV帧写入ANativeWindow（核心：写入Surface缓冲区）camera->writeFrameToWindow(result->output_buffers[0]);// 3. 释放驱动帧资源camera->mDevice->ops->return_frame(camera->mDevice,result);returntrue;}}// namespace android

核心逻辑：
Camera HAL通过独立线程（PreviewThread）与硬件驱动交互，以阻塞方式读取原始YUV帧数据。读取完成后，调用writeFrameToWindow将数据写入ANativeWindow关联的缓冲区——这是“视频流写入Surface”的核心操作。

阶段4：Camera HAL写入BufferQueue（生产者核心操作）

Camera HAL通过ANativeWindow的核心接口（dequeueBuffer/lockBuffer/queueBuffer）完成缓冲区的申请、写入、提交，最终将帧数据放入BufferQueue的“已排队”队列，等待消费者读取。

系统代码片段4：ANativeWindow缓冲区写入实现

// 路径：frameworks/native/libs/gui/Surface.cpp（ANativeWindow的核心实现）#include<gui/Surface.h>#include<gui/BufferQueue.h>namespaceandroid{// 申请空闲缓冲区（从BufferQueue获取）status_tSurface::dequeueBuffer(ANativeWindowBuffer**buffer,int*fenceFd){Mutex::Autolock_l(mLock);sp<IGraphicBufferProducer>producer=mGraphicBufferProducer;if(producer==nullptr)returnNO_INIT;// 1. 调用BufferQueueProducer的dequeueBuffer，获取空闲缓冲区intslot;sp<Fence>fence;status_t res=producer->dequeueBuffer(&slot,&fence,mWidth,mHeight,mFormat,0);if(res!=OK){ALOGE("dequeueBuffer failed, res=%d",res);returnres;}// 2. 将缓冲区转换为ANativeWindowBuffer返回给HAL*buffer=mSlots[slot].mBuffer.get();*fenceFd=fence->dup();mLastDequeuedSlot=slot;returnOK;}// 提交写入完成的缓冲区（放入BufferQueue已排队队列）status_tSurface::queueBuffer(ANativeWindowBuffer*buffer,intfenceFd){Mutex::Autolock_l(mLock);sp<IGraphicBufferProducer>producer=mGraphicBufferProducer;if(producer==nullptr)returnNO_INIT;// 1. 找到缓冲区对应的slotintslot=getSlotFromBufferLocked(buffer);if(slot<0)returnBAD_VALUE;// 2. 调用BufferQueueProducer的queueBuffer，标记缓冲区为“已排队”sp<Fence>fence=newFence(fenceFd);IGraphicBufferProducer::QueueBufferInputinput(0,mTimestamp,NATIVE_WINDOW_SCALING_MODE_FREEZE,Rect(mWidth,mHeight),NATIVE_WINDOW_TRANSFORM_IDENTITY,false,fence);IGraphicBufferProducer::QueueBufferOutput output;status_t res=producer->queueBuffer(slot,input,&output);// 3. 更新缓冲区状态if(res==OK){mSlots[slot].mBufferState=BufferSlot::QUEUED;}returnres;}}// namespace android// Camera HAL调用的写入逻辑（伪代码，简化核心流程）status_tCamera::writeFrameToWindow(constcamera3_stream_buffer_t&buffer){ANativeWindowBuffer*nativeBuffer=nullptr;intfenceFd=-1;// 步骤1：申请空闲缓冲区status_t res=mPreviewWindow->dequeueBuffer(mPreviewWindow,&nativeBuffer,&fenceFd);if(res!=OK)returnres;// 步骤2：锁定缓冲区，获取可写入的内存地址void*dstPtr=nullptr;res=mPreviewWindow->lockBuffer(mPreviewWindow,nativeBuffer,&dstPtr);if(res!=OK){mPreviewWindow->cancelBuffer(mPreviewWindow,nativeBuffer,fenceFd);returnres;}// 步骤3：将YUV帧数据拷贝到缓冲区（硬件DMA拷贝，无CPU参与）memcpy(dstPtr,buffer.buffer,buffer.size);// 步骤4：提交缓冲区到BufferQueueres=mPreviewWindow->queueBuffer(mPreviewWindow,nativeBuffer,fenceFd);if(res!=OK){ALOGE("queueBuffer failed, res=%d",res);returnres;}returnOK;}

核心逻辑：

1. dequeueBuffer：从BufferQueue申请一个空闲缓冲区（状态：FREE→DEQUEUED）；
2. lockBuffer：锁定缓冲区，获取内存地址，确保CPU/GPU可安全写入；
3. 数据拷贝：将Camera驱动的YUV数据写入缓冲区（高端设备通过DMA直接拷贝，无CPU开销）；
4. queueBuffer：提交缓冲区，状态变为QUEUED，BufferQueue通知消费者（SurfaceFlinger）有新帧可读取。

阶段5：SurfaceFlinger读取缓冲区并合成

SurfaceFlinger作为系统合成服务，定期扫描所有活跃的BufferQueue，读取“已排队”的视频帧缓冲区，将其转换为GPU纹理后，与其他UI层（如按钮、标题栏）合成。

系统代码片段5：SurfaceFlinger读取并合成缓冲区

// 路径：frameworks/native/services/surfaceflinger/Layer.cpp（Surface对应Layer）#include<surfaceflinger/Layer.h>#include<gui/BufferQueueConsumer.h>namespaceandroid{// 从BufferQueue读取新帧并更新纹理status_tLayer::updateTexImage(){Mutex::Autolock_l(mLock);sp<BufferQueueConsumer>consumer=mConsumer;if(consumer==nullptr)returnNO_INIT;// 1. 从BufferQueueConsumer获取“已排队”的缓冲区（状态：QUEUED→ACQUIRED）BufferQueue::BufferItem item;status_t res=consumer->acquireBuffer(&item,0);if(res!=OK){if(res!=NO_BUFFER_AVAILABLE){ALOGE("updateTexImage: acquireBuffer failed, res=%d",res);}returnres;}// 2. 将缓冲区数据上传到GPU纹理（为合成做准备）res=mTexture->upload(item.mGraphicBuffer);if(res!=OK){consumer->releaseBuffer(item.mSlot,item.mFrameNumber);returnres;}// 3. 释放旧缓冲区（状态：ACQUIRED→FREE，供Camera HAL复用）if(mLastAcquiredSlot!=BufferQueue::INVALID_BUFFER_SLOT){consumer->releaseBuffer(mLastAcquiredSlot,mLastAcquiredFrame);}mLastAcquiredSlot=item.mSlot;returnOK;}// 路径：frameworks/native/services/surfaceflinger/SurfaceFlinger.cppvoidSurfaceFlinger::compositeDisplay(constsp<DisplayDevice>&display){// 1. 初始化GPU渲染上下文GLRenderer&renderer=display->getRenderer();renderer.beginFrame(display->getDisplayRect());// 2. 按Z轴顺序遍历所有Layer（Camera预览Layer通常在底层）constLayerVector&layers=display->getVisibleLayersSortedByZ();for(constauto&layer:layers){if(!layer->isVisible())continue;// 3. 绘制Layer到合成缓冲区（Camera视频帧纹理）renderer.drawLayer(layer,layer->getTexture(),layer->getMatrix());}// 4. 完成合成，提交到屏幕帧缓冲区renderer.endFrame();}}// namespace android

核心逻辑：

• 每个应用Surface在SurfaceFlinger中对应一个Layer，Layer持有BufferQueueConsumer接口，负责读取缓冲区；
• updateTexImage：从BufferQueue获取新帧，转换为GPU纹理，同时释放旧缓冲区供生产者复用；
• compositeDisplay：将所有Layer的纹理按Z轴顺序合成（Camera预览Layer通常在最底层），生成最终的屏幕帧。

阶段6：硬件合成与屏幕显示

SurfaceFlinger完成合成后，通过HWComposer（硬件合成器）将最终帧数据写入屏幕的帧缓冲区（FrameBuffer），屏幕驱动以60Hz/90Hz的频率读取帧缓冲区数据，最终显示到物理屏幕上。

系统代码片段6：HWComposer硬件合成提交

// 路径：frameworks/native/services/surfaceflinger/HWComposer.cpp#include<surfaceflinger/HWComposer.h>namespaceandroid{status_tHWComposer::commit(intdisplayId){auto&display=mDisplays[displayId];if(!display.isValid())returnBAD_VALUE;// 1. 将合成后的帧数据提交到硬件合成器intres=display.device->commit(display.device);if(res!=0){ALOGE("HWComposer commit failed, res=%d",res);returnres;}// 2. 等待VSync信号（屏幕垂直同步），确保帧显示不撕裂display.vsync.wait();returnOK;}}// namespace android

核心逻辑：
HWComposer通过硬件加速完成最终的帧合成，避免CPU/GPU的额外开销；同时等待VSync信号，确保每帧数据在屏幕刷新的间隙写入，防止画面撕裂。

完整链路总结与常见问题根因

1 全链路梳理

应用层：SurfaceView创建Surface → JNI转换为ANativeWindow → 绑定到Camera ↓ 系统层：CameraService将ANativeWindow转发给Camera HAL ↓ HAL层：启动预览线程 → 从驱动读取YUV帧 → dequeueBuffer申请缓冲区 → 写入数据 → queueBuffer提交到BufferQueue ↓ SurfaceFlinger：acquireBuffer读取缓冲区 → 转换为GPU纹理 → 与UI层合成 → HWComposer提交到屏幕帧缓冲区 ↓ 硬件层：屏幕驱动读取帧缓冲区 → 显示到物理屏幕

2 常见问题的系统层根因

总结

Android系统将Camera视频流写入Surface并绘制到界面的核心，是基于BufferQueue的“生产者-消费者”模型：Camera HAL作为生产者完成帧采集与缓冲区写入，SurfaceFlinger作为消费者完成缓冲区读取与合成，ANativeWindow则是连接应用层与系统层的桥梁。

理解这一底层机制，不仅能解释应用层预览的各种异常现象，更能指导高性能预览的优化方向——比如通过减少缓冲区拷贝、匹配Camera预览尺寸与Surface尺寸、启用HWComposer硬件合成等方式，提升预览流畅度与画质。