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: %d, height: %d, size: %d, dataSize: %d, " + 111 "actualSize: %d", width_, height_, size_, dataSize_, actualSize_); 112 if ((address_ == nullptr) || (dataSize_ <= 0)) { 113 DHLOGE("DemoDCameraPhotoSurfaceListener invalid params, dataSize: %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: %d, height: %d, size: %d, dataSize: %d, " + 142 "actualSize: %d", width_, height_, size_, dataSize_, actualSize_); 143 if ((address_ == nullptr) || (actualSize_ <= 0)) { 144 DHLOGE("DemoDCameraPreviewSurfaceListener invalid params, actualSize: %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: %d, height: %d, size: %d, dataSize: %d, " + 174 "actualSize: %d", width_, height_, size_, dataSize_, actualSize_); 175 if ((address_ == nullptr) || (actualSize_ <= 0)) { 176 DHLOGE("DemoDCameraVideoSurfaceListener invalid params, actualSize: %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: %d", captureID); 200 } 201 OnCaptureEnded(const int32_t captureID,int32_t frameCount)202 void OnCaptureEnded(const int32_t captureID, int32_t frameCount) const 203 { 204 DHLOGI("DemoDCameraPhotoCallback::OnCaptureEnded captureID: %d frameCount: %d", captureID, frameCount); 205 } 206 OnFrameShutter(const int32_t captureId,const uint64_t timestamp)207 void OnFrameShutter(const int32_t captureId, const uint64_t timestamp) const 208 { 209 DHLOGI("DemoDCameraPhotoCallback::OnFrameShutter captureID: %d timestamp: %llu", captureId, timestamp); 210 } 211 OnCaptureError(const int32_t captureId,const int32_t errorCode)212 void OnCaptureError(const int32_t captureId, const int32_t errorCode) const 213 { 214 DHLOGI("DemoDCameraPhotoCallback::OnCaptureError captureID: %d errorCode: %d", captureId, errorCode); 215 } 216 }; 217 218 class DemoDCameraPreviewCallback : public CameraStandard::PreviewStateCallback { 219 public: OnFrameStarted()220 void OnFrameStarted() const 221 { 222 DHLOGI("DemoDCameraPreviewCallback::OnFrameStarted."); 223 } 224 OnFrameEnded(const int32_t frameCount)225 void OnFrameEnded(const int32_t frameCount) const 226 { 227 DHLOGI("DemoDCameraPreviewCallback::OnFrameEnded frameCount: %d", frameCount); 228 } 229 OnError(const int32_t errorCode)230 void OnError(const int32_t errorCode) const 231 { 232 DHLOGI("DemoDCameraPreviewCallback::OnError errorCode: %d", errorCode); 233 } 234 }; 235 236 class DemoDCameraVideoCallback : public CameraStandard::VideoStateCallback { 237 public: OnFrameStarted()238 void OnFrameStarted() const 239 { 240 DHLOGI("DemoDCameraVideoCallback::OnFrameStarted."); 241 } 242 OnFrameEnded(const int32_t frameCount)243 void OnFrameEnded(const int32_t frameCount) const 244 { 245 DHLOGI("DemoDCameraVideoCallback::OnFrameEnded frameCount: %d", frameCount); 246 } 247 OnError(const int32_t errorCode)248 void OnError(const int32_t errorCode) const 249 { 250 DHLOGI("DemoDCameraVideoCallback::OnError errorCode: %d", errorCode); 251 } 252 }; 253 254 class DemoDCameraInputCallback : public CameraStandard::ErrorCallback { 255 public: OnError(const int32_t errorType,const int32_t errorMsg)256 void OnError(const int32_t errorType, const int32_t errorMsg) const 257 { 258 DHLOGI("DemoDCameraInputCallback::OnError errorType: %d errorMsg: %d", errorType, errorMsg); 259 } 260 }; 261 262 class DemoDCameraManagerCallback : public CameraStandard::CameraManagerCallback { 263 public: OnCameraStatusChanged(const CameraStandard::CameraStatusInfo & cameraStatusInfo)264 void OnCameraStatusChanged(const CameraStandard::CameraStatusInfo &cameraStatusInfo) const 265 { 266 DHLOGI("DemoDCameraManagerCallback::OnCameraStatusChanged cameraStatus: %d", cameraStatusInfo.cameraStatus); 267 } 268 OnFlashlightStatusChanged(const std::string & cameraID,const CameraStandard::FlashStatus flashStatus)269 void OnFlashlightStatusChanged(const std::string &cameraID, 270 const CameraStandard::FlashStatus flashStatus) const 271 { 272 DHLOGI("DemoDCameraManagerCallback::OnFlashlightStatusChanged cameraID: %s, flashStatus: %d", 273 GetAnonyString(cameraID).c_str(), flashStatus); 274 } 275 }; 276 277 class DemoDCameraSessionCallback : public CameraStandard::SessionCallback, public CameraStandard::FocusCallback { 278 public: OnError(int32_t errorCode)279 void OnError(int32_t errorCode) 280 { 281 DHLOGI("DemoDCameraSessionCallback::OnError errorCode: %d", errorCode); 282 } 283 OnFocusState(FocusState state)284 void OnFocusState(FocusState state) 285 { 286 DHLOGI("DemoDCameraSessionCallback::OnFocusState state: %d", state); 287 } 288 }; 289 290 int32_t InitCameraStandard(OHOS::CameraStandard::CameraPosition position); 291 void InitCaptureInfo(int32_t width, int32_t height); 292 void InitPhotoOutput(void); 293 void InitPreviewOutput(void); 294 void InitVideoOutput(void); 295 void ConfigCaptureSession(void); 296 void ReleaseResource(void); 297 int32_t Capture(); 298 int32_t Video(); 299 std::shared_ptr<OHOS::CameraStandard::PhotoCaptureSetting> ConfigPhotoCaptureSetting(); 300 void ConfigFocusFlashAndExposure(bool isVideo); 301 int32_t GetPreviewProfiles(std::vector<OHOS::CameraStandard::Size> &previewResolution); 302 bool IsValid(const OHOS::CameraStandard::Size& size); 303 } // namespace DistributedHardware 304 } // namespace OHOS 305 #endif // OHOS_DCAMERA_CLIENT_DEMO_H