Android Camera HAL3中预览preview模式下的控制流

2023-10-24 23:33
文章标签 android 模式 预览 preview camera 控制流 hal3

本文主要是介绍Android Camera HAL3中预览preview模式下的控制流，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Camera3研读前沿：

    当初在研读Camera1.0相关的内容时，主要围绕着CameraClient、CameraHardwareInterface等方面进行工作的开展，无论是数据流还是控制流看起来都很简单、明了，一系列的流程化操作使得整个框架学起来特别的容易。因为没有Camera2.0相关的基础，所以这次直接看3.0相关的源码时，显得十分的吃紧，再加上底层高通HAL3.0实现的过程也是相当的复杂，都给整个研读过程带来了很多的困难。可以说，自身目前对Camera3.0框架的熟悉度也大概只有70%左右，希望通过总结来进一步梳理他的工作原理与整个框架，并进一步熟悉与加深理解。


1.Camera3下的整体架构图。

整个CameraService建立起一个可用操作底层Camera device大致需要经过Camera2Client、Camera3Device以及HAL层的camera3_device_t三个部分。


从上图中可以发现Camera3架构看上去明显比camera1来的复杂，但他更加的模块化。对比起Android4.2.2 Camer系统架构图（HAL和回调处理）一文中描述的单顺序执行流程，Camera3将更多的工作集中在了Framework去完成，将更多的控制权掌握在自己的手里，从而与HAL的交互的数据信息更少，也进一步减轻了一些在旧版本中HAL层所需要做的事情。


2. Camera2Client的建立与初始化过程


在建立好Camera2Client后会进行initialize操作，完成各个处理模块的创建：

[cpp] view plain copy
  1.   ....  
  2. StreamingProcessor = new StreamingProcessor(this);//preview和recorder  
  3.    threadName = String8::format("C2-%d-StreamProc",  
  4.            mCameraId);  
  5.    mStreamingProcessor->run(threadName.string());//预览与录像  
  6.   
  7.    mFrameProcessor = new FrameProcessor(mDevice, this);// 3A  
  8.    threadName = String8::format("C2-%d-FrameProc",  
  9.            mCameraId);  
  10.    mFrameProcessor->run(threadName.string()); //3A  
  11.   
  12.    mCaptureSequencer = new CaptureSequencer(this);  
  13.    threadName = String8::format("C2-%d-CaptureSeq",  
  14.            mCameraId);  
  15.    mCaptureSequencer->run(threadName.string());//录像，拍照  
  16.   
  17.    mJpegProcessor = new JpegProcessor(this, mCaptureSequencer);  
  18.    threadName = String8::format("C2-%d-JpegProc",  
  19.            mCameraId);  
  20.    mJpegProcessor->run(threadName.string());  
  21. ...  
  22. mCallbackProcessor = new CallbackProcessor(this);//回调处理  
  23.    threadName = String8::format("C2-%d-CallbkProc",  
  24.            mCameraId);  
  25.    mCallbackProcessor->run(threadName.string());  
依次分别创建了：

StreamingProcessor并启动一个他所属的thread，该模块主要负责处理previews与record两种视频流的处理，用于从hal层获取原始的视频数据

FrameProcessor并启动一个thread，该模块专门用于处理回调回来的每一帧的3A等信息，即每一帧视频除去原始视频数据外，还应该有其他附加的数据信息，如3A值。

CaptureSequencer并启动一个thread，该模块需要和其他模块配合使用，主要用于向APP层告知capture到的picture。
JpegProcessor并启动一个thread，该模块和streamprocessor类似，他启动一个拍照流，一般用于从HAL层获取jpeg编码后的图像照片数据。

此外ZslProcessor模块称之为0秒快拍，其本质是直接从原始的Preview流中获取预存着的最近的几帧，直接编码后返回给APP，而不需要再经过take picture去请求获取jpeg数据。0秒快拍技术得意于当下处理器CSI2 MIPI性能的提升以及Sensor支持全像素高帧率的实时输出。一般手机拍照在按下快门后都会有一定的延时，是因为需要切换底层Camera以及ISP等的工作模式，并重新设置参数以及重新对焦等等，都需要花一定时间后才抓取一帧用于编码为jpeg图像。

以上5个模块整合在一起基本上实现了Camera应用开发所需的基本业务功能。


3. 预览Preview下的控制流

研读Camera具体的业务处理功能，一般从视频实时预览Preview入手。一般熟悉Camera架构的人，可以从一个app端的一个api一直连续打通到底层hal的一个控制命令。大致可以如下图所示：


对于preview部分到CameraService的控制流可以参考博文Android4.2.2的preview的数据流和控制流以及最终的预览显示，本文将直接从Camera2Client::startPreview() 作为入口来分析整个Framework层中Preview相关的数据流。

[cpp] view plain copy
  1. status_t Camera2Client::startPreview() {  
  2.     ATRACE_CALL();  
  3.     ALOGV("%s: E", __FUNCTION__);  
  4.     Mutex::Autolock icl(mBinderSerializationLock);  
  5.     status_t res;  
  6.     if ( (res = checkPid(__FUNCTION__) ) != OK) return res;  
  7.     SharedParameters::Lock l(mParameters);  
  8.     return startPreviewL(l.mParameters, false);  
  9. }  
startPreview通过startPreviewL提取参数后真正的开始执行Preview相关的控制流。该函数看上去内容虽然较多，但基本采用了同一种处理方式：
[cpp] view plain copy
  1. status_t Camera2Client::startPreviewL(Parameters ¶ms, bool restart) {//restart == false  
  2.     ATRACE_CALL();  
  3.     status_t res;  
  4. ......  
  5.    int lastPreviewStreamId = mStreamingProcessor->getPreviewStreamId();//获取上一层Preview stream id  
  6.   
  7.    res = mStreamingProcessor->updatePreviewStream(params);//创建camera3device stream， Camera3OutputStream  
  8. .....  
  9.    int lastJpegStreamId = mJpegProcessor->getStreamId();  
  10.    res = updateProcessorStream(mJpegProcessor, params);//预览启动时就建立一个jpeg的outstream  
  11. .....  
  12.         res = mCallbackProcessor->updateStream(params);//回调处理建立一个Camera3outputstream  
  13.         if (res != OK) {  
  14.             ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",  
  15.                     __FUNCTION__, mCameraId, strerror(-res), res);  
  16.             return res;  
  17.         }  
  18.         outputStreams.push(getCallbackStreamId());  
  19. ......  
  20.     outputStreams.push(getPreviewStreamId());//预览stream  
  21. ......  
  22.    if (!params.recordingHint) {  
  23.         if (!restart) {  
  24.             res = mStreamingProcessor->updatePreviewRequest(params);//request处理,更新了mPreviewrequest  
  25.             if (res != OK) {  
  26.                 ALOGE("%s: Camera %d: Can't set up preview request: "  
  27.                         "%s (%d)", __FUNCTION__, mCameraId,  
  28.                         strerror(-res), res);  
  29.                 return res;  
  30.             }  
  31.         }  
  32.         res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW,  
  33.                 outputStreams);//启动stream，传入outputStreams即stream 的id  
  34.     } else {  
  35.         if (!restart) {  
  36.             res = mStreamingProcessor->updateRecordingRequest(params);  
  37.             if (res != OK) {  
  38.                 ALOGE("%s: Camera %d: Can't set up preview request with "  
  39.                         "record hint: %s (%d)", __FUNCTION__, mCameraId,  
  40.                         strerror(-res), res);  
  41.                 return res;  
  42.             }  
  43.         }  
  44.         res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,  
  45.                 outputStreams);  
  46.     }  
  47. ......  
  48. }  


