1 /*
2 * Copyright (c) 2024-2024 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 #include <unistd.h>
17 #include <sys/mman.h>
18 #include <iomanip>
19
20 #include <buffer_handle_parcel.h>
21 #include "utils/camera_log.h"
22 #include "datetime_ex.h"
23 #include "camera_server_photo_proxy.h"
24 #include "camera_surface_buffer_util.h"
25 #include "photo_proxy.h"
26
27 namespace OHOS {
28 namespace CameraStandard {
29
30 static std::string g_lastDisplayName = "";
31 static int32_t g_saveIndex = 0;
CameraServerPhotoProxy()32 CameraServerPhotoProxy::CameraServerPhotoProxy()
33 {
34 format_ = 0;
35 photoId_ = "";
36 deferredProcType_ = 0;
37 photoWidth_ = 0;
38 photoHeight_ = 0;
39 bufferHandle_ = nullptr;
40 fileDataAddr_ = nullptr;
41 fileSize_ = 0;
42 isMmaped_ = false;
43 isDeferredPhoto_ = 0;
44 isHighQuality_ = false;
45 mode_ = 0;
46 longitude_ = 0.0;
47 latitude_ = 0.0;
48 captureId_ = 0;
49 burstSeqId_ = -1;
50 burstKey_ = "";
51 isCoverPhoto_ = false;
52 imageFormat_ = 0;
53 stageVideoTaskStatus_ = 0;
54 cloudImageEnhanceFlag_ = 0;
55 }
56
~CameraServerPhotoProxy()57 CameraServerPhotoProxy::~CameraServerPhotoProxy()
58 {
59 std::lock_guard<std::mutex> lock(mutex_);
60 MEDIA_INFO_LOG("~CameraServerPhotoProxy");
61 fileDataAddr_ = nullptr;
62 fileSize_ = 0;
63 }
64
CameraFreeBufferHandle(BufferHandle * handle)65 int32_t CameraServerPhotoProxy::CameraFreeBufferHandle(BufferHandle *handle)
66 {
67 CHECK_RETURN_RET_ELOG(handle == nullptr, 0, "CameraFreeBufferHandle with nullptr handle");
68 if (handle->fd >= 0) {
69 close(handle->fd);
70 handle->fd = -1;
71 }
72 const uint32_t reserveFds = handle->reserveFds;
73 for (uint32_t i = 0; i < reserveFds; i++) {
74 if (handle->reserve[i] >= 0) {
75 close(handle->reserve[i]);
76 handle->reserve[i] = -1;
77 }
78 }
79 free(handle);
80 return 0;
81 }
82
CreateDisplayName(const std::string & suffix)83 std::string CreateDisplayName(const std::string& suffix)
84 {
85 struct tm currentTime;
86 std::string formattedTime = "";
87 if (GetSystemCurrentTime(¤tTime)) {
88 std::stringstream ss;
89 ss << prefix << std::setw(yearWidth) << std::setfill(placeholder) << currentTime.tm_year + startYear
90 << std::setw(otherWidth) << std::setfill(placeholder) << (currentTime.tm_mon + 1)
91 << std::setw(otherWidth) << std::setfill(placeholder) << currentTime.tm_mday
92 << connector << std::setw(otherWidth) << std::setfill(placeholder) << currentTime.tm_hour
93 << std::setw(otherWidth) << std::setfill(placeholder) << currentTime.tm_min
94 << std::setw(otherWidth) << std::setfill(placeholder) << currentTime.tm_sec;
95 formattedTime = ss.str();
96 } else {
97 MEDIA_ERR_LOG("Failed to get current time.");
98 }
99 if (g_lastDisplayName == formattedTime) {
100 g_saveIndex++;
101 formattedTime = formattedTime + connector + std::to_string(g_saveIndex);
102 MEDIA_INFO_LOG("CreateDisplayName is %{private}s", formattedTime.c_str());
103 return formattedTime;
104 }
105 g_lastDisplayName = formattedTime;
106 g_saveIndex = 0;
107 MEDIA_INFO_LOG("CreateDisplayName is %{private}s", formattedTime.c_str());
108 return formattedTime;
109 }
110
CreateVideoDisplayName()111 std::string CreateVideoDisplayName()
112 {
113 struct tm currentTime;
114 std::string formattedTime = "";
115 if (GetSystemCurrentTime(¤tTime)) {
116 std::stringstream ss;
117 ss << videoPrefix << std::setw(yearWidth) << std::setfill(placeholder) << currentTime.tm_year + startYear
118 << std::setw(otherWidth) << std::setfill(placeholder) << (currentTime.tm_mon + 1)
119 << std::setw(otherWidth) << std::setfill(placeholder) << currentTime.tm_mday
120 << connector << std::setw(otherWidth) << std::setfill(placeholder) << currentTime.tm_hour
121 << std::setw(otherWidth) << std::setfill(placeholder) << currentTime.tm_min
122 << std::setw(otherWidth) << std::setfill(placeholder) << currentTime.tm_sec;
123 formattedTime = ss.str();
124 } else {
125 MEDIA_ERR_LOG("Failed to get current time.");
126 }
127 if (g_lastDisplayName == formattedTime) {
128 g_saveIndex++;
129 formattedTime = formattedTime + connector + std::to_string(g_saveIndex);
130 MEDIA_INFO_LOG("CreateVideoDisplayName is %{private}s", formattedTime.c_str());
131 return formattedTime;
132 }
133 g_lastDisplayName = formattedTime;
134 g_saveIndex = 0;
135 MEDIA_INFO_LOG("CreateVideoDisplayName is %{private}s", formattedTime.c_str());
136 return formattedTime;
137 }
138
SetDisplayName(std::string displayName)139 void CameraServerPhotoProxy::SetDisplayName(std::string displayName)
140 {
141 displayName_ = displayName;
142 }
143
ReadFromParcel(MessageParcel & parcel)144 void CameraServerPhotoProxy::ReadFromParcel(MessageParcel &parcel)
145 {
146 std::lock_guard<std::mutex> lock(mutex_);
147 photoId_ = parcel.ReadString();
148 deferredProcType_ = parcel.ReadInt32();
149 isDeferredPhoto_ = parcel.ReadInt32();
150 format_ = parcel.ReadInt32();
151 photoWidth_ = parcel.ReadInt32();
152 photoHeight_ = parcel.ReadInt32();
153 isHighQuality_ = parcel.ReadBool();
154 fileSize_ = parcel.ReadUint64();
155 latitude_ = parcel.ReadDouble();
156 longitude_ = parcel.ReadDouble();
157 captureId_ = parcel.ReadInt32();
158 burstSeqId_ = parcel.ReadInt32();
159 imageFormat_ = parcel.ReadInt32();
160 cloudImageEnhanceFlag_ = parcel.ReadUint32();
161 bufferHandle_ = ReadBufferHandle(parcel);
162 MEDIA_INFO_LOG("CameraServerPhotoProxy::ReadFromParcel");
163 }
164
GetServerPhotoProxyInfo(sptr<SurfaceBuffer> & surfaceBuffer)165 void CameraServerPhotoProxy::GetServerPhotoProxyInfo(sptr<SurfaceBuffer>& surfaceBuffer)
166 {
167 MEDIA_INFO_LOG("GetServerPhotoProxyInfo E");
168 CHECK_RETURN_ELOG(surfaceBuffer == nullptr, "surfaceBuffer is null");
169 std::lock_guard<std::mutex> lock(mutex_);
170 captureId_ = CameraSurfaceBufferUtil::GetCaptureId(surfaceBuffer);
171 BufferHandle *bufferHandle = surfaceBuffer->GetBufferHandle();
172 bufferHandle_ = bufferHandle;
173 CHECK_PRINT_ELOG(bufferHandle == nullptr, "invalid bufferHandle");
174 format_ = bufferHandle->format;
175 std::string imageIdStr = std::to_string(CameraSurfaceBufferUtil::GetImageId(surfaceBuffer));
176 photoId_ = imageIdStr;
177 photoWidth_ = CameraSurfaceBufferUtil::GetDataWidth(surfaceBuffer);
178 photoHeight_ = CameraSurfaceBufferUtil::GetDataHeight(surfaceBuffer);
179 deferredProcType_ = CameraSurfaceBufferUtil::GetDeferredProcessingType(surfaceBuffer);
180 isDeferredPhoto_ = 1;
181 bool isHighQuality = (CameraSurfaceBufferUtil::GetIsDegradedImage(surfaceBuffer) == 0);
182 isHighQuality_ = isHighQuality;
183 if (isHighQuality) { // get cloudImageEnhanceFlag for 100 picture
184 cloudImageEnhanceFlag_ = CameraSurfaceBufferUtil::GetCloudImageEnhanceFlag(surfaceBuffer);
185 }
186 uint64_t size = static_cast<uint64_t>(surfaceBuffer->GetSize());
187 int32_t extraDataSize = CameraSurfaceBufferUtil::GetDataSize(surfaceBuffer);
188 if (extraDataSize <= 0) {
189 MEDIA_INFO_LOG("ExtraGet dataSize Ok, but size <= 0");
190 } else if (static_cast<uint64_t>(extraDataSize) > size) {
191 MEDIA_INFO_LOG("ExtraGet dataSize Ok,but dataSize %{public}d is bigger than bufferSize %{public}" PRIu64,
192 extraDataSize, size);
193 } else {
194 MEDIA_INFO_LOG("ExtraGet dataSize %{public}d", extraDataSize);
195 size = static_cast<uint64_t>(extraDataSize);
196 }
197 fileSize_ = size;
198 burstSeqId_ = CameraSurfaceBufferUtil::GetBurstSequenceId(surfaceBuffer);
199 imageFormat_ = CameraSurfaceBufferUtil::GetDeferredImageFormat(surfaceBuffer);
200 latitude_ = 0.0;
201 longitude_ = 0.0;
202 MEDIA_INFO_LOG("GetServerPhotoProxyInfo X,cId:%{public}d pId:%{public}s w:%{public}d h:%{public}d f:%{public}d "
203 "s:%{public}zu dT:%{public}d iH:%{public}d",
204 captureId_, photoId_.c_str(), photoWidth_, photoHeight_, format_, fileSize_, deferredProcType_, isHighQuality_);
205 }
206
GetCaptureId()207 int32_t CameraServerPhotoProxy::GetCaptureId()
208 {
209 MEDIA_INFO_LOG("CameraServerPhotoProxy::GetCaptureId captureId:%{public}d", captureId_);
210 std::lock_guard<std::mutex> lock(mutex_);
211 return captureId_;
212 }
213
GetBurstSeqId()214 int32_t CameraServerPhotoProxy::GetBurstSeqId()
215 {
216 MEDIA_INFO_LOG("CameraServerPhotoProxy::GetBurstSeqId burstSeqId:%{public}d", burstSeqId_);
217 std::lock_guard<std::mutex> lock(mutex_);
218 return burstSeqId_;
219 }
220
GetPhotoId()221 std::string CameraServerPhotoProxy::GetPhotoId()
222 {
223 MEDIA_INFO_LOG("CameraServerPhotoProxy::GetPhotoId photoId:%{public}s", photoId_.c_str());
224 std::lock_guard<std::mutex> lock(mutex_);
225 return photoId_;
226 }
227
GetDeferredProcType()228 Media::DeferredProcType CameraServerPhotoProxy::GetDeferredProcType()
229 {
230 MEDIA_DEBUG_LOG("CameraServerPhotoProxy::GetDeferredProcType");
231 std::lock_guard<std::mutex> lock(mutex_);
232 if (deferredProcType_ == 0) {
233 return Media::DeferredProcType::BACKGROUND;
234 } else {
235 return Media::DeferredProcType::OFFLINE;
236 }
237 }
238
GetFileDataAddr()239 void* CameraServerPhotoProxy::GetFileDataAddr()
240 {
241 MEDIA_INFO_LOG("CameraServerPhotoProxy::GetFileDataAddr");
242 std::lock_guard<std::mutex> lock(mutex_);
243 CHECK_RETURN_RET_ELOG(
244 bufferHandle_ == nullptr, fileDataAddr_, "CameraServerPhotoProxy::GetFileDataAddr bufferHandle_ is nullptr");
245 if (!isMmaped_) {
246 MEDIA_INFO_LOG("CameraServerPhotoProxy::GetFileDataAddr mmap");
247 fileDataAddr_ = mmap(nullptr, bufferHandle_->size, PROT_READ, MAP_SHARED, bufferHandle_->fd, 0);
248 CHECK_RETURN_RET_ELOG(
249 fileDataAddr_ == MAP_FAILED, fileDataAddr_, "CameraServerPhotoProxy::GetFileDataAddr mmap failed");
250 isMmaped_ = true;
251 } else {
252 MEDIA_ERR_LOG("CameraServerPhotoProxy::GetFileDataAddr mmap failed");
253 }
254 return fileDataAddr_;
255 }
256
GetFileSize()257 size_t CameraServerPhotoProxy::GetFileSize()
258 {
259 MEDIA_INFO_LOG("CameraServerPhotoProxy::GetFileSize");
260 std::lock_guard<std::mutex> lock(mutex_);
261 return fileSize_;
262 }
263
GetWidth()264 int32_t CameraServerPhotoProxy::GetWidth()
265 {
266 return photoWidth_;
267 }
268
GetHeight()269 int32_t CameraServerPhotoProxy::GetHeight()
270 {
271 return photoHeight_;
272 }
273
GetFormat()274 PhotoFormat CameraServerPhotoProxy::GetFormat()
275 {
276 auto iter = formatMap.find(imageFormat_);
277 return iter != formatMap.end() ? iter->second : Media::PhotoFormat::RGBA;
278 }
279
GetPhotoQuality()280 PhotoQuality CameraServerPhotoProxy::GetPhotoQuality()
281 {
282 return isHighQuality_ ? Media::PhotoQuality::HIGH : Media::PhotoQuality::LOW;
283 }
284
Release()285 void CameraServerPhotoProxy::Release()
286 {
287 MEDIA_INFO_LOG("CameraServerPhotoProxy release enter");
288 bool isMmappedAndBufferValid = isMmaped_ && bufferHandle_ != nullptr;
289 if (isMmappedAndBufferValid) {
290 munmap(fileDataAddr_, bufferHandle_->size);
291 } else {
292 MEDIA_ERR_LOG("CameraServerPhotoProxy munmap failed");
293 }
294 }
295
GetTitle()296 std::string CameraServerPhotoProxy::GetTitle()
297 {
298 return displayName_;
299 }
300
GetExtension()301 std::string CameraServerPhotoProxy::GetExtension()
302 {
303 std::string suffix = suffixJpeg;
304 if (isVideo_) {
305 suffix = suffixMp4;
306 return suffix;
307 }
308 switch (GetFormat()) {
309 case PhotoFormat::HEIF : {
310 suffix = suffixHeif;
311 break;
312 }
313 case PhotoFormat::DNG : {
314 suffix = suffixDng;
315 break;
316 }
317 default: {
318 suffix = suffixJpeg;
319 break;
320 }
321 }
322 return suffix;
323 }
324
SetLatitude(double latitude)325 void CameraServerPhotoProxy::SetLatitude(double latitude)
326 {
327 latitude_ = latitude;
328 }
SetLongitude(double longitude)329 void CameraServerPhotoProxy::SetLongitude(double longitude)
330 {
331 longitude_ = longitude;
332 }
333
GetLatitude()334 double CameraServerPhotoProxy::GetLatitude()
335 {
336 return latitude_;
337 }
GetLongitude()338 double CameraServerPhotoProxy::GetLongitude()
339 {
340 return longitude_;
341 }
GetShootingMode()342 int32_t CameraServerPhotoProxy::GetShootingMode()
343 {
344 auto iter = modeMap.find(mode_);
345 return iter != modeMap.end() ? iter->second : 0;
346 }
SetShootingMode(int32_t mode)347 void CameraServerPhotoProxy::SetShootingMode(int32_t mode)
348 {
349 mode_ = mode;
350 }
351
GetBurstKey()352 std::string CameraServerPhotoProxy::GetBurstKey()
353 {
354 MEDIA_DEBUG_LOG("CameraServerPhotoProxy GetBurstKey");
355 return burstKey_;
356 }
357
IsCoverPhoto()358 bool CameraServerPhotoProxy::IsCoverPhoto()
359 {
360 MEDIA_DEBUG_LOG("CameraServerPhotoProxy IsCoverPhoto");
361 return isCoverPhoto_;
362 }
363
SetBurstInfo(std::string burstKey,bool isCoverPhoto)364 void CameraServerPhotoProxy::SetBurstInfo(std::string burstKey, bool isCoverPhoto)
365 {
366 MEDIA_INFO_LOG("CameraServerPhotoProxy SetBurstInfo");
367 burstKey_ = burstKey;
368 isCoverPhoto_ = isCoverPhoto;
369 isHighQuality_ = true; // tell media lib disable deferred photo
370 }
371
GetCloudImageEnhanceFlag()372 uint32_t CameraServerPhotoProxy::GetCloudImageEnhanceFlag()
373 {
374 MEDIA_DEBUG_LOG("%{public}s get value: %{public}u", __FUNCTION__, cloudImageEnhanceFlag_);
375 return cloudImageEnhanceFlag_;
376 }
377
SetIsVideo(bool isVideo)378 void CameraServerPhotoProxy::SetIsVideo(bool isVideo)
379 {
380 isVideo_ = isVideo;
381 }
382
SetStageVideoTaskStatus(uint8_t status)383 void CameraServerPhotoProxy::SetStageVideoTaskStatus(uint8_t status)
384 {
385 stageVideoTaskStatus_ = static_cast<int32_t>(status);
386 MEDIA_INFO_LOG("StageVideoTaskStatus is %{public}d", stageVideoTaskStatus_);
387 }
388
GetStageVideoTaskStatus()389 int32_t CameraServerPhotoProxy::GetStageVideoTaskStatus()
390 {
391 MEDIA_DEBUG_LOG("%{public}s get value: %{public}d", __FUNCTION__, stageVideoTaskStatus_);
392 return stageVideoTaskStatus_;
393 }
394
SetFormat(int32_t format)395 void CameraServerPhotoProxy::SetFormat(int32_t format)
396 {
397 format_ = format;
398 }
399
SetImageFormat(int32_t imageFormat)400 void CameraServerPhotoProxy::SetImageFormat(int32_t imageFormat)
401 {
402 imageFormat_ = imageFormat;
403 }
404 } // namespace CameraStandard
405 } // namespace OHOS
406