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 #ifndef CAMERA_TEST_COMMON_H 16 #define CAMERA_TEST_COMMON_H 17 18 #include <stdlib.h> 19 #include <limits.h> 20 #include <gtest/gtest.h> 21 #include <iostream> 22 #include <climits> 23 #include <sys/stat.h> 24 #include <fcntl.h> 25 #include <unistd.h> 26 #include <sys/ioctl.h> 27 #include <sys/wait.h> 28 #include <thread> 29 #include <stdio.h> 30 #include <sys/time.h> 31 #include <vector> 32 #include <map> 33 #include "utils.h" 34 #include "camera.h" 35 #include "camera_host.h" 36 #include "types.h" 37 #include <surface.h> 38 #include "idevice_manager.h" 39 #include "camera_metadata_info.h" 40 #include "ibuffer.h" 41 #include <display_type.h> 42 #include <hdf_log.h> 43 #include <osal_mem.h> 44 #include "securec.h" 45 #include "icamera_host.h" 46 #include "icamera_device.h" 47 #include "istream_operator.h" 48 #include "ioffline_stream_operator.h" 49 #include "camera_host_callback.h" 50 #include "camera_device_callback.h" 51 #include "stream_operator_callback.h" 52 #include "video_key_info.h" 53 #include "type_common.h" 54 55 namespace OHOS::Camera { 56 class Test { 57 public: 58 void Init(); 59 void Open(); 60 void Close(); 61 void GetCameraAbility(); 62 uint64_t GetCurrentLocalTimeStamp(); 63 int32_t SaveYUV(const char* type, const void* buffer, int32_t size); 64 int32_t SaveVideoFile(const char* type, const void* buffer, int32_t size, int32_t operationMode); 65 void StartStream(std::vector<Camera::StreamIntent> intents); 66 void StartCapture(int streamId, int captureId, bool shutterCallback, bool isStreaming); 67 void StopStream(std::vector<int>& captureIds, std::vector<int>& streamIds); 68 void StopOfflineStream(int captureId); 69 void GetCameraMetadata(); 70 void StopConsumer(std::vector<Camera::StreamIntent> intents); 71 void CreateStreamOperatorCallback(); 72 void CreateDeviceCallback(); 73 void CreateOfflineStreamOperatorCallback(); 74 void StreamInfoFormat(); 75 76 OHOS::sptr<StreamOperatorCallback> streamOperatorCallback = nullptr; 77 OHOS::sptr<CameraHostCallback> hostCallback = nullptr; 78 OHOS::sptr<CameraDeviceCallback> deviceCallback = nullptr; 79 OHOS::sptr<IStreamOperator> streamOperator = nullptr; 80 OHOS::sptr<Camera::IOfflineStreamOperator> offlineStreamOperator = nullptr; 81 OHOS::sptr<IStreamOperatorCallback> offlineStreamOperatorCallback = nullptr; 82 83 std::shared_ptr<OHOS::Camera::CaptureInfo> captureInfo = nullptr; 84 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos; 85 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = nullptr; 86 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo2 = nullptr; 87 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo_pre = nullptr; 88 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo_video = nullptr; 89 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo_capture = nullptr; 90 std::vector<std::string> cameraIds; 91 int streamId_preview = 1000; 92 int streamId_preview_double = 1001; 93 int streamId_capture = 1010; 94 int streamId_video = 1020; 95 int captureId_preview = 2000; 96 int captureId_preview_double = 2001; 97 int captureId_capture = 3000; 98 int captureId_video = 4000; 99 std::vector<int> captureIds; 100 std::vector<int> streamIds; 101 std::vector<Camera::StreamIntent> intents; 102 OHOS::Camera::CamRetCode rc; 103 104 #ifdef CAMERA_BUILT_ON_OHOS_LITE 105 std::shared_ptr<OHOS::Camera::CameraHost> service = nullptr; 106 std::shared_ptr<ICameraDevice> cameraDevice = nullptr; 107 #else 108 OHOS::sptr<OHOS::Camera::ICameraHost> service = nullptr; 109 OHOS::sptr<ICameraDevice> cameraDevice = nullptr; 110 #endif 111 std::shared_ptr<CameraAbility> ability = nullptr; 112 113 bool status; 114 bool onCameraStatusFlag; 115 bool onFlashlightStatusFlag; 116 bool onErrorFlag; 117 bool onResultFlag; 118 bool captureStartFlag; 119 bool captureEndFlag; 120 bool captureErrorFlag; 121 bool frameShutterFlag; 122 int previewBufCnt = 0; 123 int32_t videoFd = -1; 124 class StreamConsumer; 125 std::map<OHOS::Camera::StreamIntent, std::shared_ptr<StreamConsumer>> consumerMap_ = {}; 126 127 class TestBufferConsumerListener : public IBufferConsumerListener { 128 public: TestBufferConsumerListener()129 TestBufferConsumerListener() {} ~TestBufferConsumerListener()130 ~TestBufferConsumerListener() {} OnBufferAvailable()131 void OnBufferAvailable() {} 132 }; 133 134 class StreamConsumer { 135 public: 136 void StopConsumer(); 137 #ifdef CAMERA_BUILT_ON_OHOS_LITE 138 std::shared_ptr<OHOS::Surface> CreateProducer(std::function<void(OHOS::SurfaceBuffer* buffer)> callback); 139 #else 140 OHOS::sptr<OHOS::IBufferProducer> CreateProducer(std::function<void(void*, uint32_t)> callback); 141 #endif TakeSnapshot()142 void TakeSnapshot() 143 { 144 shotCount_++; 145 } WaitSnapshotEnd()146 void WaitSnapshotEnd() 147 { 148 std::cout << "ready to wait" << std::endl; 149 std::unique_lock<std::mutex> l(l_); 150 cv_.wait(l, [this]() { return shotCount_ == 0; }); 151 } ~StreamConsumer()152 ~StreamConsumer() 153 { 154 running_ = false; 155 if (consumerThread_ != nullptr) { 156 consumerThread_->join(); 157 delete consumerThread_; 158 } 159 } 160 public: 161 std::atomic<uint64_t> shotCount_ = 0; 162 std::mutex l_; 163 std::condition_variable cv_; 164 bool running_ = true; 165 #ifdef CAMERA_BUILT_ON_OHOS_LITE 166 std::shared_ptr<OHOS::Surface> consumer_ = nullptr; 167 std::function<void(OHOS::SurfaceBuffer*)> callback_ = nullptr; 168 #else 169 OHOS::sptr<OHOS::Surface> consumer_ = nullptr; 170 std::function<void(void*, uint32_t)> callback_ = nullptr; 171 #endif 172 std::thread* consumerThread_ = nullptr; 173 }; 174 }; 175 176 class HdiHostCallback : public CameraHostCallback { 177 public: 178 Test *test_; 179 virtual ~HdiHostCallback() = default; HdiHostCallback(Test * test)180 HdiHostCallback(Test *test) 181 { 182 test_ = test; 183 } OnCameraStatus(const std::string & cameraId,CameraStatus status)184 void OnCameraStatus(const std::string &cameraId, CameraStatus status) override 185 { 186 test_->onCameraStatusFlag = true; 187 } OnFlashlightStatus(const std::string & cameraId,FlashlightStatus status)188 void OnFlashlightStatus(const std::string &cameraId, FlashlightStatus status) override 189 { 190 test_->onFlashlightStatusFlag = true; 191 } 192 }; 193 class HdiDeviceCallback : public CameraDeviceCallback { 194 public: 195 Test *test_; 196 virtual ~HdiDeviceCallback() = default; HdiDeviceCallback(Test * test)197 HdiDeviceCallback(Test *test) 198 { 199 test_ = test; 200 } OnError(ErrorType type,int32_t errorMsg)201 void OnError(ErrorType type, int32_t errorMsg) override 202 { 203 test_->onErrorFlag = true; 204 } OnResult(uint64_t timestamp,const std::shared_ptr<CameraMetadata> & result)205 void OnResult(uint64_t timestamp, const std::shared_ptr<CameraMetadata> &result) override 206 { 207 test_->onResultFlag = true; 208 } 209 }; 210 class HdiOperatorCallback : public StreamOperatorCallback { 211 public: 212 Test *test_; 213 virtual ~HdiOperatorCallback() = default; HdiOperatorCallback(Test * test)214 HdiOperatorCallback(Test *test) 215 { 216 test_ = test; 217 } OnCaptureStarted(int32_t captureId,const std::vector<int32_t> & streamId)218 void OnCaptureStarted(int32_t captureId, const std::vector<int32_t> &streamId) override 219 { 220 test_->captureStartFlag = true; 221 } OnCaptureEnded(int32_t captureId,const std::vector<std::shared_ptr<CaptureEndedInfo>> & info)222 void OnCaptureEnded(int32_t captureId, 223 const std::vector<std::shared_ptr<CaptureEndedInfo>> &info) override 224 { 225 test_->captureEndFlag = true; 226 } OnCaptureError(int32_t captureId,const std::vector<std::shared_ptr<CaptureErrorInfo>> & info)227 void OnCaptureError(int32_t captureId, 228 const std::vector<std::shared_ptr<CaptureErrorInfo>> &info) override 229 { 230 test_->captureErrorFlag = true; 231 } OnFrameShutter(int32_t captureId,const std::vector<int32_t> & streamId,uint64_t timestamp)232 void OnFrameShutter(int32_t captureId, 233 const std::vector<int32_t> &streamId, uint64_t timestamp) override 234 { 235 test_->frameShutterFlag = true; 236 } 237 }; 238 } 239 #endif 240