(1). mStreamingProcessor->updatePreviewStream()

由预览与录像处理模块更新一个预览流，其实现过程如下：

[cpp] view plain copy
  1. status_t StreamingProcessor::updatePreviewStream(const Parameters ¶ms) {  
  2.     ATRACE_CALL();  
  3.     Mutex::Autolock m(mMutex);  
  4.   
  5.     status_t res;  
  6.     sp<CameraDeviceBase> device = mDevice.promote();//Camera3Device  
  7.     if (device == 0) {  
  8.         ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId);  
  9.         return INVALID_OPERATION;  
  10.     }  
  11.   
  12.     if (mPreviewStreamId != NO_STREAM) {  
  13.         // Check if stream parameters have to change  
  14.         uint32_t currentWidth, currentHeight;  
  15.         res = device->getStreamInfo(mPreviewStreamId,  
  16.                 ¤tWidth, ¤tHeight, 0);  
  17.         if (res != OK) {  
  18.             ALOGE("%s: Camera %d: Error querying preview stream info: "  
  19.                     "%s (%d)", __FUNCTION__, mId, strerror(-res), res);  
  20.             return res;  
  21.         }  
  22.         if (currentWidth != (uint32_t)params.previewWidth ||  
  23.                 currentHeight != (uint32_t)params.previewHeight) {  
  24.             ALOGV("%s: Camera %d: Preview size switch: %d x %d -> %d x %d",  
  25.                     __FUNCTION__, mId, currentWidth, currentHeight,  
  26.                     params.previewWidth, params.previewHeight);  
  27.             res = device->waitUntilDrained();  
  28.             if (res != OK) {  
  29.                 ALOGE("%s: Camera %d: Error waiting for preview to drain: "  
  30.                         "%s (%d)", __FUNCTION__, mId, strerror(-res), res);  
  31.                 return res;  
  32.             }  
  33.             res = device->deleteStream(mPreviewStreamId);  
  34.             if (res != OK) {  
  35.                 ALOGE("%s: Camera %d: Unable to delete old output stream "  
  36.                         "for preview: %s (%d)", __FUNCTION__, mId,  
  37.                         strerror(-res), res);  
  38.                 return res;  
  39.             }  
  40.             mPreviewStreamId = NO_STREAM;  
  41.         }  
  42.     }  
  43.   
  44.     if (mPreviewStreamId == NO_STREAM) {//首次create stream  
  45.         res = device->createStream(mPreviewWindow,  
  46.                 params.previewWidth, params.previewHeight,  
  47.                 CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, &mPreviewStreamId);//创建一个Camera3OutputStream  
  48.         if (res != OK) {  
  49.             ALOGE("%s: Camera %d: Unable to create preview stream: %s (%d)",  
  50.                     __FUNCTION__, mId, strerror(-res), res);  
  51.             return res;  
  52.         }  
  53.     }  
  54.   
  55.     res = device->setStreamTransform(mPreviewStreamId,  
  56.             params.previewTransform);  
  57.     if (res != OK) {  
  58.         ALOGE("%s: Camera %d: Unable to set preview stream transform: "  
  59.                 "%s (%d)", __FUNCTION__, mId, strerror(-res), res);  
  60.         return res;  
  61.     }  
  62.   
  63.     return OK;  
  64. }  
该函数首先是查看当前 StreamingProcessor模块下是否存在Stream，没有的话，则交由Camera3Device创建一个stream。显然，一个StreamingProcessor只能拥有一个PreviewStream，而一个Camera3Device显然控制着所有的Stream。

注意：在Camera2Client中，Stream大行其道，5大模块的数据交互均以stream作为基础。

下面我们来重点关注Camera3Device的接口createStream，他是5个模块创建stream的基础：

[cpp] view plain copy
  1. status_t Camera3Device::createStream(sp<ANativeWindow> consumer,  
  2.         uint32_t width, uint32_t height, int format, int *id) {  
  3.     ATRACE_CALL();  
  4.     Mutex::Autolock il(mInterfaceLock);  
  5.     Mutex::Autolock l(mLock);  
  6.     ALOGV("Camera %d: Creating new stream %d: %d x %d, format %d",  
  7.             mId, mNextStreamId, width, height, format);  
  8.   
  9.     status_t res;  
  10.     bool wasActive = false;  
  11.   
  12.     switch (mStatus) {  
  13.         case STATUS_ERROR:  
  14.             CLOGE("Device has encountered a serious error");  
  15.             return INVALID_OPERATION;  
  16.         case STATUS_UNINITIALIZED:  
  17.             CLOGE("Device not initialized");  
  18.             return INVALID_OPERATION;  
  19.         case STATUS_UNCONFIGURED:  
  20.         case STATUS_CONFIGURED:  
  21.             // OK  
  22.             break;  
  23.         case STATUS_ACTIVE:  
  24.             ALOGV("%s: Stopping activity to reconfigure streams", __FUNCTION__);  
  25.             res = internalPauseAndWaitLocked();  
  26.             if (res != OK) {  
  27.                 SET_ERR_L("Can't pause captures to reconfigure streams!");  
  28.                 return res;  
  29.             }  
  30.             wasActive = true;  
  31.             break;  
  32.         default:  
  33.             SET_ERR_L("Unexpected status: %d", mStatus);  
  34.             return INVALID_OPERATION;  
  35.     }  
  36.     assert(mStatus != STATUS_ACTIVE);  
  37.   
  38.     sp<Camera3OutputStream> newStream;  
  39.     if (format == HAL_PIXEL_FORMAT_BLOB) {//图片  
  40.         ssize_t jpegBufferSize = getJpegBufferSize(width, height);  
  41.         if (jpegBufferSize <= 0) {  
  42.             SET_ERR_L("Invalid jpeg buffer size %zd", jpegBufferSize);  
  43.             return BAD_VALUE;  
  44.         }  
  45.   
  46.         newStream = new Camera3OutputStream(mNextStreamId, consumer,  
  47.                 width, height, jpegBufferSize, format);//jpeg 缓存的大小  
  48.     } else {  
  49.         newStream = new Camera3OutputStream(mNextStreamId, consumer,  
  50.                 width, height, format);//Camera3OutputStream  
  51.     }  
  52.     newStream->setStatusTracker(mStatusTracker);  
  53.   
  54.     res = mOutputStreams.add(mNextStreamId, newStream);//一个streamid与Camera3OutputStream绑定  
  55.     if (res < 0) {  
  56.         SET_ERR_L("Can't add new stream to set: %s (%d)", strerror(-res), res);  
  57.         return res;  
  58.     }  
  59.   
  60.     *id = mNextStreamId++;//至少一个previewstream 一般还有CallbackStream  
  61.     mNeedConfig = true;  
  62.   
  63.     // Continue captures if active at start  
  64.     if (wasActive) {  
  65.         ALOGV("%s: Restarting activity to reconfigure streams", __FUNCTION__);  
  66.         res = configureStreamsLocked();  
  67.         if (res != OK) {  
  68.             CLOGE("Can't reconfigure device for new stream %d: %s (%d)",  
  69.                     mNextStreamId, strerror(-res), res);  
  70.             return res;  
  71.         }  
  72.         internalResumeLocked();  
  73.     }  
  74.     ALOGV("Camera %d: Created new stream", mId);  
  75.     return OK;  
  76. }  
