1 /* 2 * Copyright (c) 2021 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef UTEST_CAMERA_HOST_IMPL_TEST_H 17 #define UTEST_CAMERA_HOST_IMPL_TEST_H 18 19 #include "utest_camera_hdi_base.h" 20 21 class StreamOperatorImplTest : public CameraHdiBaseTest { 22 public: 23 static void SetUpTestCase(void); 24 static void TearDownTestCase(void); 25 26 void SetUp(void); 27 void TearDown(void); 28 class TestBufferConsumerListener : public IBufferConsumerListener { 29 public: OnBufferAvailable()30 void OnBufferAvailable() 31 { 32 } 33 TestBufferConsumerListener()34 TestBufferConsumerListener() 35 { 36 } 37 ~TestBufferConsumerListener()38 ~TestBufferConsumerListener() 39 { 40 } 41 }; 42 #ifdef CAMERA_BUILT_ON_OHOS_LITE 43 class StreamConsumer { 44 public: CreateProducer(std::function<void (OHOS::SurfaceBuffer *)> callback)45 std::shared_ptr<OHOS::Surface> CreateProducer(std::function<void(OHOS::SurfaceBuffer*)> callback) 46 { 47 consumer_ = std::shared_ptr<OHOS::Surface>(OHOS::Surface::CreateSurface()); 48 if (consumer_ == nullptr) { 49 return nullptr; 50 } 51 52 callback_ = callback; 53 54 consumerThread_ = new std::thread([this] { 55 while (running_ == true) { 56 OHOS::SurfaceBuffer* buffer = consumer_->AcquireBuffer(); 57 if (buffer != nullptr) { 58 if (callback_ != nullptr) { 59 callback_(buffer); 60 } 61 consumer_->ReleaseBuffer(buffer); 62 } 63 } 64 }); 65 66 return consumer_; 67 } 68 ~StreamConsumer()69 ~StreamConsumer() 70 { 71 running_ = false; 72 if (consumerThread_ != nullptr) { 73 consumerThread_->join(); 74 delete consumerThread_; 75 } 76 } 77 78 private: 79 bool running_ = true; 80 std::shared_ptr<OHOS::Surface> consumer_ = nullptr; 81 std::thread* consumerThread_ = nullptr; 82 std::function<void(OHOS::SurfaceBuffer*)> callback_ = nullptr; 83 }; 84 85 #else 86 class StreamConsumer { 87 public: CreateProducer(std::function<void (void *,uint32_t)> callback)88 OHOS::sptr<OHOS::IBufferProducer> CreateProducer(std::function<void(void*, uint32_t)> callback) 89 { 90 consumer_ = OHOS::Surface::CreateSurfaceAsConsumer(); 91 if (consumer_ == nullptr) { 92 return nullptr; 93 } 94 sptr<IBufferConsumerListener> listener = new TestBufferConsumerListener(); 95 consumer_->RegisterConsumerListener(listener); 96 97 auto producer = consumer_->GetProducer(); 98 CAMERA_LOGI("%{public}s, create a buffer queue producer %{public}p", __FUNCTION__, producer.GetRefPtr()); 99 100 if (producer == nullptr) { 101 return nullptr; 102 } 103 callback_ = callback; 104 105 consumerThread_ = new std::thread([this] { 106 int32_t flushFence = 0; 107 int64_t timestamp = 0; 108 OHOS::Rect damage; 109 while (running_ == true) { 110 OHOS::sptr<OHOS::SurfaceBuffer> buffer = nullptr; 111 consumer_->AcquireBuffer(buffer, flushFence, timestamp, damage); 112 if (buffer != nullptr) { 113 void* addr = buffer->GetVirAddr(); 114 uint32_t size = buffer->GetSize(); 115 if (callback_ != nullptr) { 116 callback_(addr, size); 117 } 118 consumer_->ReleaseBuffer(buffer, -1); 119 } 120 } 121 }); 122 123 return producer; 124 } ~StreamConsumer()125 ~StreamConsumer() 126 { 127 running_ = false; 128 if (consumerThread_ != nullptr) { 129 consumerThread_->join(); 130 delete consumerThread_; 131 } 132 } 133 134 private: 135 bool running_ = true; 136 OHOS::sptr<OHOS::Surface> consumer_ = nullptr; 137 std::thread* consumerThread_ = nullptr; 138 std::function<void(void*, uint32_t)> callback_ = nullptr; 139 }; 140 #endif 141 142 private: 143 void Init(); 144 void OnError(HDI::Camera::V1_0::ErrorType type, int32_t errorMsg); 145 void OnResult(uint64_t timestamp, const std::shared_ptr<CameraMetadata>& result); 146 void ForkProcess(); 147 void StopProcess(); 148 }; 149 150 #endif /* UTEST_CAMERA_HOST_IMPL_TEST_H */ 151