Android camera:

生成CameraDevice后：

// This is the CaptureRequest.Builder that we use to take a picture.
final CaptureRequest.Builder captureBuilder =
            mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);

从名字上看有点误解并不是生成一个caputreRequest，而是生成CaptureRequest.Builder去构建 caputreRequest。

captureBuilder.addTarget(mImageReader.getSurface());

captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, getOrientation(rotation))；

captureBuilder.set(CaptureRequest.CONTROL_AF_MODE,CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE)；

转换为CaptureReqeust: captureBuilder.build();

  public abstract int capture(@NonNull CaptureRequest request,

            @Nullable CaptureCallback listener, @Nullable Handler handler)

public int capture(CaptureRequest request, CaptureCallback callback,

            Handler handler){

return addPendingSequence(mDeviceImpl.capture(request,
                    createCaptureCallbackProxy(handler, callback), mDeviceHandler));

}

这里不关注createCaptureCallbackProxy(handler, callback)

    public int capture(CaptureRequest request, CaptureCallback callback, Handler handler)
            throws CameraAccessException {
        List<CaptureRequest> requestList = new ArrayList<CaptureRequest>();
        requestList.add(request);
        return submitCaptureRequest(requestList, callback, handler, /*streaming*/false);
    }

    private int submitCaptureRequest(List<CaptureRequest> requestList, CaptureCallback callback,
            Handler handler, boolean repeating) throws CameraAccessException {

            SubmitInfo requestInfo;

            CaptureRequest[] requestArray = requestList.toArray(new CaptureRequest[requestList.size()]);
            requestInfo = mRemoteDevice.submitRequestList(requestArray, repeating);

       }

通过mRemoteDevice调用到 camera service:

binder::Status CameraDeviceClient::submitRequestList(
        const std::vector<hardware::camera2::CaptureRequest>& requests,
        bool streaming,
        /*out*/
        hardware::camera2::utils::SubmitInfo *submitInfo) {

    List<const CameraMetadata> metadataRequestList;
    std::list<const SurfaceMap> surfaceMapList;

  for (auto&& request: requests) {

    CameraMetadata metadata(request.mMetadata); 

 SurfaceMap surfaceMap;

 for (sp<Surface> surface : request.mSurfaceList) {

   surfaceMap[streamSurfaceId.streamId()].push_back(streamSurfaceId.surfaceId());

 }

   metadataRequestList.push_back(metadata);
   surfaceMapList.push_back(surfaceMap);
 }

mDevice->captureList(metadataRequestList, surfaceMapList,
                &(submitInfo->mLastFrameNumber));

}

status_t Camera3Device::captureList(const List<const CameraMetadata> &requests,
                                    const std::list<const SurfaceMap> &surfaceMaps,
                                    int64_t *lastFrameNumber) {
    return submitRequestsHelper(requests, surfaceMaps, /*repeating*/false, lastFrameNumber);
}

status_t Camera3Device::submitRequestsHelper(
        const List<const CameraMetadata> &requests,
        const std::list<const SurfaceMap> &surfaceMaps,
        bool repeating,
        /*out*/
        int64_t *lastFrameNumber) {

    convertMetadataListToRequestListLocked(requests, surfaceMaps,
            repeating, /*out*/&requestList);

    mRequestThread->queueRequestList(requestList, lastFrameNumber);

}

status_t Camera3Device::RequestThread::queueRequestList(
        List<sp<CaptureRequest> > &requests,
        /*out*/
        int64_t *lastFrameNumber) {

    for (List<sp<CaptureRequest> >::iterator it = requests.begin(); it != requests.end();
            ++it) {
        mRequestQueue.push_back(*it);
    }

   unpauseForNewRequests();

}

void Camera3Device::RequestThread::unpauseForNewRequests() {
    // extra signaling/waiting overhead to waitUntilPaused
    mRequestSignal.signal();

}

处理captureRequest:

bool Camera3Device::RequestThread::threadLoop() {
    // Wait for the next batch of requests.
    waitForNextRequestBatch();

    // Prepare a batch of HAL requests and output buffers.
    res = prepareHalRequests();

    // Inform waitUntilRequestProcessed thread of a new request ID
    {
        Mutex::Autolock al(mLatestRequestMutex);

        mLatestRequestId = latestRequestId;
        mLatestRequestSignal.signal();
    }

    nsecs_t tRequestStart = systemTime(SYSTEM_TIME_MONOTONIC);
    if (mInterface->supportBatchRequest()) {
        submitRequestSuccess = sendRequestsBatch();
    } else {
        submitRequestSuccess = sendRequestsOneByOne();
    }
    nsecs_t tRequestEnd = systemTime(SYSTEM_TIME_MONOTONIC);
    mRequestLatency.add(tRequestStart, tRequestEnd);

}

其中函数

void Camera3Device::RequestThread::waitForNextRequestBatch() {
    ATRACE_CALL();
    // Optimized a bit for the simple steady-state case (single repeating
    // request), to avoid putting that request in the queue temporarily.
    Mutex::Autolock l(mRequestLock);

    assert(mNextRequests.empty());

    NextRequest nextRequest;
    nextRequest.captureRequest = waitForNextRequestLocked();
    if (nextRequest.captureRequest == nullptr) {
        return;
    }

    nextRequest.halRequest = camera3_capture_request_t();
    nextRequest.submitted = false;
    mNextRequests.add(nextRequest);

}

sp<Camera3Device::CaptureRequest>
        Camera3Device::RequestThread::waitForNextRequestLocked() {

sp<CaptureRequest> nextRequest;

  mRequestSignal.waitRelative(mRequestLock, kRequestTimeout);

}

status_t Camera3Device::RequestThread::prepareHalRequests() {

     outputStream->getBuffer(&outputBuffers->editItemAt(j),
                    captureRequest->mOutputSurfaces[j]);

}

调用的内存的分配

getBufferLocked(buffer, surface_ids) ->

getBufferLockedCommon(&anb, &fenceFd)

  currentConsumer->dequeueBuffer(currentConsumer.get(), anb, fenceFd)

bool Camera3Device::RequestThread::sendRequestsOneByOne() {

    for (auto& nextRequest : mNextRequests) {
        // Submit request and block until ready for next one
        ATRACE_ASYNC_BEGIN("frame capture", nextRequest.halRequest.frame_number);
        res = mInterface->processCaptureRequest(&nextRequest.halRequest);

      }
}