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 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 OHOS_DCAMERA_CLIENT_DEMO_H
17 #define OHOS_DCAMERA_CLIENT_DEMO_H
18 
19 #include <fstream>
20 
21 #include "anonymous_string.h"
22 #include "camera_device_ability_items.h"
23 #include "camera_input.h"
24 #include "camera_manager.h"
25 #include "camera_metadata_operator.h"
26 #include "camera_output_capability.h"
27 #include "capture_input.h"
28 #include "capture_output.h"
29 #include "capture_session.h"
30 #include "dcamera_capture_info_cmd.h"
31 #include "dcamera_utils_tools.h"
32 #include "distributed_camera_constants.h"
33 #include "distributed_camera_errno.h"
34 #include "distributed_hardware_log.h"
35 #include "metadata_utils.h"
36 #include "photo_output.h"
37 #include "preview_output.h"
38 #include "surface.h"
39 #include "video_output.h"
40 
41 namespace OHOS {
42 namespace DistributedHardware {
43 class DemoDCameraBufferConsumerListener : public IBufferConsumerListener {
44 public:
DemoDCameraBufferConsumerListener(const sptr<IConsumerSurface> & surface)45     explicit DemoDCameraBufferConsumerListener(const sptr<IConsumerSurface>& surface) : surface_(surface)
46     {
47     }
48 
OnBufferAvailable()49     void OnBufferAvailable()
50     {
51         DHLOGI("DemoDCameraBufferConsumerListener::OnBufferAvailable");
52         if (surface_ == nullptr) {
53             DHLOGE("DemoDCameraBufferConsumerListener surface is null");
54             return;
55         }
56 
57         int32_t flushFence = 0;
58         int64_t timestamp = 0;
59         OHOS::Rect damage;
60         OHOS::sptr<OHOS::SurfaceBuffer> buffer = nullptr;
61         surface_->AcquireBuffer(buffer, flushFence, timestamp, damage);
62         if (buffer == nullptr) {
63             DHLOGE("DemoDCameraBufferConsumerListener AcquireBuffer failed");
64             return;
65         }
66 
67         width_ = buffer->GetWidth();
68         height_ = buffer->GetHeight();
69         size_ = buffer->GetSize();
70         address_ = static_cast<char *>(buffer->GetVirAddr());
71         buffer->GetExtraData()->ExtraGet("dataSize", dataSize_);
72 
73 #ifdef DCAMERA_COMMON
74         actualSize_ = width_ * height_ * RGB_BYTES_PER_PIXEL;
75 #else
76         actualSize_ = width_ * height_ * YUV_BYTES_PER_PIXEL / Y2UV_RATIO;
77 #endif
78 
79         SaveFile();
80         surface_->ReleaseBuffer(buffer, -1);
81     }
82 
83 protected:
84     virtual void SaveFile() const = 0;
85 
86 protected:
87     constexpr static int32_t Y2UV_RATIO = 2;
88     constexpr static int32_t YUV_BYTES_PER_PIXEL = 3;
89     constexpr static int32_t RGB_BYTES_PER_PIXEL = 4;
90 
91     char *address_ = nullptr;
92     int32_t actualSize_ = 0;
93     int32_t dataSize_ = 0;
94     int32_t height_ = 0;
95     int32_t width_ = 0;
96     int32_t size_ = 0;
97     sptr<IConsumerSurface> surface_;
98 };
99 
100 class DemoDCameraPhotoSurfaceListener : public DemoDCameraBufferConsumerListener {
101 public:
DemoDCameraPhotoSurfaceListener(const sptr<IConsumerSurface> & surface)102     explicit DemoDCameraPhotoSurfaceListener(const sptr<IConsumerSurface>& surface)
103         : DemoDCameraBufferConsumerListener(surface)
104     {
105     }
106 
107 protected:
SaveFile()108     void SaveFile() const override
109     {
110         DHLOGI("DemoDCameraPhotoSurfaceListener::SaveFile width: %{public}d, height: %{public}d, size: %{public}d, "
111             "dataSize: %{public}d, actualSize: %{public}d", width_, height_, size_, dataSize_, actualSize_);
112         if ((address_ == nullptr) || (dataSize_ <= 0)) {
113             DHLOGE("DemoDCameraPhotoSurfaceListener invalid params, dataSize: %{public}d", dataSize_);
114             return;
115         }
116 
117         std::ofstream ofs;
118         std::cout << "saving photo ..." << std::endl;
119         std::string fileName = "/data/log/dcamera_photo_" + std::to_string(GetNowTimeStampMs()) + ".jpg";
120         ofs.open(fileName, std::ios::binary | std::ios::out);
121         if (!ofs.is_open()) {
122             DHLOGE("DemoDCameraPhotoSurfaceListener open file failed");
123             return;
124         }
125         ofs.write(address_, dataSize_);
126         ofs.close();
127         std::cout << "saving photo success" << std::endl;
128     }
129 };
130 
131 class DemoDCameraPreviewSurfaceListener : public DemoDCameraBufferConsumerListener {
132 public:
DemoDCameraPreviewSurfaceListener(const sptr<IConsumerSurface> & surface)133     explicit DemoDCameraPreviewSurfaceListener(const sptr<IConsumerSurface>& surface)
134         : DemoDCameraBufferConsumerListener(surface)
135     {
136     }
137 
138 protected:
SaveFile()139     void SaveFile() const override
140     {
141         DHLOGI("DemoDCameraPreviewSurfaceListener::SaveFile width: %{public}d, height: %{public}d, size: %{public}d, "
142             "dataSize: %{public}d, actualSize: %{public}d", width_, height_, size_, dataSize_, actualSize_);
143         if ((address_ == nullptr) || (actualSize_ <= 0)) {
144             DHLOGE("DemoDCameraPreviewSurfaceListener invalid params, actualSize: %{public}d", actualSize_);
145             return;
146         }
147 
148         std::ofstream ofs;
149         std::cout << "saving preview ..." << std::endl;
150         std::string resolution = std::to_string(width_) + "_" + std::to_string(height_);
151         std::string fileName = "/data/log/dcamera_preview_" + resolution + ".yuv";
152         ofs.open(fileName, std::ios::binary | std::ios::out | std::ios::app);
153         if (!ofs.is_open()) {
154             DHLOGE("DemoDCameraPreviewSurfaceListener open file failed");
155             return;
156         }
157         ofs.write(address_, actualSize_);
158         ofs.close();
159         std::cout << "saving preview success" << std::endl;
160     }
161 };
162 
163 class DemoDCameraVideoSurfaceListener : public DemoDCameraBufferConsumerListener {
164 public:
DemoDCameraVideoSurfaceListener(const sptr<IConsumerSurface> & surface)165     explicit DemoDCameraVideoSurfaceListener(const sptr<IConsumerSurface>& surface)
166         : DemoDCameraBufferConsumerListener(surface)
167     {
168     }
169 
170 protected:
SaveFile()171     void SaveFile() const override
172     {
173         DHLOGI("DemoDCameraVideoSurfaceListener::SaveFile width: %{public}d, height: %{public}d, size: %{public}d, "
174             "dataSize: %{public}d, actualSize: %{public}d", width_, height_, size_, dataSize_, actualSize_);
175         if ((address_ == nullptr) || (actualSize_ <= 0)) {
176             DHLOGE("DemoDCameraVideoSurfaceListener invalid params, actualSize: %{public}d", actualSize_);
177             return;
178         }
179 
180         std::ofstream ofs;
181         std::cout << "saving video ..." << std::endl;
182         std::string resolution = std::to_string(width_) + "_" + std::to_string(height_);
183         std::string fileName = "/data/log/dcamera_video_" + resolution + ".yuv";
184         ofs.open(fileName, std::ios::binary | std::ios::out | std::ios::app);
185         if (!ofs.is_open()) {
186             DHLOGE("DemoDCameraVideoSurfaceListener open file failed");
187             return;
188         }
189         ofs.write(address_, actualSize_);
190         ofs.close();
191         std::cout << "saving video success" << std::endl;
192     }
193 };
194 
195 class DemoDCameraPhotoCallback : public CameraStandard::PhotoStateCallback {
196 public:
OnCaptureStarted(const int32_t captureID)197     void OnCaptureStarted(const int32_t captureID) const
198     {
199         DHLOGI("DemoDCameraPhotoCallback::OnCaptureStarted captureID: %{public}d", captureID);
200     }
201 
OnCaptureStarted(const int32_t captureID,uint32_t exposureTime)202     void OnCaptureStarted(const int32_t captureID, uint32_t exposureTime) const
203     {
204         DHLOGI("DemoDCameraPhotoCallback::OnCaptureStarted captureID: %{public}d, exposureTime: %{public}u",
205             captureID, exposureTime);
206     }
207 
OnCaptureEnded(const int32_t captureID,int32_t frameCount)208     void OnCaptureEnded(const int32_t captureID, int32_t frameCount) const
209     {
210         DHLOGI("DemoDCameraPhotoCallback::OnCaptureEnded captureID: %{public}d frameCount: %{public}d",
211             captureID, frameCount);
212     }
213 
OnFrameShutter(const int32_t captureId,const uint64_t timestamp)214     void OnFrameShutter(const int32_t captureId, const uint64_t timestamp) const
215     {
216         DHLOGI("DemoDCameraPhotoCallback::OnFrameShutter captureID: %{public}d timestamp: %{public}" PRIu64,
217             captureId, timestamp);
218     }
219 
OnFrameShutterEnd(const int32_t captureId,const uint64_t timestamp)220     void OnFrameShutterEnd(const int32_t captureId, const uint64_t timestamp) const
221     {
222         DHLOGI("DemoDCameraPhotoCallback::OnFrameShutterEnd captureID: %{public}d timestamp: %{public}" PRIu64,
223             captureId, timestamp);
224     }
225 
OnCaptureReady(const int32_t captureId,const uint64_t timestamp)226     void OnCaptureReady(const int32_t captureId, const uint64_t timestamp) const
227     {
228         DHLOGI("DemoDCameraPhotoCallback::OnFrameShutterEnd captureID: %{public}d timestamp: %{public}" PRIu64,
229             captureId, timestamp);
230     }
231 
OnEstimatedCaptureDuration(const int32_t duration)232     void OnEstimatedCaptureDuration(const int32_t duration) const
233     {
234         DHLOGI("DemoDCameraPhotoCallback::OnEstimatedCaptureDuration duration: %{public}d", duration);
235     }
236 
OnCaptureError(const int32_t captureId,const int32_t errorCode)237     void OnCaptureError(const int32_t captureId, const int32_t errorCode) const
238     {
239         DHLOGI("DemoDCameraPhotoCallback::OnCaptureError captureID: %{public}d errorCode: %{public}d",
240             captureId, errorCode);
241     }
242 };
243 
244 class DemoDCameraPreviewCallback : public CameraStandard::PreviewStateCallback {
245 public:
OnFrameStarted()246     void OnFrameStarted() const
247     {
248         DHLOGI("DemoDCameraPreviewCallback::OnFrameStarted.");
249     }
250 
OnFrameEnded(const int32_t frameCount)251     void OnFrameEnded(const int32_t frameCount) const
252     {
253         DHLOGI("DemoDCameraPreviewCallback::OnFrameEnded frameCount: %{public}d", frameCount);
254     }
255 
OnError(const int32_t errorCode)256     void OnError(const int32_t errorCode) const
257     {
258         DHLOGI("DemoDCameraPreviewCallback::OnError errorCode: %{public}d", errorCode);
259     }
260 
OnSketchStatusDataChanged(const CameraStandard::SketchStatusData & statusData)261     void OnSketchStatusDataChanged(const CameraStandard::SketchStatusData& statusData) const
262     {
263         DHLOGI("DemoDCameraPreviewCallback::OnSketchStatusDataChanged.");
264     }
265 };
266 
267 class DemoDCameraVideoCallback : public CameraStandard::VideoStateCallback {
268 public:
OnFrameStarted()269     void OnFrameStarted() const
270     {
271         DHLOGI("DemoDCameraVideoCallback::OnFrameStarted.");
272     }
273 
OnFrameEnded(const int32_t frameCount)274     void OnFrameEnded(const int32_t frameCount) const
275     {
276         DHLOGI("DemoDCameraVideoCallback::OnFrameEnded frameCount: %{public}d", frameCount);
277     }
278 
OnError(const int32_t errorCode)279     void OnError(const int32_t errorCode) const
280     {
281         DHLOGI("DemoDCameraVideoCallback::OnError errorCode: %{public}d", errorCode);
282     }
283 };
284 
285 class DemoDCameraInputCallback : public CameraStandard::ErrorCallback {
286 public:
OnError(const int32_t errorType,const int32_t errorMsg)287     void OnError(const int32_t errorType, const int32_t errorMsg) const
288     {
289         DHLOGI("DemoDCameraInputCallback::OnError errorType: %{public}d errorMsg: %{public}d", errorType, errorMsg);
290     }
291 };
292 
293 class DemoDCameraManagerCallback : public CameraStandard::CameraManagerCallback {
294 public:
OnCameraStatusChanged(const CameraStandard::CameraStatusInfo & cameraStatusInfo)295     void OnCameraStatusChanged(const CameraStandard::CameraStatusInfo &cameraStatusInfo) const
296     {
297         DHLOGI("DemoDCameraManagerCallback::OnCameraStatusChanged cameraStatus: %{public}d",
298             cameraStatusInfo.cameraStatus);
299     }
300 
OnFlashlightStatusChanged(const std::string & cameraID,const CameraStandard::FlashStatus flashStatus)301     void OnFlashlightStatusChanged(const std::string &cameraID,
302         const CameraStandard::FlashStatus flashStatus) const
303     {
304         DHLOGI("DemoDCameraManagerCallback::OnFlashlightStatusChanged cameraID: %{public}s, flashStatus: %{public}d",
305             GetAnonyString(cameraID).c_str(), flashStatus);
306     }
307 };
308 
309 class DemoDCameraSessionCallback : public CameraStandard::SessionCallback, public CameraStandard::FocusCallback {
310 public:
OnError(int32_t errorCode)311     void OnError(int32_t errorCode)
312     {
313         DHLOGI("DemoDCameraSessionCallback::OnError errorCode: %{public}d", errorCode);
314     }
315 
OnFocusState(FocusState state)316     void OnFocusState(FocusState state)
317     {
318         DHLOGI("DemoDCameraSessionCallback::OnFocusState state: %{public}d", state);
319     }
320 };
321 
322 int32_t InitCameraStandard(OHOS::CameraStandard::CameraPosition position);
323 void InitCaptureInfo(int32_t width, int32_t height);
324 void InitPhotoOutput(void);
325 void InitPreviewOutput(void);
326 void InitVideoOutput(void);
327 void ConfigCaptureSession(void);
328 void ReleaseResource(void);
329 int32_t Capture();
330 int32_t Video();
331 std::shared_ptr<OHOS::CameraStandard::PhotoCaptureSetting> ConfigPhotoCaptureSetting();
332 void ConfigFocusFlashAndExposure(bool isVideo);
333 int32_t GetPreviewProfiles(std::vector<OHOS::CameraStandard::Size> &previewResolution);
334 bool IsValid(const OHOS::CameraStandard::Size& size);
335 } // namespace DistributedHardware
336 } // namespace OHOS
337 #endif // OHOS_DCAMERA_CLIENT_DEMO_H