1 /*
2 * Copyright (c) 2021-2022 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 "output/deferred_photo_proxy.h"
17
18 #include <sys/mman.h>
19 #include <unistd.h>
20
21 #include "camera_buffer_handle_utils.h"
22 #include "camera_log.h"
23 #include "output/deferred_photo_proxy.h"
24 #include "photo_proxy.h"
25
26 namespace OHOS {
27 namespace CameraStandard {
28
DeferredPhotoProxy()29 DeferredPhotoProxy::DeferredPhotoProxy()
30 {
31 photoId_ = "";
32 deferredProcType_ = 0;
33 photoWidth_ = 0;
34 photoHeight_ = 0;
35 bufferHandle_ = nullptr;
36 fileDataAddr_ = nullptr;
37 fileSize_ = 0;
38 isMmaped_ = false;
39 buffer_ = nullptr;
40 }
41
DeferredPhotoProxy(const BufferHandle * bufferHandle,std::string imageId,int32_t deferredProcType)42 DeferredPhotoProxy::DeferredPhotoProxy(const BufferHandle* bufferHandle,
43 std::string imageId, int32_t deferredProcType)
44 {
45 MEDIA_INFO_LOG("DeferredPhotoProxy");
46 photoId_ = imageId;
47 deferredProcType_ = deferredProcType;
48 bufferHandle_ = bufferHandle;
49 fileDataAddr_ = nullptr;
50 photoWidth_ = 0;
51 photoHeight_ = 0;
52 fileSize_ = 0;
53 isMmaped_ = false;
54 buffer_ = nullptr;
55 MEDIA_INFO_LOG("DeferredPhotoProxy imageId: = %{public}s, deferredProcType = %{public}d",
56 imageId.c_str(), deferredProcType);
57 }
58
DeferredPhotoProxy(const BufferHandle * bufferHandle,std::string imageId,int32_t deferredProcType,int32_t photoWidth,int32_t photoHeight)59 DeferredPhotoProxy::DeferredPhotoProxy(const BufferHandle* bufferHandle,
60 std::string imageId, int32_t deferredProcType, int32_t photoWidth, int32_t photoHeight)
61 {
62 MEDIA_INFO_LOG("DeferredPhotoProxy");
63 photoId_ = imageId;
64 deferredProcType_ = deferredProcType;
65 photoWidth_ = photoWidth;
66 photoHeight_ = photoHeight;
67 bufferHandle_ = bufferHandle;
68 fileDataAddr_ = nullptr;
69 fileSize_ = 0;
70 isMmaped_ = false;
71 buffer_ = nullptr;
72 MEDIA_INFO_LOG("imageId: = %{public}s, deferredProcType = %{public}d, width = %{public}d, height = %{public}d",
73 imageId.c_str(), deferredProcType, photoWidth, photoHeight);
74 }
75
DeferredPhotoProxy(const BufferHandle * bufferHandle,std::string imageId,int32_t deferredProcType,uint8_t * buffer,size_t fileSize)76 DeferredPhotoProxy::DeferredPhotoProxy(const BufferHandle* bufferHandle,
77 std::string imageId, int32_t deferredProcType, uint8_t* buffer, size_t fileSize)
78 {
79 MEDIA_INFO_LOG("DeferredPhotoProxy");
80 photoId_ = imageId;
81 deferredProcType_ = deferredProcType;
82 photoWidth_ = 0;
83 photoHeight_ = 0;
84 bufferHandle_ = bufferHandle;
85 fileDataAddr_ = nullptr;
86 fileSize_ = fileSize;
87 isMmaped_ = false;
88 buffer_ = buffer;
89 MEDIA_INFO_LOG("DeferredPhotoProxy imageId: = %{public}s, deferredProcType = %{public}d",
90 imageId.c_str(), deferredProcType);
91 }
92
~DeferredPhotoProxy()93 DeferredPhotoProxy::~DeferredPhotoProxy()
94 {
95 std::lock_guard<std::mutex> lock(mutex_);
96 MEDIA_INFO_LOG("~DeferredPhotoProxy");
97 CHECK_EXECUTE(isMmaped_, munmap(fileDataAddr_, fileSize_));
98 CameraFreeBufferHandle(const_cast<BufferHandle*>(bufferHandle_));
99 fileDataAddr_ = nullptr;
100 fileSize_ = 0;
101 delete [] buffer_;
102 buffer_ = nullptr;
103 }
104
ReadFromParcel(MessageParcel & parcel)105 void DeferredPhotoProxy::ReadFromParcel(MessageParcel &parcel)
106 {
107 std::lock_guard<std::mutex> lock(mutex_);
108 photoId_ = parcel.ReadString();
109 deferredProcType_ = parcel.ReadInt32();
110 photoWidth_ = parcel.ReadInt32();
111 photoHeight_ = parcel.ReadInt32();
112 bufferHandle_ = ReadBufferHandle(parcel);
113 MEDIA_INFO_LOG("DeferredPhotoProxy::ReadFromParcel");
114 }
115
WriteToParcel(MessageParcel & parcel)116 void DeferredPhotoProxy::WriteToParcel(MessageParcel &parcel)
117 {
118 std::lock_guard<std::mutex> lock(mutex_);
119 parcel.WriteString(photoId_);
120 parcel.WriteInt32(deferredProcType_);
121 parcel.WriteInt32(photoWidth_);
122 parcel.WriteInt32(photoHeight_);
123 WriteBufferHandle(parcel, *bufferHandle_);
124 MEDIA_INFO_LOG("DeferredPhotoProxy::WriteToParcel");
125 }
126
GetPhotoId()127 std::string DeferredPhotoProxy::GetPhotoId()
128 {
129 MEDIA_INFO_LOG("DeferredPhotoProxy::GetPhotoId photoId: = %{public}s", photoId_.c_str());
130 std::lock_guard<std::mutex> lock(mutex_);
131 return photoId_;
132 }
133
GetDeferredProcType()134 Media::DeferredProcType DeferredPhotoProxy::GetDeferredProcType()
135 {
136 MEDIA_INFO_LOG("DeferredPhotoProxy::GetDeferredProcType");
137 std::lock_guard<std::mutex> lock(mutex_);
138 if (deferredProcType_ == 0) {
139 return Media::DeferredProcType::BACKGROUND;
140 } else {
141 return Media::DeferredProcType::OFFLINE;
142 }
143 }
144
GetFileDataAddr()145 void* DeferredPhotoProxy::GetFileDataAddr()
146 {
147 MEDIA_INFO_LOG("DeferredPhotoProxy::GetFileDataAddr");
148 std::lock_guard<std::mutex> lock(mutex_);
149 if (buffer_ != nullptr) {
150 MEDIA_INFO_LOG("DeferredPhotoProxy::GetFileDataAddr get addr temp!");
151 return buffer_;
152 }
153
154 if (!isMmaped_) {
155 MEDIA_INFO_LOG("DeferredPhotoProxy::GetFileDataAddr mmap");
156 fileDataAddr_ = mmap(nullptr, bufferHandle_->size, PROT_READ | PROT_WRITE, MAP_SHARED, bufferHandle_->fd, 0);
157 CHECK_ERROR_RETURN_RET_LOG(
158 fileDataAddr_ == MAP_FAILED, fileDataAddr_, "DeferredPhotoProxy::GetFileDataAddr mmap failed");
159 isMmaped_ = true;
160 } else {
161 MEDIA_ERR_LOG("DeferredPhotoProxy::GetFileDataAddr mmap failed");
162 }
163 return fileDataAddr_;
164 }
165
GetFormat()166 Media::PhotoFormat DeferredPhotoProxy::GetFormat()
167 {
168 return Media::PhotoFormat::RGBA;
169 }
170
GetPhotoQuality()171 Media::PhotoQuality DeferredPhotoProxy::GetPhotoQuality()
172 {
173 return Media::PhotoQuality::LOW;
174 }
175
GetFileSize()176 size_t DeferredPhotoProxy::GetFileSize()
177 {
178 MEDIA_INFO_LOG("DeferredPhotoProxy::GetFileSize");
179 std::lock_guard<std::mutex> lock(mutex_);
180 CHECK_ERROR_RETURN_RET_LOG(buffer_ != nullptr, fileSize_,
181 "DeferredPhotoProxy::GetFileSize temp!");
182 fileSize_ = bufferHandle_->size;
183 return fileSize_;
184 }
185
GetWidth()186 int32_t DeferredPhotoProxy::GetWidth()
187 {
188 return photoWidth_;
189 }
190
GetHeight()191 int32_t DeferredPhotoProxy::GetHeight()
192 {
193 return photoHeight_;
194 }
195
Release()196 void DeferredPhotoProxy::Release()
197 {
198 MEDIA_INFO_LOG("DeferredPhotoProxy release start");
199 }
200
GetTitle()201 std::string DeferredPhotoProxy::GetTitle()
202 {
203 return "";
204 }
205
GetExtension()206 std::string DeferredPhotoProxy::GetExtension()
207 {
208 return "";
209 }
GetLatitude()210 double DeferredPhotoProxy::GetLatitude()
211 {
212 return 0;
213 }
GetLongitude()214 double DeferredPhotoProxy::GetLongitude()
215 {
216 return 0;
217 }
GetBurstKey()218 std::string DeferredPhotoProxy::GetBurstKey()
219 {
220 return "";
221 }
IsCoverPhoto()222 bool DeferredPhotoProxy::IsCoverPhoto()
223 {
224 return false;
225 }
GetShootingMode()226 int32_t DeferredPhotoProxy::GetShootingMode()
227 {
228 return 0;
229 }
230
GetCloudImageEnhanceFlag()231 uint32_t DeferredPhotoProxy::GetCloudImageEnhanceFlag()
232 {
233 return 0;
234 }
235
236 } // namespace CameraStandard
237 } // namespace OHOS
238