OH-v3.0-LTS Camera相机驱动框架(L2)解析5之图像采集

mainDemo->CaptureON(STREAM_ID_PREVIEW, CAPTURE_ID_PREVIEW, CAPTURE_PREVIEW)；
RetCode Hos3516Demo::CaptureON(const int streamId, const int captureId, CaptureMode mode)
{
    CAMERA_LOGD("demo test: CaptureON enter mode == %{public}d", mode);
    std::shared_ptr<Camera::CaptureInfo> captureInfo = std::make_shared<Camera::CaptureInfo>();
    captureInfo->streamIds_ = {streamId};
    captureInfo->captureSetting_ = ability_;
    captureInfo->enableShutterCallback_ = false;
    int rc = streamOperator_->Capture(captureId, captureInfo, true);
    ......
    CAMERA_LOGD("demo test: CaptureON exit");
    return RC_OK;
}

//drivers/peripheral/camera/hal/hdi_impl/src/stream_operator/stream_operator.cpp
CamRetCode StreamOperator::Capture(int captureId, const std::shared_ptr<CaptureInfo>& captureInfo, bool isStreaming)
{
...
    CaptureSetting setting = captureInfo->captureSetting_;
    auto request =
        std::make_shared<CaptureRequest>(captureId, captureInfo->streamIds_.size(), setting,                                        captureInfo->enableShutterCallback_, isStreaming);
    for (auto id : captureInfo->streamIds_) {
        RetCode rc = streamMap_[id]->AddRequest(request);
        if (rc != RC_OK) {
            return DEVICE_ERROR;
        }
    }
...
    return NO_ERROR;
}

//drivers/peripheral/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp
RetCode StreamBase::AddRequest(std::shared_ptr<CaptureRequest>& request)
{
    ......
    if (isFirstRequest) {
        ......
        RetCode rc = StartStream();
        if (rc != RC_OK) {
            CAMERA_LOGE("start stream [id:%{public}d] failed", streamId_);
            return RC_ERROR;
        }
        request->SetFirstRequest(true);
        isFirstRequest = false;
    }
    {
        std::unique_lock<std::mutex> l(wtLock_);
        waitingList_.emplace_back(request);
        cv_.notify_one();
    }
    return RC_OK;
}

//drivers/peripheral/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp
RetCode StreamBase::StartStream()
{
    ...
    RetCode rc = pipeline_->Prepare({streamId_});
    ...
    state_ = STREAM_STATE_BUSY;
    std::string threadName =
        g_avaliableStreamType[static_cast<StreamIntent>(streamType_)] + "#" + std::to_string(streamId_);

        handler_ = std::make_unique<std::thread>([this, &threadName] {
        prctl(PR_SET_NAME, threadName.c_str());
        while (state_ == STREAM_STATE_BUSY) {
            HandleRequest();
        }
    });
    rc = pipeline_->Start({streamId_});
    ...
    return RC_OK;
}

//drivers/peripheral/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp
RetCode StreamBase::Capture(const std::shared_ptr<CaptureRequest>& request)
{
    ...
    rc = pipeline_->Config({streamId_}, request->GetCaptureSetting());
    ...
    rc = pipeline_->Capture({streamId_}, request->GetCaptureId());
    ...
    if (request->IsFirstOne()) {
        if (messenger_ == nullptr) {
            CAMERA_LOGE("stream [id:%{public}d] can't send message, messenger_ is null", streamId_);
            return RC_ERROR;
        }
        std::shared_ptr<ICaptureMessage> startMessage = std::make_shared<CaptureStartedMessage>(
            streamId_, request->GetCaptureId(), request->GetBeginTime(), request->GetOwnerCount());
        messenger_->SendMessage(startMessage);
        request->SetFirstRequest(false);
    }
    // DeliverBuffer must be called after Capture, or this capture request will miss a buffer.
    do {
        rc = DeliverBuffer();
    } while (rc != RC_OK && state_ == STREAM_STATE_BUSY);
    return RC_OK;
}

RetCode StreamBase::DeliverBuffer()
{
    CHECK_IF_PTR_NULL_RETURN_VALUE(tunnel_, RC_ERROR);
    CHECK_IF_PTR_NULL_RETURN_VALUE(bufferPool_, RC_ERROR);
    std::shared_ptr<IBuffer> buffer = tunnel_->GetBuffer();
    CHECK_IF_PTR_NULL_RETURN_VALUE(buffer, RC_ERROR);
    buffer->SetEncodeType(streamConfig_.encodeType);
    buffer->SetStreamId(streamId_);
    bufferPool_->AddBuffer(buffer);
    CAMERA_LOGI("stream [id:%{public}d] enqueue buffer index:%{public}d", streamId_, buffer->GetIndex());
    return RC_OK;
}