该函数重点是关注一个new Camera3OutputStream，在Camera3Device主要存在 Camera3OutputStream和Camera3InputStream
两种stream，前者主要作为HAL的输出，是请求HAL填充数据的OutPutStream，后者是由Framework将Stream进行填充。无论是Preview、record还是capture均是从HAL层获取数据，故都会以OutPutStream的形式存在，是我们关注的重点，后面在描述Preview的数据流时还会进一步的阐述。

每当创建一个OutPutStream后，相关的stream信息被push维护在一个mOutputStreams的KeyedVector<int, sp<camera3::Camera3OutputStreamInterface> >表中，分别是该stream在Camera3Device中创建时的ID以及Camera3OutputStream的sp值。同时对mNextStreamId记录下一个Stream的ID号。

上述过程完成StreamingProcessor模块中一个PreviewStream的创建，其中Camera3OutputStream创建时的ID值被返回记录作为mPreviewStreamId的值，此外每个Stream都会有一个对应的ANativeWindow，这里称之为Consumer。


（2）mCallbackProcessor->updateStream(params)

对比StreamingProcessor模块创建previewstream的过程，很容易定位到Callback模块是需要建立一个callback流，同样需要创建一个Camera3OutputStream来接收HAL返回的每一帧帧数据，是否需要callback可以通过callbackenable来控制。一般但预览阶段可能不需要回调每一帧的数据到APP，但涉及到相应的其他业务如视频处理时，就需要进行callback的enable。

[cpp] view plain copy
  1. status_t CallbackProcessor::updateStream(const Parameters ¶ms) {  
  2.     ATRACE_CALL();  
  3.     status_t res;  
  4.   
  5.     Mutex::Autolock l(mInputMutex);  
  6.   
  7.     sp<CameraDeviceBase> device = mDevice.promote();  
  8.     if (device == 0) {  
  9.         ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId);  
  10.         return INVALID_OPERATION;  
  11.     }  
  12.   
  13.     // If possible, use the flexible YUV format  
  14.     int32_t callbackFormat = params.previewFormat;  
  15.     if (mCallbackToApp) {  
  16.         // TODO: etalvala: This should use the flexible YUV format as well, but  
  17.         // need to reconcile HAL2/HAL3 requirements.  
  18.         callbackFormat = HAL_PIXEL_FORMAT_YV12;  
  19.     } else if(params.fastInfo.useFlexibleYuv &&  
  20.             (params.previewFormat == HAL_PIXEL_FORMAT_YCrCb_420_SP ||  
  21.              params.previewFormat == HAL_PIXEL_FORMAT_YV12) ) {  
  22.         callbackFormat = HAL_PIXEL_FORMAT_YCbCr_420_888;  
  23.     }  
  24.   
  25.     if (!mCallbackToApp && mCallbackConsumer == 0) {  
  26.         // Create CPU buffer queue endpoint, since app hasn't given us one  
  27.         // Make it async to avoid disconnect deadlocks  
  28.         sp<IGraphicBufferProducer> producer;  
  29.         sp<IGraphicBufferConsumer> consumer;  
  30.         BufferQueue::createBufferQueue(&producer, &consumer);//BufferQueueProducer与BufferQueueConsumer  
  31.         mCallbackConsumer = new CpuConsumer(consumer, kCallbackHeapCount);  
  32.         mCallbackConsumer->setFrameAvailableListener(this);//当前CallbackProcessor继承于CpuConsumer::FrameAvailableListener  
  33.         mCallbackConsumer->setName(String8("Camera2Client::CallbackConsumer"));  
  34.         mCallbackWindow = new Surface(producer);//用于queue操作，这里直接进行本地的buffer操作  
  35.     }  
  36.   
  37.     if (mCallbackStreamId != NO_STREAM) {  
  38.         // Check if stream parameters have to change  
  39.         uint32_t currentWidth, currentHeight, currentFormat;  
  40.         res = device->getStreamInfo(mCallbackStreamId,  
  41.                 ¤tWidth, ¤tHeight, ¤tFormat);  
  42.         if (res != OK) {  
  43.             ALOGE("%s: Camera %d: Error querying callback output stream info: "  
  44.                     "%s (%d)", __FUNCTION__, mId,  
  45.                     strerror(-res), res);  
  46.             return res;  
  47.         }  
  48.         if (currentWidth != (uint32_t)params.previewWidth ||  
  49.                 currentHeight != (uint32_t)params.previewHeight ||  
  50.                 currentFormat != (uint32_t)callbackFormat) {  
  51.             // Since size should only change while preview is not running,  
  52.             // assuming that all existing use of old callback stream is  
  53.             // completed.  
  54.             ALOGV("%s: Camera %d: Deleting stream %d since the buffer "  
  55.                     "parameters changed", __FUNCTION__, mId, mCallbackStreamId);  
  56.             res = device->deleteStream(mCallbackStreamId);  
  57.             if (res != OK) {  
  58.                 ALOGE("%s: Camera %d: Unable to delete old output stream "  
  59.                         "for callbacks: %s (%d)", __FUNCTION__,  
  60.                         mId, strerror(-res), res);  
  61.                 return res;  
  62.             }  
  63.             mCallbackStreamId = NO_STREAM;  
  64.         }  
  65.     }  
  66.   
  67.     if (mCallbackStreamId == NO_STREAM) {  
  68.         ALOGV("Creating callback stream: %d x %d, format 0x%x, API format 0x%x",  
  69.                 params.previewWidth, params.previewHeight,  
  70.                 callbackFormat, params.previewFormat);  
  71.         res = device->createStream(mCallbackWindow,  
  72.                 params.previewWidth, params.previewHeight,  
  73.                 callbackFormat, &mCallbackStreamId);//Creating callback stream  
  74.         if (res != OK) {  
  75.             ALOGE("%s: Camera %d: Can't create output stream for callbacks: "  
  76.                     "%s (%d)", __FUNCTION__, mId,  
  77.                     strerror(-res), res);  
  78.             return res;  
  79.         }  
  80.     }  
  81.   
  82.     return OK;  
  83. }  
对比updatePreviewStream可以发现，该函数自助创建了一套surface/BufferQueue/CpuConsumer的机制，这套类似SurfaceFlinger的buffer管理机制可参看一文Android5.1中 surface生产者和消费者间的处理框架简述。此外通过createStream请求Camera3Device建立一个Stream，其中Stream的ID值保存在mCallBackStreamId当中，并将一个CallbackWindow和当前的Stream绑定。

