1/*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file expected 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 HDI_COMMON_H
17#define HDI_COMMON_H
18
19#include <stdlib.h>
20#include <thread>
21#include <iostream>
22#include <unistd.h>
23#ifdef CAMERA_UT_TEST
24    #include <gtest/gtest.h>
25#endif
26#include <sys/time.h>
27#include <map>
28#include <string>
29#include <vector>
30#include <fcntl.h>
31#include "camera.h"
32#include "v1_0/types.h"
33#include "metadata_utils.h"
34#include "v1_0/icamera_host.h"
35#include "v1_0/icamera_device.h"
36#include "v1_0/istream_operator.h"
37#include "v1_0/camera_host_proxy.h"
38#include "v1_0/ioffline_stream_operator.h"
39#include "display_format.h"
40#include "iconsumer_surface.h"
41
42namespace OHOS::Camera {
43enum CameraUtConstants {
44    UT_SLEEP_TIME = 2,
45    UT_SECOND_TIMES = 3,
46    UT_SECOND_TIMES_MAX = 100,
47    UT_TUNNEL_MODE = 5,
48    UT_DATA_SIZE = 8,
49    UT_PREVIEW_SIZE = 3112960,
50    UT_MICROSECOND_TIMES = 500000,
51};
52
53enum ImageDataSaveSwitch {
54    SWITCH_OFF,
55    SWITCH_ON,
56};
57using namespace OHOS::HDI::Camera::V1_0;
58class HdiCommon {
59public:
60    void Init();
61    void Open();
62    void Close();
63    void GetCameraMetadata();
64    void StartStream(std::vector<StreamIntent> intents);
65    void DefaultPreview(std::shared_ptr<StreamInfo> &infos);
66    void DefaultCapture(std::shared_ptr<StreamInfo> &infos);
67    void DefaultInfosPreview(std::shared_ptr<StreamInfo> &infos);
68    void DefaultInfosCapture(std::shared_ptr<StreamInfo> &infos);
69    void DefaultInfosVideo(std::shared_ptr<StreamInfo> &infos);
70    void DefaultInfosAnalyze(std::shared_ptr<StreamInfo> &infos);
71    uint64_t GetCurrentLocalTimeStamp();
72    int32_t DumpImageFile(int streamId, std::string suffix, const void* buffer, int32_t size);
73    void StartCapture(int streamId, int captureId, bool shutterCallback, bool isStreaming);
74    void StopStream(std::vector<int>& captureIds, std::vector<int>& streamIds);
75    OHOS::sptr<OHOS::Camera::ICameraHost> service = nullptr;
76    OHOS::sptr<ICameraDevice> cameraDevice = nullptr;
77    OHOS::sptr<IStreamOperatorCallback> streamOperatorCallback = nullptr;
78    OHOS::sptr<ICameraHostCallback> hostCallback = nullptr;
79    OHOS::sptr<IStreamOperator> streamOperator = nullptr;
80    class DemoCameraDeviceCallback;
81    OHOS::sptr<DemoCameraDeviceCallback> deviceCallback = nullptr;
82    std::vector<StreamInfo> streamInfos;
83    std::shared_ptr<StreamInfo> streamInfo = nullptr;
84    std::shared_ptr<StreamInfo> streamInfoSnapshot = nullptr;
85    std::shared_ptr<StreamInfo> streamInfoCapture = nullptr;
86    std::shared_ptr<StreamInfo> streamInfoAnalyze = nullptr;
87    std::shared_ptr<StreamInfo> streamInfoPre = nullptr;
88    std::shared_ptr<StreamInfo> streamInfoVideo = nullptr;
89    std::shared_ptr<CaptureInfo> captureInfo = nullptr;
90    int previewFormat = PIXEL_FMT_YCRCB_420_SP;
91    int videoFormat = PIXEL_FMT_YCRCB_420_SP;
92    int snapshotFormat = PIXEL_FMT_YCRCB_420_SP;
93    int analyzeFormat = PIXEL_FMT_YCRCB_420_SP;
94    int videoEncodeType = ENCODE_TYPE_H265;
95    int streamIdPreview = 100;
96    int streamIdCapture = 101;
97    int captureWidth = 1280;
98    int captureHeight = 960;
99    int captureIdPreview = 2000;
100    int previewWidth = 1920;
101    int previewHeight = 1080;
102    int captureIdCapture = 2010;
103    int captureIdVideo = 2020;
104    int streamIdVideo = 102;
105    int videoHeight = 1080;
106    int videoWidth = 1920;
107    int analyzeWidth = 1920;
108    int analyzeHeight = 1080;
109    int snapshotWidth = 4160;
110    int snapshotHeight = 3120;
111    int streamIdAnalyze = 103;
112    int usbCamera_previewWidth = 640;
113    int usbCamera_previewHeight = 480;
114    int usbCamera_videoWidth = 1280;
115    int usbCamera_videoHeight = 960;
116    int usbCamera_captureWidth = 1280;
117    int usbCamera_captureHeight = 960;
118    int usbCamera_analyzeWidth = 640;
119    int usbCamera_analyzeHeight = 480;
120    int usbCamera_previewFormat = PIXEL_FMT_RGBA_8888;
121    int usbCamera_videoFormat = PIXEL_FMT_YCRCB_420_SP;
122    int usbCamera_snapshotFormat = PIXEL_FMT_RGBA_8888;
123    int usbCamera_analyzeFormat = PIXEL_FMT_RGBA_8888;
124    int usbCamera_videoEncodeType = ENCODE_TYPE_H264;
125    std::vector<int> captureIds;
126    std::vector<int> streamIds;
127    int32_t imageDataSaveSwitch = SWITCH_OFF;
128    uint32_t itemCapacity = 100;
129    uint32_t dataCapacity = 2000;
130    uint32_t dataCount = 1;
131
132    int32_t rc;
133    bool status;
134    std::vector<std::string> cameraIds;
135    std::vector<uint8_t> abilityVec = {};
136    std::shared_ptr<CameraMetadata> ability = nullptr;
137    std::vector<StreamIntent> intents;
138    class StreamConsumer;
139    std::map<OHOS::Camera::StreamIntent, std::shared_ptr<StreamConsumer>> consumerMap_ = {};
140
141    class TestBufferConsumerListener : public OHOS::IBufferConsumerListener {
142    public:
143        TestBufferConsumerListener() {}
144        ~TestBufferConsumerListener() {}
145        void OnBufferAvailable()
146        {
147            hasAvailablebuffer = true;
148        }
149        bool checkBufferAvailable()
150        {
151            if (hasAvailablebuffer) {
152                hasAvailablebuffer = false;
153                return true;
154            }
155            return false;
156        }
157    private:
158        bool hasAvailablebuffer = false;
159    };
160
161    class StreamConsumer {
162    public:
163        void CalculateFps(int64_t timestamp, int32_t streamId);
164        OHOS::sptr<OHOS::IBufferProducer> CreateProducer(std::function<void(void*, uint32_t)> callback);
165        OHOS::sptr<BufferProducerSequenceable> CreateProducerSeq(std::function<void(void*, uint32_t)> callback);
166        void TakeSnapshoe()
167        {
168            shotCount_++;
169        }
170        void WaitSnapshotEnd()
171        {
172            std::cout << "ready to wait" << std::endl;
173            std::unique_lock<std::mutex> l(l_);
174            cv_.wait(l, [this]() {return shotCount_ == 0; });
175        }
176        ~StreamConsumer()
177        {
178            running_ = false;
179            if (consumerThread_ != nullptr) {
180                consumerThread_->join();
181                delete consumerThread_;
182            }
183        }
184    public:
185        std::atomic<uint64_t> shotCount_ = 0;
186        std::mutex l_;
187        std::condition_variable cv_;
188        bool running_ = true;
189        OHOS::sptr<OHOS::IConsumerSurface> consumer_ = nullptr;
190        std::thread* consumerThread_ = nullptr;
191        std::function<void(void*, uint32_t)> callback_ = nullptr;
192        bool isFirstCalculateFps_ = false;
193        int timestampCount_ = 0;
194        int64_t intervalTimestamp_ = 0;
195        const int64_t ONESECOND_OF_MICROSECOND_UNIT = 1000000000;
196        int64_t interval_ = ONESECOND_OF_MICROSECOND_UNIT;
197    };
198
199    class DemoCameraDeviceCallback : public ICameraDeviceCallback {
200    public:
201        std::shared_ptr<CameraMetadata> resultMeta = nullptr;
202        DemoCameraDeviceCallback() = default;
203        virtual ~DemoCameraDeviceCallback() = default;
204
205        int32_t OnError(ErrorType type, int32_t errorMsg) override;
206        int32_t OnResult(uint64_t timestamp, const std::vector<uint8_t> &result) override;
207    };
208
209    using ResultCallback = std::function<void (uint64_t, const std::shared_ptr<CameraMetadata>)>;
210    static ResultCallback resultCallback_;
211
212    class TestStreamOperatorCallback : public IStreamOperatorCallback {
213    public:
214        TestStreamOperatorCallback() = default;
215        virtual ~TestStreamOperatorCallback() = default;
216        int32_t OnCaptureStarted(int32_t captureId, const std::vector<int32_t> &streamId) override;
217        int32_t OnCaptureEnded(int32_t captureId, const std::vector<CaptureEndedInfo> &infos) override;
218        int32_t OnCaptureError(int32_t captureId, const std::vector<CaptureErrorInfo> &infos) override;
219        int32_t OnFrameShutter(int32_t captureId, const std::vector<int32_t> &streamIds, uint64_t timestamp) override;
220    };
221
222    class TestCameraHostCallback : public ICameraHostCallback {
223    public:
224        TestCameraHostCallback() = default;
225        virtual ~TestCameraHostCallback() = default;
226
227        int32_t OnCameraStatus(const std::string& cameraId, CameraStatus status) override;
228        int32_t OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status) override;
229        int32_t OnCameraEvent(const std::string& cameraId, CameraEvent event) override;
230    };
231};
232}
233#endif
234