//drivers/peripheral/camera/hal/pipeline_core/nodes/src/source_node/source_node.cpp
void SourceNode::PortHandler::CollectBuffers()
{
    CHECK_IF_PTR_NULL_RETURN_VOID(pool);
    std::shared_ptr<IBuffer> buffer = pool->AcquireBuffer(-1);
    CHECK_IF_PTR_NULL_RETURN_VOID(buffer);
    PortFormat format = {};
    port->GetFormat(format);
    std::shared_ptr<FrameSpec> frameSpec = std::make_shared<FrameSpec>();
    frameSpec->bufferPoolId_ = format.bufferPoolId_;
    frameSpec->bufferCount_ = format.bufferCount_;
    frameSpec->buffer_ = buffer;
    auto node = port->GetNode();
    CHECK_IF_PTR_NULL_RETURN_VOID(node);
    RetCode rc = node->ProvideBuffers(frameSpec);
    if (rc == RC_ERROR) {
        CAMERA_LOGE("provide buffer failed.");
    }
}

//drivers/peripheral/camera/hal/adapter/chipset/hispark_taurus/src/pipeline_core/nodes/vpss_node/vpss_node.cpp
RetCode VpssNode::ProvideBuffers(std::shared_ptr<FrameSpec> frameSpec)
{
    if (deviceManager_->SendFrameBuffer(frameSpec) == RC_OK) {
        return RC_OK;
    }
    CAMERA_LOGE("provide buffer failed.");
    return RC_ERROR;
}

//drivers/peripheral/camera/hal/pipeline_core/nodes/src/source_node/source_node.cpp
RetCode SourceNode::Start(const int32_t streamId)
{
    ...
    SetBufferCallback();
    ...
    RetCode rc = handler_[streamId]->StartCollectBuffers();
    CHECK_IF_NOT_EQUAL_RETURN_VALUE(rc, RC_OK, RC_ERROR);
    rc = handler_[streamId]->StartDistributeBuffers();
    CHECK_IF_NOT_EQUAL_RETURN_VALUE(rc, RC_OK, RC_ERROR);
    return RC_OK;
}

//drivers/peripheral/camera/hal/adapter/chipset/hispark_taurus/src/pipeline_core/nodes/vpss_node/vpss_node.cpp
void VpssNode::SetBufferCallback()
{
    deviceManager_->SetNodeCallBack([&](std::shared_ptr<FrameSpec> frameSpec) {
            OnPackBuffer(frameSpec);
    });
    return;
}

//drivers\peripheral\camera\hal\hdi_impl\src\stream_operator\stream_base.cpp
RetCode StreamBase::CommitStream()
{
    ...
    RetCode rc = hostStreamMgr_->CreateHostStream(info, [this](std::shared_ptr<IBuffer> buffer) {
        HandleResult(buffer);
        return;
    });
    ...
}

std::shared_ptr<Pipeline> StreamPipelineBuilder::Build(const std::shared_ptr<PipelineSpec>& pipelineSpec)
{
...
    std::optional<int32_t> typeId = GetTypeId(it.type_, G_STREAM_TABLE_PTR, G_STREAM_TABLE_SIZE);
    if (typeId) {
        newNode->SetCallBack(hostStreamMgr_->GetBufferCb(it.streamId_));
    }
...
}

//drivers/peripheral/camera/hal/pipeline_core/nodes/src/sink_node/sink_node.cpp
void SinkNode::DeliverBuffer(std::shared_ptr<IBuffer>& buffer)
{
    cb_(buffer);
    return;
}

//drivers/peripheral/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp
RetCode StreamBase::ReceiveBuffer(std::shared_ptr<IBuffer>& buffer)
{
    CHECK_IF_PTR_NULL_RETURN_VALUE(buffer, RC_ERROR);
    CHECK_IF_PTR_NULL_RETURN_VALUE(tunnel_, RC_ERROR);
    CHECK_IF_PTR_NULL_RETURN_VALUE(bufferPool_, RC_ERROR); 
    bufferPool_->ReturnBuffer(buffer);
    tunnel_->PutBuffer(buffer);
    return RC_OK;
}