通过这个对比，也需要重点关注到，对于每个Camera3OutPutStream来说，每一个stream都被一个Consumer，而在此处都是Surface(ANativeWindow)所拥有，这个Consumer和HAL相匹配来说是消费者，但对于真正的处理Buffer的Consumer来说如CPUConsumer，Surface却又是以一个Product的角色存在的。


（3）updateProcessorStream(mJpegProcessor, params)

[cpp] view plain copy
  1. status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,  
  2.                                               camera2::Parameters params) {  
  3.     // No default template arguments until C++11, so we need this overload  
  4.     return updateProcessorStream<ProcessorT, &ProcessorT::updateStream>(  
  5.             processor, params);  
  6. }  
  7. template <typename ProcessorT,  
  8.           status_t (ProcessorT::*updateStreamF)(const Parameters &)>  
  9. status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,  
  10.                                               Parameters params) {  
  11.     status_t res;  
  12.   
  13.     // Get raw pointer since sp<T> doesn't have operator->*  
  14.     ProcessorT *processorPtr = processor.get();  
  15.     res = (processorPtr->*updateStreamF)(params);  
  16. .......  
  17. }  
该模板函数处理过程最终通过非显示实例到显示实例调用JpegProcessor::updateStream，该函数处理的逻辑基本和Callback模块处理一致，创建的一个OutPutStream和CaptureWindow相互绑定，同时Stream的ID保存在mCaptureStreamId中。

此外需要说明一点：

在preview模式下，就去创建一个jpeg处理的stream，目的在于启动takepicture时，可以更快的进行capture操作。是通过牺牲内存空间来提升效率。


（4）整合startPreviewL中所有的stream 到Vector<int32_t> outputStreams

outputStreams.push(getPreviewStreamId());//预览stream

outputStreams.push(getCallbackStreamId())//Callback stream

目前一次Preview构建的stream数目至少为两个。


（5）mStreamingProcessor->updatePreviewRequest()

在创建好多路stream后，由StreamingProcessor模块来将所有的stream信息交由Camera3Device去打包成Request请求。

注意：

Camera HAL2/3的特点是：将所有stream的请求都转化为几个典型的Request请求，而这些Request需要由HAL去解析，进而处理所需的业务。这也是Camera3数据处理复杂化的原因所在。

[cpp] view plain copy
  1. status_t StreamingProcessor::updatePreviewRequest(const Parameters ¶ms) {  
  2.     ATRACE_CALL();  
  3.     status_t res;  
  4.     sp<CameraDeviceBase> device = mDevice.promote();  
  5.     if (device == 0) {  
  6.         ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId);  
  7.         return INVALID_OPERATION;  
  8.     }  
  9.   
  10.     Mutex::Autolock m(mMutex);  
  11.     if (mPreviewRequest.entryCount() == 0) {  
  12.         sp<Camera2Client> client = mClient.promote();  
  13.         if (client == 0) {  
  14.             ALOGE("%s: Camera %d: Client does not exist", __FUNCTION__, mId);  
  15.             return INVALID_OPERATION;  
  16.         }  
  17.   
  18.         // Use CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG for ZSL streaming case.  
  19.         if (client->getCameraDeviceVersion() >= CAMERA_DEVICE_API_VERSION_3_0) {  
  20.             if (params.zslMode && !params.recordingHint) {  
  21.                 res = device->createDefaultRequest(CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG,  
  22.                         &mPreviewRequest);  
  23.             } else {  
  24.                 res = device->createDefaultRequest(CAMERA3_TEMPLATE_PREVIEW,  
  25.                         &mPreviewRequest);  
  26.             }  
  27.         } else {  
  28.             res = device->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,  
  29.                     &mPreviewRequest);//创建一个Preview相关的request，由底层的hal来完成default创建  
  30.         }  
  31.   
  32.         if (res != OK) {  
  33.             ALOGE("%s: Camera %d: Unable to create default preview request: "  
  34.                     "%s (%d)", __FUNCTION__, mId, strerror(-res), res);  
  35.             return res;  
  36.         }  
  37.     }  
  38.   
  39.     res = params.updateRequest(&mPreviewRequest);//根据参数来更新CameraMetadata request  
  40.     if (res != OK) {  
  41.         ALOGE("%s: Camera %d: Unable to update common entries of preview "  
  42.                 "request: %s (%d)", __FUNCTION__, mId,  
  43.                 strerror(-res), res);  
  44.         return res;  
  45.     }  
  46.   
  47.     res = mPreviewRequest.update(ANDROID_REQUEST_ID,  
  48.             &mPreviewRequestId, 1);//mPreviewRequest的ANDROID_REQUEST_ID  
  49.     if (res != OK) {  
  50.         ALOGE("%s: Camera %d: Unable to update request id for preview: %s (%d)",  
  51.                 __FUNCTION__, mId, strerror(-res), res);  
  52.         return res;  
  53.     }  
  54.   
  55.     return OK;  
  56. }<span style="color:#ff0000;">  
  57. </span>  
该函数的处理过程是一个构建并初始化 mPreviewRequest的过程，分以下几个流程来分析：

a mPreviewRequest是一个CameraMetadata类型数据，用于封装当前previewRequest。


b device->createDefaultRequest(CAMERA3_TEMPLATE_PREVIEW, &mPreviewRequest)

[cpp] view plain copy
  1. const camera_metadata_t *rawRequest;  
  2.  ATRACE_BEGIN("camera3->construct_default_request_settings");  
  3.  rawRequest = mHal3Device->ops->construct_default_request_settings(  
  4.      mHal3Device, templateId);  
  5.  ATRACE_END();  
  6.  if (rawRequest == NULL) {  
  7.      SET_ERR_L("HAL is unable to construct default settings for template %d",  
  8.              templateId);  
  9.      return DEAD_OBJECT;  
  10.  }  
  11.  *request = rawRequest;  
  12.  mRequestTemplateCache[templateId] = rawRequest;  
最终是由hal来实现构建一个rawrequest,即对于Preview，而言是构建了一个 CAMERA3_TEMPLATE_PREVIEW类型的Request。其实对HAL而言，rawrequest本质是用于操作一个camera_metadata_t类型的数据：

[cpp] view plain copy
  1. struct camera_metadata {  
  2.     metadata_size_t          size;  
  3.     uint32_t                 version;  
  4.     uint32_t                 flags;  
  5.     metadata_size_t          entry_count;  
  6.     metadata_size_t          entry_capacity;  
  7.     metadata_uptrdiff_t      entries_start; // Offset from camera_metadata  
  8.     metadata_size_t          data_count;  
  9.     metadata_size_t          data_capacity;  
  10.     metadata_uptrdiff_t      data_start; // Offset from camera_metadata  
  11.     uint8_t                  reserved[];  
  12. };  
该数据结构可以存储多种数据，且可以根据entry tag的不同类型来存储数据，同时数据量的大小也可以自动调整。


c mPreviewRequest.update(ANDROID_REQUEST_ID,&mPreviewRequestId, 1)

