From c03549e294630d154bc49a0f516ebcfe639ded54 Mon Sep 17 00:00:00 2001 From: zhaihaipeng1 Date: Wed, 29 Jun 2022 10:34:20 +0800 Subject: [PATCH] feat: Add double preview function Signed-off-by: zhaihaipeng1 --- .../nodes/src/fork_node/fork_node.cpp | 1 + camera/hal/test/v4l2/BUILD.gn | 1 + .../test/v4l2/include/double_preview_test.h | 55 ++++ .../hal/test/v4l2/src/double_preview_test.cpp | 294 ++++++++++++++++++ 4 files changed, 351 insertions(+) create mode 100644 camera/hal/test/v4l2/include/double_preview_test.h create mode 100644 camera/hal/test/v4l2/src/double_preview_test.cpp diff --git a/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.cpp b/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.cpp index 9f18222acb..e67a8f50d6 100644 --- a/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.cpp +++ b/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.cpp @@ -192,6 +192,7 @@ RetCode ForkNode::CopyBuffer(uint64_t poolId, std::shared_ptr& buffer) tmpBuffer_->GetVirAddress(), tmpBuffer_->GetSize()) != 0) { CAMERA_LOGE("memcpy_s failed."); } + buffer->SetEsFrameSize(buffer->GetSize()); buffer->SetEsTimestamp(tmpBuffer_->GetEsFrameInfo().timestamp); return RC_OK; } diff --git a/camera/hal/test/v4l2/BUILD.gn b/camera/hal/test/v4l2/BUILD.gn index 50a2fcd790..faca066644 100644 --- a/camera/hal/test/v4l2/BUILD.gn +++ b/camera/hal/test/v4l2/BUILD.gn @@ -128,6 +128,7 @@ if (defined(ohos_lite)) { module_out_path = module_output_path sources = [ "./src/camera_ability_test.cpp", + "./src/double_preview_test.cpp", "./src/hdfcamera_facedetect.cpp", "./src/open_camera_test.cpp", "./src/preview_test.cpp", diff --git a/camera/hal/test/v4l2/include/double_preview_test.h b/camera/hal/test/v4l2/include/double_preview_test.h new file mode 100644 index 0000000000..0a14968474 --- /dev/null +++ b/camera/hal/test/v4l2/include/double_preview_test.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef DOUBLE_PREVIEW_H +#define DOUBLE_PREVIEW_H + +#include "test_display.h" +#define PREVIEW_WIDTH 640 +#define PREVIEW_HEIGHT 480 +#define CAMERA_CAPTURE_WIDTH 640 +#define CAMERA_CAPTURE_HEIGHT 480 +#define CAMERA_VIDEO_WIDTH 640 +#define CAMERA_VIDEO_HEIGHT 480 + +enum { + streamId_preview_double = 1004, // double preview streamID + captureId_preview_double = 2004, // double preview captureId +}; + +class DoublePreviewTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(void); + void TearDown(void); + void CreateStream(int streamId, OHOS::Camera::StreamIntent intent); + void CommitStream(); + void SetStreamInfo(std::shared_ptr &streamInfo, + const std::shared_ptr &streamCustomer, + const int streamId, const OHOS::Camera::StreamIntent intent); + void StartCapture(int streamId, int captureId, bool shutterCallback, bool isStreaming); + void StopStream(std::vector &captureIds, std::vector &streamIds); + + OHOS::Camera::CamRetCode result_; + std::shared_ptr display_ = nullptr; + std::shared_ptr streamCustomerPreview_ = nullptr; + std::shared_ptr streamCustomerPreviewDouble_ = nullptr; + std::vector> streamInfos_; + std::shared_ptr captureInfo_ = nullptr; + std::vector captureIds_; + std::vector streamIds_; +}; +#endif /* DOUBLE_PREVIEW_H */ diff --git a/camera/hal/test/v4l2/src/double_preview_test.cpp b/camera/hal/test/v4l2/src/double_preview_test.cpp new file mode 100644 index 0000000000..efefcf8e1f --- /dev/null +++ b/camera/hal/test/v4l2/src/double_preview_test.cpp @@ -0,0 +1,294 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file expected in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "double_preview_test.h" + +using namespace testing::ext; + +void DoublePreviewTest::SetUpTestCase(void) +{} +void DoublePreviewTest::TearDownTestCase(void) +{} +void DoublePreviewTest::SetUp(void) +{ + if (display_ == nullptr) { + display_ = std::make_shared(); + } + display_->Init(); +} +void DoublePreviewTest::TearDown(void) +{ + display_->Close(); +} + +void DoublePreviewTest::SetStreamInfo(std::shared_ptr &streamInfo, + const std::shared_ptr &streamCustomer, + const int streamId, const OHOS::Camera::StreamIntent intent) +{ + constexpr uint32_t DATA_SPACE = 8; // picture dataspace + constexpr uint32_t TUNNEL_MODE = 5; // tunnel mode + constexpr uint32_t BUFFER_QUEUE_SIZE = 8; // set bufferQueue size + if (intent == OHOS::Camera::PREVIEW) { + streamInfo->width_ = PREVIEW_WIDTH; + streamInfo->height_ = PREVIEW_HEIGHT; + streamInfo->format_ = PIXEL_FMT_RGBA_8888; + if (streamId == display_->streamId_preview) { + streamInfo->streamId_ = streamId; + } else if (streamId == streamId_preview_double) { + streamInfo->streamId_ = streamId; + } + } + streamInfo->datasapce_ = DATA_SPACE; + streamInfo->intent_ = intent; + streamInfo->tunneledMode_ = TUNNEL_MODE; + streamInfo->bufferQueue_ = streamCustomer->CreateProducer(); + streamInfo->bufferQueue_->SetQueueSize(BUFFER_QUEUE_SIZE); +} + +void DoublePreviewTest::CreateStream(int streamId, OHOS::Camera::StreamIntent intent) +{ + std::shared_ptr streamInfo = std::make_shared(); + if (streamInfo == nullptr) { + std::cout << "==========[test log]std::make_shared() is nullptr" << std::endl; + return; + } + if (intent == OHOS::Camera::PREVIEW) { + if (streamId == display_->streamId_preview) { + if (streamCustomerPreview_ == nullptr) { + streamCustomerPreview_ = std::make_shared(); + SetStreamInfo(streamInfo, streamCustomerPreview_, streamId, intent); + std::vector>().swap(streamInfos_); + streamInfos_.push_back(streamInfo); + } + } else if (streamId == streamId_preview_double) { + if (streamCustomerPreviewDouble_ == nullptr) { + streamCustomerPreviewDouble_ = std::make_shared(); + SetStreamInfo(streamInfo, streamCustomerPreviewDouble_, streamId, intent); + std::vector>().swap(streamInfos_); + streamInfos_.push_back(streamInfo); + } + } + } + result_ = display_->streamOperator->CreateStreams(streamInfos_); + EXPECT_EQ(false, result_!= OHOS::Camera::NO_ERROR); + if (result_ == OHOS::Camera::NO_ERROR) { + std::cout << "==========[test log]CreateStreams success." << std::endl; + } else { + std::cout << "==========[test log]CreateStreams fail, result_ = " << result_ << std::endl; + } +} + +void DoublePreviewTest::CommitStream() +{ + result_ = display_->streamOperator->CommitStreams(OHOS::Camera::NORMAL, display_->ability); + EXPECT_EQ(false, result_ != OHOS::Camera::NO_ERROR); + if (result_ == OHOS::Camera::NO_ERROR) { + std::cout << "==========[test log]CommitStreams preview success." << std::endl; + } else { + std::cout << "==========[test log]CommitStreams preview fail, result_ = " << result_ << std::endl; + } +} + +void DoublePreviewTest::StartCapture(int streamId, int captureId, bool shutterCallback, bool isStreaming) +{ + captureInfo_ = std::make_shared(); + captureInfo_->streamIds_ = {streamId}; + captureInfo_->captureSetting_ = display_->ability; + captureInfo_->enableShutterCallback_ = shutterCallback; + constexpr uint32_t SLEEP_SECOND_TWO = 2; // sleep two second + result_ = display_->streamOperator->Capture(captureId, captureInfo_, isStreaming); + EXPECT_EQ(true, result_ == OHOS::Camera::NO_ERROR); + if (result_ == OHOS::Camera::NO_ERROR) { + std::cout << "==========[test log]check Capture: Capture success, " << captureId << std::endl; + } else { + std::cout << "==========[test log]check Capture: Capture fail, result_ = " << result_ << captureId << std::endl; + } + if (captureId == display_->captureId_preview) { + streamCustomerPreview_->ReceiveFrameOn([this](void* addr, const uint32_t size) { + std::cout << "==========[test log]preview size= " << + size << std::endl; + }); + } else if (captureId == captureId_preview_double) { + streamCustomerPreviewDouble_->ReceiveFrameOn([this](void* addr, const uint32_t size) { + std::cout << "==========[test log]preview double size= " << + size << std::endl; + }); + } else { + std::cout << "==========[test log]StartCapture ignore command " << std::endl; + } + sleep(SLEEP_SECOND_TWO); +} + +void DoublePreviewTest::StopStream(std::vector &captureIds, std::vector &streamIds) +{ + if (sizeof(captureIds_) > 0) { + for (auto &captureId : captureIds_) { + if (captureId == display_->captureId_preview) { + streamCustomerPreview_->ReceiveFrameOff(); + } else if (captureId == captureId_preview_double) { + streamCustomerPreviewDouble_->ReceiveFrameOff(); + } else { + std::cout << "==========[test log]StopStream ignore command. " << std::endl; + } + } + for (auto &captureId : captureIds_) { + result_ = display_->streamOperator->CancelCapture(captureId); + EXPECT_EQ(true, result_ == OHOS::Camera::NO_ERROR); + if (result_ == OHOS::Camera::NO_ERROR) { + std::cout << "==========[test log]check Capture: CancelCapture success," << captureId << std::endl; + } else { + std::cout << "==========[test log]check Capture: CancelCapture fail, result_ = " << result_; + std::cout << "captureId = " << captureId << std::endl; + } + } + } + + if (sizeof(streamIds_) > 0) { + result_ = display_->streamOperator->ReleaseStreams(streamIds_); + EXPECT_EQ(true, result_ == OHOS::Camera::NO_ERROR); + if (result_ == OHOS::Camera::NO_ERROR) { + std::cout << "==========[test log]check Capture: ReleaseStreams success." << std::endl; + } else { + std::cout << "==========[test log]check Capture: ReleaseStreams fail, result_ = " << result_ << std::endl; + std::cout << "streamIds_ = " << streamIds_.front() << std::endl; + } + } +} + +/** + * @tc.name: double preview + * @tc.desc: Commit 2 streams together, Double preview streams, isStreaming is true. + * @tc.level: Level1 + * @tc.size: MediumTest + * @tc.type: Function + */ +static HWTEST_F(DoublePreviewTest, double_preview_001, TestSize.Level1) +{ + // Get the stream manager + display_->AchieveStreamOperator(); + + // Start stream + CreateStream(display_->streamId_preview, OHOS::Camera::PREVIEW); + CreateStream(streamId_preview_double, OHOS::Camera::PREVIEW); + + // Commit stream + CommitStream(); + + // Get preview + StartCapture(display_->streamId_preview, display_->captureId_preview, false, true); + StartCapture(streamId_preview_double, captureId_preview_double, false, true); + + constexpr uint32_t SLEEP_SECOND_TEN = 10; // sleep ten second + sleep(SLEEP_SECOND_TEN); + + streamIds_ = {display_->streamId_preview, streamId_preview_double}; + captureIds_ = {display_->captureId_preview, captureId_preview_double}; + StopStream(captureIds_, streamIds_); +} + +/** + * @tc.name: double preview and still_capture + * @tc.desc: Commit 3 streams together, Double preview and still_capture streams, isStreaming is true. + * @tc.level: Level1 + * @tc.size: MediumTest + * @tc.type: Function + */ +static HWTEST_F(DoublePreviewTest, double_preview_002, TestSize.Level1) +{ + // Get the stream manager + display_->AchieveStreamOperator(); + + // Start stream + CreateStream(display_->streamId_preview, OHOS::Camera::PREVIEW); + CreateStream(streamId_preview_double, OHOS::Camera::PREVIEW); + display_->intents = { OHOS::Camera::STILL_CAPTURE}; + display_->StartStream(display_->intents); + + // Get preview + StartCapture(display_->streamId_preview, display_->captureId_preview, false, true); + StartCapture(streamId_preview_double, captureId_preview_double, false, true); + // add dumy exif info + constexpr double latitude = 27.987500; // dummy data: Qomolangma latitde + constexpr double longitude = 86.927500; // dummy data: Qomolangma longituude + constexpr double altitude = 8848.86; // dummy data: Qomolangma altitude + constexpr size_t entryCapacity = 100; + constexpr size_t dataCapacity = 2000; + std::shared_ptr captureSetting = + std::make_shared(entryCapacity, dataCapacity); + std::vector gps; + gps.push_back(latitude); + gps.push_back(longitude); + gps.push_back(altitude); + captureSetting->addEntry(OHOS_JPEG_GPS_COORDINATES, gps.data(), gps.size()); + + std::shared_ptr captureInfo = std::make_shared(); + captureInfo->streamIds_ = {display_->streamId_capture}; + captureInfo->captureSetting_ = captureSetting; + captureInfo->enableShutterCallback_ = false; + display_->rc = display_->streamOperator->Capture(display_->captureId_capture, captureInfo, true); + EXPECT_EQ(true, display_->rc == OHOS::Camera::NO_ERROR); + if (display_->rc == OHOS::Camera::NO_ERROR) { + std::cout << "==========[test log]check Capture: Capture success, " << display_->captureId_capture << std::endl; + } else { + std::cout << "==========[test log]check Capture: Capture fail, rc = " << display_->rc + << display_->captureId_capture << std::endl; + } + display_->streamCustomerCapture_->ReceiveFrameOn([this](void* addr, const uint32_t size) { + display_->StoreImage(addr, size); + }); + + constexpr uint32_t SLEEP_SECOND_FIVE = 5; // sleep five second + sleep(SLEEP_SECOND_FIVE); + + streamIds_ = {display_->streamId_preview, streamId_preview_double}; + captureIds_ = {display_->captureId_preview, captureId_preview_double}; + std::vector captureIds = {display_->captureId_capture}; + std::vector streamIds = {display_->streamId_capture}; + StopStream(captureIds_, streamIds_); + display_->StopStream(captureIds, streamIds); +} + +/** + * @tc.name: double preview and video + * @tc.desc: Commit 3 streams together, Double preview and video streams, isStreaming is true. + * @tc.level: Level1 + * @tc.size: MediumTest + * @tc.type: Function + */ +static HWTEST_F(DoublePreviewTest, double_preview_003, TestSize.Level1) +{ + // Get the stream manager + display_->AchieveStreamOperator(); + + // Start stream + CreateStream(display_->streamId_preview, OHOS::Camera::PREVIEW); + CreateStream(streamId_preview_double, OHOS::Camera::PREVIEW); + display_->intents = { OHOS::Camera::VIDEO}; + display_->StartStream(display_->intents); + + // Get preview + StartCapture(display_->streamId_preview, display_->captureId_preview, false, true); + StartCapture(streamId_preview_double, captureId_preview_double, false, true); + display_->StartCapture(display_->streamId_video, display_->captureId_video, false, true); + + constexpr uint32_t SLEEP_SECOND_FIVE = 5; // sleep five second + sleep(SLEEP_SECOND_FIVE); + + streamIds_ = {display_->streamId_preview, streamId_preview_double}; + captureIds_ = {display_->captureId_preview, captureId_preview_double}; + std::vector captureIds = {display_->captureId_video}; + std::vector streamIds = {display_->streamId_video}; + StopStream(captureIds_, streamIds_); + display_->StopStream(captureIds, streamIds); +} -- Gitee