程序博客网 > php 互换数组里面的值

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

来源：互联网 发布：php 互换数组里面的值 编辑：程序博客网 时间：2024/05/01 17:22

http://blog.csdn.net/gzzaigcnforever/article/details/48997463

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视频缓存流的管理维护将在下一博文进行描述与总结。


0 0
php 互换数组里面的值 php 互换数组里面的值
原创粉丝点击
热门IT博客
js 对象集合js 对象集合
行星减速机 知乎行星减速机 知乎
淘宝聚星台
电脑容易被入侵的端口
cnc程序模拟软件
怎样删除软件注册表
finder for mac
linux nic link
供应链网络鲁棒性
国安社区数据app
mac上app store出错4
短信平台软件下载
windows操作系统平板
域名备案到期
淘宝 卖家客服电话
dnf淘宝卡称号
java输入流读取文件
2016年淘宝活动时间表
知乎有趣的回答
js统计浏览次数
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 黄勇深 黄勇智能木马 黄勇案 黄勐 黄勤翔 黄华 黄华照片 菊有黄华 黄华市 黄南 黄南州 2019黄历 老黄历2019 老黄历网 今天黄历 老黄历查询 黄历网 2020年黄历 2020黄历 黄历宜忌 2019老黄历 黄历2019 在线老黄历 下载老黄历 明天黄历 万年老黄历 香港黄历 每日黄历 老黄历今日 今日老黄历 查黄历 老黄历查看 在线黄历 黄历怎么看 黄历吉时 明日黄历 择吉老黄历 今天老黄历 今曰黄历 今天的黄历 查看老黄历

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里