将当前的PreviewRequest相应的ID保存到camera metadata。


（6）mStreamingProcessor->startStream启动整个预览的stream流

该函数的处理过程较为复杂，可以说是整个Preview正常工作的核心控制

[cpp] view plain copy
  1. status_t StreamingProcessor::startStream(StreamType type,  
  2.         const Vector<int32_t> &outputStreams) {  
  3. .....  
  4. CameraMetadata &request = (type == PREVIEW) ?  
  5.             mPreviewRequest : mRecordingRequest;//取preview的CameraMetadata request  
  6. ....res = request.update(  
  7.     ANDROID_REQUEST_OUTPUT_STREAMS,  
  8.         outputStreams);//CameraMetadata中添加outputStreams  
  9.  res = device->setStreamingRequest(request);//向hal发送request  
  10. .....  
  11. }  

该函数首先是根据当前工作模式来确定StreamingProcessor需要处理的Request，该模块负责Preview和Record两个Request。

以PreviewRequest就是之前createDefaultRequest构建的，这里先是将这个Request所需要操作的Outputstream打包到一个tag叫ANDROID_REQUEST_OUTPUT_STREAMS的entry当中。


a:setStreamingRequest

真正的请求Camera3Device去处理这个带有多路stream的PreviewRequest。

[cpp] view plain copy
  1. status_t Camera3Device::setStreamingRequest(const CameraMetadata &request,  
  2.                                             int64_t* /*lastFrameNumber*/) {  
  3.     ATRACE_CALL();  
  4.   
  5.     List<const CameraMetadata> requests;  
  6.     requests.push_back(request);  
  7.     return setStreamingRequestList(requests, /*lastFrameNumber*/NULL);  
  8. }  
该函数将mPreviewRequest push到一个list，调用setStreamingRequestList

[cpp] view plain copy
  1. status_t Camera3Device::setStreamingRequestList(const List<const CameraMetadata> &requests,  
  2.                                                 int64_t *lastFrameNumber) {  
  3.     ATRACE_CALL();  
  4.   
  5.     return submitRequestsHelper(requests, /*repeating*/true, lastFrameNumber);  
  6. }  

[cpp] view plain copy
  1. status_t Camera3Device::submitRequestsHelper(  
  2.         const List<const CameraMetadata> &requests, bool repeating,  
  3.         /*out*/  
  4.         int64_t *lastFrameNumber) {//repeating = 1;lastFrameNumber = NULL  
  5.     ATRACE_CALL();  
  6.     Mutex::Autolock il(mInterfaceLock);  
  7.     Mutex::Autolock l(mLock);  
  8.   
  9.     status_t res = checkStatusOkToCaptureLocked();  
  10.     if (res != OK) {  
  11.         // error logged by previous call  
  12.         return res;  
  13.     }  
  14.   
  15.     RequestList requestList;  
  16.   
  17.     res = convertMetadataListToRequestListLocked(requests, /*out*/&requestList);//返回的是CaptureRequest RequestList  
  18.     if (res != OK) {  
  19.         // error logged by previous call  
  20.         return res;  
  21.     }  
  22.   
  23.     if (repeating) {  
  24.         res = mRequestThread->setRepeatingRequests(requestList, lastFrameNumber);//重复的request存入到RequestThread  
  25.     } else {  
  26.         res = mRequestThread->queueRequestList(requestList, lastFrameNumber);//capture模式，拍照单词  
  27.     }  
  28.   
  29.     if (res == OK) {  
  30.         waitUntilStateThenRelock(/*active*/true, kActiveTimeout);  
  31.         if (res != OK) {  
  32.             SET_ERR_L("Can't transition to active in %f seconds!",  
  33.                     kActiveTimeout/1e9);  
  34.         }  
  35.         ALOGV("Camera %d: Capture request %" PRId32 " enqueued", mId,  
  36.               (*(requestList.begin()))->mResultExtras.requestId);  
  37.     } else {  
  38.         CLOGE("Cannot queue request. Impossible.");  
  39.         return BAD_VALUE;  
  40.     }  
  41.   
  42.     return res;  
  43. }  
b convertMetadataListToRequestListLocked

这个函数是需要将Requestlist中保存的CameraMetadata数据转换为List<sp<CaptureRequest> >

[cpp] view plain copy
  1. status_t Camera3Device::convertMetadataListToRequestListLocked(  
  2.         const List<const CameraMetadata> &metadataList, RequestList *requestList) {  
  3.     if (requestList == NULL) {  
  4.         CLOGE("requestList cannot be NULL.");  
  5.         return BAD_VALUE;  
  6.     }  
  7.   
  8.     int32_t burstId = 0;  
  9.     for (List<const CameraMetadata>::const_iterator it = metadataList.begin();//CameraMetadata, mPreviewRequest  
  10.             it != metadataList.end(); ++it) {  
  11.         sp<CaptureRequest> newRequest = setUpRequestLocked(*it);//新建CaptureRequest由CameraMetadata转化而来  
  12.         if (newRequest == 0) {  
  13.             CLOGE("Can't create capture request");  
  14.             return BAD_VALUE;  
  15.         }  
  16.   
  17.         // Setup burst Id and request Id  
  18.         newRequest->mResultExtras.burstId = burstId++;  
  19.         if (it->exists(ANDROID_REQUEST_ID)) {  
  20.             if (it->find(ANDROID_REQUEST_ID).count == 0) {  
  21.                 CLOGE("RequestID entry exists; but must not be empty in metadata");  
  22.                 return BAD_VALUE;  
  23.             }  
  24.             newRequest->mResultExtras.requestId = it->find(ANDROID_REQUEST_ID).data.i32[0];//设置该request对应的id  
  25.         } else {  
  26.             CLOGE("RequestID does not exist in metadata");  
  27.             return BAD_VALUE;  
  28.         }  
  29.   
  30.         requestList->push_back(newRequest);  
  31.   
  32.         ALOGV("%s: requestId = %" PRId32, __FUNCTION__, newRequest->mResultExtras.requestId);  
  33.     }  
  34.     return OK;  
  35. }  
这里是对List<const CameraMetadata>进行迭代解析处理，如当前模式下仅存在PreviewRequest这一个CameraMetadata，通过setUpRequestLocked将其转换为一个CaptureRequest。


c 重点来关注setUpRequestLocked复杂的处理过程

[cpp] view plain copy
  1. sp<Camera3Device::CaptureRequest> Camera3Device::setUpRequestLocked(  
  2.         const CameraMetadata &request) {//mPreviewRequest  
  3.     status_t res;  
  4.   
  5.     if (mStatus == STATUS_UNCONFIGURED || mNeedConfig) {  
  6.         res = configureStreamsLocked();  
  7.       ......<strong>  
  8.     </strong>sp<CaptureRequest> newRequest = createCaptureRequest(request);//CameraMetadata转为CaptureRequest，包含mOutputStreams  
  9.     return newRequest;  
  10. }  

configureStreamsLocked函数主要是将Camera3Device侧建立的所有Stream包括Output与InPut格式的交由HAL3层的Device去实现处理的核心接口是configure_streams与register_stream_buffer。该部分内容会涉及到更多的数据流，详细的处理过程会放在下一博文中进行分析。


createCaptureRequest函数是将一个CameraMetadata格式的数据如PreviewRequest转换为一个CaptureRequest：

[cpp] view plain copy
  1. sp<Camera3Device::CaptureRequest> Camera3Device::createCaptureRequest(  
  2.         const CameraMetadata &request) {//mPreviewRequest  
  3.     ATRACE_CALL();  
  4.     status_t res;  
  5.   
  6.     sp<CaptureRequest> newRequest = new CaptureRequest;  
  7.     newRequest->mSettings = request;//CameraMetadata  
  8.   
  9.     camera_metadata_entry_t inputStreams =  
  10.             newRequest->mSettings.find(ANDROID_REQUEST_INPUT_STREAMS);  
  11.     if (inputStreams.count > 0) {  
  12.         if (mInputStream == NULL ||  
  13.                 mInputStream->getId() != inputStreams.data.i32[0]) {  
  14.             CLOGE("Request references unknown input stream %d",  
  15.                     inputStreams.data.u8[0]);  
  16.             return NULL;  
  17.         }  
  18.         // Lazy completion of stream configuration (allocation/registration)  
  19.         // on first use  
  20.         if (mInputStream->isConfiguring()) {  
  21.             res = mInputStream->finishConfiguration(mHal3Device);  
  22.             if (res != OK) {  
  23.                 SET_ERR_L("Unable to finish configuring input stream %d:"  
  24.                         " %s (%d)",  
  25.                         mInputStream->getId(), strerror(-res), res);  
  26.                 return NULL;  
  27.             }  
  28.         }  
  29.   
  30.         newRequest->mInputStream = mInputStream;  
  31.         newRequest->mSettings.erase(ANDROID_REQUEST_INPUT_STREAMS);  
  32.     }  
  33.   
  34.     camera_metadata_entry_t streams =  
  35.             newRequest->mSettings.find(ANDROID_REQUEST_OUTPUT_STREAMS);//读取存储在CameraMetadata的stream id信息  
  36.     if (streams.count == 0) {  
  37.         CLOGE("Zero output streams specified!");  
  38.         return NULL;  
  39.     }  
  40.   
  41.     for (size_t i = 0; i < streams.count; i++) {  
  42.         int idx = mOutputStreams.indexOfKey(streams.data.i32[i]);//Camera3OutputStream的id在mOutputStreams中  
  43.         if (idx == NAME_NOT_FOUND) {  
  44.             CLOGE("Request references unknown stream %d",  
  45.                     streams.data.u8[i]);  
  46.             return NULL;  
  47.         }  
  48.         sp<Camera3OutputStreamInterface> stream =  
  49.                 mOutputStreams.editValueAt(idx);//返回的是Camera3OutputStream，preview/callback等stream  
  50.   
  51.         // Lazy completion of stream configuration (allocation/registration)  
  52.         // on first use  
  53.         if (stream->isConfiguring()) {//STATE_IN_CONFIG或者STATE_IN_RECONFIG  
  54.             res = stream->finishConfiguration(mHal3Device);//register_stream_buffer， STATE_CONFIGURED  
  55.             if (res != OK) {  
  56.                 SET_ERR_L("Unable to finish configuring stream %d: %s (%d)",  
  57.                         stream->getId(), strerror(-res), res);  
  58.                 return NULL;  
  59.             }  
  60.         }  
  61.   
  62.         newRequest->mOutputStreams.push(stream);//Camera3OutputStream添加到CaptureRequest的mOutputStreams  
  63.     }  
  64.     newRequest->mSettings.erase(ANDROID_REQUEST_OUTPUT_STREAMS);  
  65.   
  66.     return newRequest;  
  67. }  
该函数主要处理指定的这个CameraMetadata mPreviewRequest下对应所拥有的Output与Input Stream，对于Preview而言，至少存在OutPutStream包括一路StreamProcessor与一路可选的CallbackProcessor。

在构建这个PreviewRequest时，已经将ANDROID_REQUEST_OUTPUT_STREAMS这个Tag进行了初始化，相应的内容为Vector<int32_t> &outputStreams，包含着属于PreviewRequest这个Request所需要的输出stream的ID值，通过这个ID index值，可以遍历到Camera3Device下所createstream创造的Camera3OutputStream，即说明不同类型的Request在Camera3Device端存在多个Stream，而每次不同业务下所需要Request的对应的Stream又仅是其中的个别而已。

idx =  mOutputStreams.indexOfKey(streams.data.i32[i])是通过属于PreviewRequest中包含的一个stream的ID值来查找到mOutputStreams这个KeyedVector中对应的标定值index。注意：两个索引值不一定是一致的。

mOutputStreams.editValueAt(idx)是获取一个与该ID值(如Previewstream ID、Callback Stream ID等等)相对应的Camera3OutputStream。


在找到了当前Request中所有的Camera3OutputStream后，将其维护在CaptureRequest中

[cpp] view plain copy
  1. class CaptureRequest : public LightRefBase<CaptureRequest> {  
  2.       public:  
  3.         CameraMetadata                      mSettings;  
  4.         sp<camera3::Camera3Stream>          mInputStream;  
  5.         Vector<sp<camera3::Camera3OutputStreamInterface> >  
  6.                                             mOutputStreams;  
  7.         CaptureResultExtras                 mResultExtras;  
  8.     };  
mSettings是保存CameraMetadata PreviewRequest，vector mOutPutStreams保存着当前Request提取出来的 Camera3OutputStream，至此构建了一个CaptureRequest。


返回到convertMetadataListToRequestListLocked中，现在已经完成了一个CameraMetadata Request的处理，生产的是一个CaptureRequest。我们将这个ANDROID_REQUEST_ID的ID值，保留在

newRequest->mResultExtras.requestId = it->find(ANDROID_REQUEST_ID).data.i32[0]。

这个值在整个Camera3的架构中，仅存在3大种Request类型，说明了整个和HAL层交互的Request类型是不多的：

预览Request mPreviewRequest：        mPreviewRequestId(Camera2Client::kPreviewRequestIdStart),

拍照Request mCaptureRequest：mCaptureId(Camera2Client::kCaptureRequestIdStart),

录像Request mRecordingRequest：        mRecordingRequestId(Camera2Client::kRecordingRequestIdStart),

[cpp] view plain copy
  1. static const int32_t kPreviewRequestIdStart = 10000000;  
  2. static const int32_t kPreviewRequestIdEnd   = 20000000;  
  3. static const int32_t kRecordingRequestIdStart  = 20000000;  
  4. static const int32_t kRecordingRequestIdEnd    = 30000000;  
  5. static const int32_t kCaptureRequestIdStart = 30000000;  
  6. static const int32_t kCaptureRequestIdEnd   = 40000000;  
至此执行requestList->push_back(newRequest)后生成了一个 requestList，本质上可以先认为这次仅是含有PreviewRequest相关的内容。


d mRequestThread->setRepeatingRequests(requestList)

对于Preview来说，一次Preview后底层硬件就该可以连续的工作，而不需要进行过多的切换，故Framework每次向HAL发送的Request均是一种repeat的操作模式，故调用了一个重复的RequestQueue来循环处理每次的Request。

[cpp] view plain copy
  1. status_t Camera3Device::RequestThread::setRepeatingRequests(  
  2.         const RequestList &requests,  
  3.         /*out*/  
  4.         int64_t *lastFrameNumber) {  
  5.     Mutex::Autolock l(mRequestLock);  
  6.     if (lastFrameNumber != NULL) {//第一次进来为null  
  7.         *lastFrameNumber = mRepeatingLastFrameNumber;  
  8.     }  
  9.     mRepeatingRequests.clear();  
  10.     mRepeatingRequests.insert(mRepeatingRequests.begin(),  
  11.             requests.begin(), requests.end());  
  12.   
  13.     unpauseForNewRequests();//signal request_thread in waitfornextrequest  
  14.   
  15.     mRepeatingLastFrameNumber = NO_IN_FLIGHT_REPEATING_FRAMES;  
  16.     return OK;  
  17. }  
将Preview线程提交的Request加入到mRepeatingRequests中后，唤醒RequestThread线程去处理当前新的Request。


(7) RequestThread 请求处理线程

RequestThread::threadLoop()函数主要用于响应并处理新加入到Request队列中的请求。

[cpp] view plain copy
  1. bool Camera3Device::RequestThread::threadLoop() {  
  2. ....  
  3.     sp<CaptureRequest> nextRequest = waitForNextRequest();//返回的是mRepeatingRequests，mPreviewRequest  
  4.     if (nextRequest == NULL) {  
  5.         return true;  
  6.     }  
  7.     // Create request to HAL  
  8.     camera3_capture_request_t request = camera3_capture_request_t();//CaptureRequest转为给HAL3.0的camera3_capture_request_t  
  9.     request.frame_number = nextRequest->mResultExtras.frameNumber;//当前帧号  
  10.     Vector<camera3_stream_buffer_t> outputBuffers;  
  11.     // Get the request ID, if any  
  12.     int requestId;  
  13.     camera_metadata_entry_t requestIdEntry =  
  14.             nextRequest->mSettings.find(ANDROID_REQUEST_ID);  
  15.     if (requestIdEntry.count > 0) {  
  16.         requestId = requestIdEntry.data.i32[0];//获取requestid,这里是mPreviewRequest的id  
  17.     } else {  
  18.         ALOGW("%s: Did not have android.request.id set in the request",  
  19.                 __FUNCTION__);  
  20.         requestId = NAME_NOT_FOUND;  
  21.     }  
  22.  .....  
  23.     camera3_stream_buffer_t inputBuffer;  
  24.     uint32_t totalNumBuffers = 0;  
  25. .....  
  26.     // Submit request and block until ready for next one  
  27.     ATRACE_ASYNC_BEGIN("frame capture", request.frame_number);  
  28.     ATRACE_BEGIN("camera3->process_capture_request");  
  29.     res = mHal3Device->ops->process_capture_request(mHal3Device, &request);//调用底层的process_capture_request  
  30.     ATRACE_END();  
  31.   
  32.    .......  
  33. }  
函数主体内容较为复杂，分以下几个部分来说明他的响应逻辑：

(7.1) waitForNextRequest()

[cpp] view plain copy
  1.     Camera3Device::RequestThread::waitForNextRequest() {  
  2. status_t res;  
  3. sp<CaptureRequest> nextRequest;  
  4.   
  5. // Optimized a bit for the simple steady-state case (single repeating  
  6. // request), to avoid putting that request in the queue temporarily.  
  7. Mutex::Autolock l(mRequestLock);  
  8.   
  9. while (mRequestQueue.empty()) {  
  10.     if (!mRepeatingRequests.empty()) {  
  11.         // Always atomically enqueue all requests in a repeating request  
  12.         // list. Guarantees a complete in-sequence set of captures to  
  13.         // application.  
  14.         const RequestList &requests = mRepeatingRequests;  
  15.         RequestList::const_iterator firstRequest =  
  16.                 requests.begin();  
  17.         nextRequest = *firstRequest;//取  
  18.         mRequestQueue.insert(mRequestQueue.end(),  
  19.                 ++firstRequest,  
  20.                 requests.end());//把当前的mRepeatingRequests插入到mRequestQueue  
  21.         // No need to wait any longer  
  22.   
  23.         mRepeatingLastFrameNumber = mFrameNumber + requests.size() - 1;  
  24.   
  25.         break;  
  26.     }  
  27.   
  28.     res = mRequestSignal.waitRelative(mRequestLock, kRequestTimeout);//等待下一个request  
  29.   
  30.     if ((mRequestQueue.empty() && mRepeatingRequests.empty()) ||  
  31.             exitPending()) {  
  32.         Mutex::Autolock pl(mPauseLock);  
  33.         if (mPaused == false) {  
  34.             ALOGV("%s: RequestThread: Going idle", __FUNCTION__);  
  35.             mPaused = true;  
  36.             // Let the tracker know  
  37.             sp<StatusTracker> statusTracker = mStatusTracker.promote();  
  38.             if (statusTracker != 0) {  
  39.                 statusTracker->markComponentIdle(mStatusId, Fence::NO_FENCE);  
  40.             }  
  41.         }  
  42.         // Stop waiting for now and let thread management happen  
  43.         return NULL;  
  44.     }  
  45. }  
  46.   
  47. if (nextRequest == NULL) {  
  48.     // Don't have a repeating request already in hand, so queue  
  49.     // must have an entry now.  
  50.     RequestList::iterator firstRequest =  
  51.             mRequestQueue.begin();  
  52.     nextRequest = *firstRequest;  
  53.     mRequestQueue.erase(firstRequest);//取一根mRequestQueue中的CaptureRequest，来自于mRepeatingRequests的next  
  54. }  
  55.   
  56. // In case we've been unpaused by setPaused clearing mDoPause, need to  
  57. // update internal pause state (capture/setRepeatingRequest unpause  
  58. // directly).  
  59. Mutex::Autolock pl(mPauseLock);  
  60. if (mPaused) {  
  61.     ALOGV("%s: RequestThread: Unpaused", __FUNCTION__);  
  62.     sp<StatusTracker> statusTracker = mStatusTracker.promote();  
  63.     if (statusTracker != 0) {  
  64.         statusTracker->markComponentActive(mStatusId);  
  65.     }  
  66. }  
  67. mPaused = false;  
  68.   
  69. // Check if we've reconfigured since last time, and reset the preview  
  70. // request if so. Can't use 'NULL request == repeat' across configure calls.  
  71. if (mReconfigured) {  
  72.     mPrevRequest.clear();  
  73.     mReconfigured = false;  
  74. }  
  75.   
  76. if (nextRequest != NULL) {  
  77.     nextRequest->mResultExtras.frameNumber = mFrameNumber++;//对每一个非空的request需要帧号++  
  78.     nextRequest->mResultExtras.afTriggerId = mCurrentAfTriggerId;  
  79.     nextRequest->mResultExtras.precaptureTriggerId = mCurrentPreCaptureTriggerId;  
  80. }  
  81. return nextRequest;  
该函数是响应RequestList的核心，通过不断的轮训休眠等待一旦mRepeatingRequests有Request可处理时，就将他内部所有的 CaptureRequest加入到 mRequestQueue 中去，理论来说每一个CaptureRequest对应着一帧的请求处理，每次响应时可能会出现mRequestQueue包含了多个CaptureRequest。

通过nextRequest->mResultExtras.frameNumber = mFrameNumber++表示当前CaptureRequest在处理的一帧图像号。

对于mRepeatingRequests而言，只有其非空，在执行完一次queue操作后，在循环进入执行时，会自动对mRequestQueue进行erase操作，是的mRequestQueue变为empty后再次重新加载mRepeatingRequests中的内容，从而形成一个队repeatRequest的重复响应过程。


(7.2)   camera_metadata_entry_t requestIdEntry = nextRequest->mSettings.find(ANDROID_REQUEST_ID);提取该CaptureRequest对应的Request 类型值


(7.3) getBuffer操作

涉及到比较复杂的数据流操作过程的内容见下一博文


(7.4) mHal3Device->ops->process_capture_request(mHal3Device, &request)

这里的request是已经由一个CaptureRequest转换为和HAL3.0交互的camera3_capture_request_t结构。



8 小结

至此已经完成了一次向HAL3.0 Device发送一次完整的Request的请求。从最初Preview启动建立多个OutPutStream，再是将这些Stream打包成一个mPreviewRequest来启动stream，随后将这个Request又转变为一个CaptureRequest，直到转为Capture list后交由RequestThread来处理这些请求。每一次的Request简单可以说是Camera3Device向HAL3.0请求一帧数据，当然每一次Request也可以包含各种控制操作，如AutoFocus等内容，会在后续补充。

到这里从StartPreview的入口开始，直到相应的Request下发到HAL3.0，基本描述了一次完成的控制流的处理。对于较为复杂的数据流本质也是一并合并在这个控制操作中的，但作为Buffer视频缓存流的管理维护将在下一博文进行描述与总结。


这篇关于Android Camera HAL3中预览preview模式下的控制流的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/278524。

相关文章

Android数据库Room的实际使用过程总结

Android数据库Room的实际使用过程总结

《Android数据库Room的实际使用过程总结》这篇文章主要给大家介绍了关于Android数据库Room的实际使用过程,详细介绍了如何创建实体类、数据访问对象（DAO）和数据库抽象类,需要的朋友可以... 目录前言一、Room的基本使用1.项目配置2.创建实体类（Entity）3.创建数据访问对象（DAO
阅读更多...
Android WebView的加载超时处理方案

Android WebView的加载超时处理方案

《AndroidWebView的加载超时处理方案》在Android开发中,WebView是一个常用的组件,用于在应用中嵌入网页,然而,当网络状况不佳或页面加载过慢时,用户可能会遇到加载超时的问题,本... 目录引言一、WebView加载超时的原因二、加载超时处理方案1. 使用Handler和Timer进行超
阅读更多...
Android实现任意版本设置默认的锁屏壁纸和桌面壁纸（两张壁纸可不一致）

Android实现任意版本设置默认的锁屏壁纸和桌面壁纸（两张壁纸可不一致）

客户有些需求需要设置默认壁纸和锁屏壁纸  在默认情况下 这两个壁纸是相同的  如果需要默认的锁屏壁纸和桌面壁纸不一样 需要额外修改 Android13实现 替换默认桌面壁纸： 将图片文件替换frameworks/base/core/res/res/drawable-nodpi/default_wallpaper.*  （注意不能是bmp格式） 替换默认锁屏壁纸： 将图片资源放入vendo
阅读更多...
在JS中的设计模式的单例模式、策略模式、代理模式、原型模式浅讲

在JS中的设计模式的单例模式、策略模式、代理模式、原型模式浅讲

1. 单例模式（Singleton Pattern） 确保一个类只有一个实例，并提供一个全局访问点。 示例代码： class Singleton {constructor() {if (Singleton.instance) {return Singleton.instance;}Singleton.instance = this;this.data = [];}addData(value)
阅读更多...
Android平台播放RTSP流的几种方案探究（VLC VS ExoPlayer VS SmartPlayer）

Android平台播放RTSP流的几种方案探究（VLC VS ExoPlayer VS SmartPlayer）

技术背景 好多开发者需要遴选Android平台RTSP直播播放器的时候，不知道如何选的好，本文针对常用的方案，做个大概的说明： 1. 使用VLC for Android VLC Media Player（VLC多媒体播放器），最初命名为VideoLAN客户端，是VideoLAN品牌产品，是VideoLAN计划的多媒体播放器。它支持众多音频与视频解码器及文件格式，并支持DVD影音光盘，VCD影
阅读更多...
android-opencv-jni

android-opencv-jni

//------------------start opencv--------------------@Override public void onResume(){ super.onResume(); //通过OpenCV引擎服务加载并初始化OpenCV类库，所谓OpenCV引擎服务即是 //OpenCV_2.4.3.2_Manager_2.4_*.apk程序包，存
阅读更多...
从状态管理到性能优化：全面解析 Android Compose

从状态管理到性能优化：全面解析 Android Compose

文章目录 引言一、Android Compose基本概念1.1 什么是Android Compose?1.2 Compose的优势1.3 如何在项目中使用Compose 二、Compose中的状态管理2.1 状态管理的重要性2.2 Compose中的状态和数据流2.3 使用State和MutableState处理状态2.4 通过ViewModel进行状态管理 三、Compose中的列表和滚动
阅读更多...
模版方法模式template method

模版方法模式template method

学习笔记，原文链接 https://refactoringguru.cn/design-patterns/template-method 超类中定义了一个算法的框架， 允许子类在不修改结构的情况下重写算法的特定步骤。 上层接口有默认实现的方法和子类需要自己实现的方法
阅读更多...
Android 10.0 mtk平板camera2横屏预览旋转90度横屏拍照图片旋转90度功能实现

Android 10.0 mtk平板camera2横屏预览旋转90度横屏拍照图片旋转90度功能实现

1.前言 在10.0的系统rom定制化开发中，在进行一些平板等默认横屏的设备开发的过程中，需要在进入camera2的 时候，默认预览图像也是需要横屏显示的，在上一篇已经实现了横屏预览功能，然后发现横屏预览后，拍照保存的图片 依然是竖屏的，所以说同样需要将图片也保存为横屏图标了，所以就需要看下mtk的camera2的相关横屏保存图片功能， 如何实现实现横屏保存图片功能 如图所示: 2.mtk
阅读更多...
android应用中res目录说明

android应用中res目录说明

Android应用的res目录是一个特殊的项目，该项目里存放了Android应用所用的全部资源，包括图片、字符串、颜色、尺寸、样式等，类似于web开发中的public目录，js、css、image、style。。。。 Android按照约定，将不同的资源放在不同的文件夹中，这样可以方便的让AAPT(即Android Asset Packaging Tool , 在SDK的build-tools目
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2