1 /*
2 * Copyright (c) 2025 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/photo_output_callback.h"
17
18 #include <mutex>
19 #include <securec.h>
20
21 #include "photo_output.h"
22 #include "camera_log.h"
23 #include "camera_util.h"
24 #include "image_type.h"
25 #include "video_key_info.h"
26 #include "display/graphic/common/v1_0/cm_color_space.h"
27 #include "display/graphic/common/v2_1/cm_color_space.h"
28 #include "metadata_helper.h"
29 #include <pixel_map.h>
30 #include "hdr_type.h"
31 #include "camera_surface_buffer_util.h"
32 #include "task_manager.h"
33 using namespace std;
34
35 namespace OHOS {
36 namespace CameraStandard {
37 using namespace OHOS::HDI::Display::Graphic::Common::V2_1;
38 using CM_ColorSpaceType_V2_1 = OHOS::HDI::Display::Graphic::Common::V2_1::CM_ColorSpaceType;
39 static const std::unordered_map<CM_ColorSpaceType_V2_1, OHOS::ColorManager::ColorSpaceName> COLORSPACE_MAP = {
40 {CM_ColorSpaceType_V2_1::CM_COLORSPACE_NONE, OHOS::ColorManager::ColorSpaceName::NONE},
41 {CM_ColorSpaceType_V2_1::CM_BT601_EBU_FULL, OHOS::ColorManager::ColorSpaceName::BT601_EBU},
42 {CM_ColorSpaceType_V2_1::CM_BT601_SMPTE_C_FULL, OHOS::ColorManager::ColorSpaceName::BT601_SMPTE_C},
43 {CM_ColorSpaceType_V2_1::CM_BT709_FULL, OHOS::ColorManager::ColorSpaceName::BT709},
44 {CM_ColorSpaceType_V2_1::CM_BT2020_HLG_FULL, OHOS::ColorManager::ColorSpaceName::BT2020_HLG},
45 {CM_ColorSpaceType_V2_1::CM_BT2020_PQ_FULL, OHOS::ColorManager::ColorSpaceName::BT2020_PQ},
46 {CM_ColorSpaceType_V2_1::CM_BT601_EBU_LIMIT, OHOS::ColorManager::ColorSpaceName::BT601_EBU_LIMIT},
47 {CM_ColorSpaceType_V2_1::CM_BT601_SMPTE_C_LIMIT, OHOS::ColorManager::ColorSpaceName::BT601_SMPTE_C_LIMIT},
48 {CM_ColorSpaceType_V2_1::CM_BT709_LIMIT, OHOS::ColorManager::ColorSpaceName::BT709_LIMIT},
49 {CM_ColorSpaceType_V2_1::CM_BT2020_HLG_LIMIT, OHOS::ColorManager::ColorSpaceName::BT2020_HLG_LIMIT},
50 {CM_ColorSpaceType_V2_1::CM_BT2020_PQ_LIMIT, OHOS::ColorManager::ColorSpaceName::BT2020_PQ_LIMIT},
51 {CM_ColorSpaceType_V2_1::CM_SRGB_FULL, OHOS::ColorManager::ColorSpaceName::SRGB},
52 {CM_ColorSpaceType_V2_1::CM_P3_FULL, OHOS::ColorManager::ColorSpaceName::DISPLAY_P3},
53 {CM_ColorSpaceType_V2_1::CM_P3_HLG_FULL, OHOS::ColorManager::ColorSpaceName::P3_HLG},
54 {CM_ColorSpaceType_V2_1::CM_P3_PQ_FULL, OHOS::ColorManager::ColorSpaceName::P3_PQ},
55 {CM_ColorSpaceType_V2_1::CM_ADOBERGB_FULL, OHOS::ColorManager::ColorSpaceName::ADOBE_RGB},
56 {CM_ColorSpaceType_V2_1::CM_SRGB_LIMIT, OHOS::ColorManager::ColorSpaceName::SRGB_LIMIT},
57 {CM_ColorSpaceType_V2_1::CM_P3_LIMIT, OHOS::ColorManager::ColorSpaceName::DISPLAY_P3_LIMIT},
58 {CM_ColorSpaceType_V2_1::CM_P3_HLG_LIMIT, OHOS::ColorManager::ColorSpaceName::P3_HLG_LIMIT},
59 {CM_ColorSpaceType_V2_1::CM_P3_PQ_LIMIT, OHOS::ColorManager::ColorSpaceName::P3_PQ_LIMIT},
60 {CM_ColorSpaceType_V2_1::CM_ADOBERGB_LIMIT, OHOS::ColorManager::ColorSpaceName::ADOBE_RGB_LIMIT},
61 {CM_ColorSpaceType_V2_1::CM_LINEAR_SRGB, OHOS::ColorManager::ColorSpaceName::LINEAR_SRGB},
62 {CM_ColorSpaceType_V2_1::CM_LINEAR_BT709, OHOS::ColorManager::ColorSpaceName::LINEAR_BT709},
63 {CM_ColorSpaceType_V2_1::CM_LINEAR_P3, OHOS::ColorManager::ColorSpaceName::LINEAR_P3},
64 {CM_ColorSpaceType_V2_1::CM_LINEAR_BT2020, OHOS::ColorManager::ColorSpaceName::LINEAR_BT2020},
65 {CM_ColorSpaceType_V2_1::CM_DISPLAY_SRGB, OHOS::ColorManager::ColorSpaceName::DISPLAY_SRGB},
66 {CM_ColorSpaceType_V2_1::CM_DISPLAY_P3_SRGB, OHOS::ColorManager::ColorSpaceName::DISPLAY_P3_SRGB},
67 {CM_ColorSpaceType_V2_1::CM_DISPLAY_P3_HLG, OHOS::ColorManager::ColorSpaceName::DISPLAY_P3_HLG},
68 {CM_ColorSpaceType_V2_1::CM_DISPLAY_P3_PQ, OHOS::ColorManager::ColorSpaceName::DISPLAY_P3_PQ},
69 {CM_ColorSpaceType_V2_1::CM_DISPLAY_BT2020_SRGB, OHOS::ColorManager::ColorSpaceName::DISPLAY_BT2020_SRGB},
70 {CM_ColorSpaceType_V2_1::CM_DISPLAY_BT2020_HLG, OHOS::ColorManager::ColorSpaceName::DISPLAY_BT2020_HLG},
71 };
72 static constexpr int32_t PLANE_Y = 0;
73 static constexpr int32_t PLANE_U = 1;
74 static constexpr uint8_t PIXEL_SIZE_HDR_YUV = 3;
75 static constexpr uint8_t HDR_PIXEL_SIZE = 2;
76 static constexpr uint8_t SDR_PIXEL_SIZE = 1;
77
OnPhotoAvailable(sptr<SurfaceBuffer> surfaceBuffer,int64_t timestamp,bool isRaw)78 int32_t HStreamCapturePhotoCallbackImpl::OnPhotoAvailable(
79 sptr<SurfaceBuffer> surfaceBuffer, int64_t timestamp, bool isRaw)
80 {
81 CAMERA_SYNC_TRACE;
82 MEDIA_INFO_LOG("HStreamCapturePhotoCallbackImpl OnPhotoAvailable E");
83 auto photoOutput = GetPhotoOutput();
84 CHECK_RETURN_RET_ELOG(
85 photoOutput == nullptr, CAMERA_OK, "HStreamCapturePhotoCallbackImpl::OnPhotoAvailable photoOutput is nullptr");
86 auto callback = photoOutput->GetAppPhotoCallback();
87 CHECK_RETURN_RET_ELOG(
88 callback == nullptr, CAMERA_OK, "HStreamCapturePhotoCallbackImpl::OnPhotoAvailable callback is nullptr");
89 std::shared_ptr<CameraBufferProcessor> bufferProcessor;
90 std::shared_ptr<Media::NativeImage> image =
91 std::make_shared<Media::NativeImage>(surfaceBuffer, bufferProcessor, timestamp);
92 callback->OnPhotoAvailable(image, isRaw);
93 MEDIA_INFO_LOG("HStreamCapturePhotoCallbackImpl OnPhotoAvailable X");
94 return CAMERA_OK;
95 }
96
OnPhotoAssetAvailable(const int32_t captureId,const std::string & uri,int32_t cameraShotType,const std::string & burstKey)97 int32_t HStreamCapturePhotoAssetCallbackImpl::OnPhotoAssetAvailable(
98 const int32_t captureId, const std::string &uri, int32_t cameraShotType, const std::string &burstKey)
99 {
100 CAMERA_SYNC_TRACE;
101 MEDIA_INFO_LOG("HStreamCapturePhotoAssetCallbackImpl OnPhotoAssetAvailable");
102 auto photoOutput = GetPhotoOutput();
103 CHECK_RETURN_RET_ELOG(photoOutput == nullptr,
104 CAMERA_OK,
105 "HStreamCapturePhotoAssetCallbackImpl::OnPhotoAssetAvailable photoOutput is nullptr");
106 auto callback = photoOutput->GetAppPhotoAssetCallback();
107 CHECK_RETURN_RET_ELOG(callback == nullptr,
108 CAMERA_OK,
109 "HStreamCapturePhotoAssetCallbackImpl::OnPhotoAssetAvailable callback is nullptr");
110 callback->OnPhotoAssetAvailable(captureId, uri, cameraShotType, burstKey);
111 photoOutput->NotifyOfflinePhotoOutput(captureId);
112 return CAMERA_OK;
113 }
114
GetColorSpace(sptr<SurfaceBuffer> surfaceBuffer)115 OHOS::ColorManager::ColorSpaceName GetColorSpace(sptr<SurfaceBuffer> surfaceBuffer)
116 {
117 OHOS::ColorManager::ColorSpaceName colorSpace = OHOS::ColorManager::ColorSpaceName::NONE;
118 HDI::Display::Graphic::Common::V1_0::CM_ColorSpaceType colorSpaceType;
119 GSError gsErr = MetadataHelper::GetColorSpaceType(surfaceBuffer, colorSpaceType);
120 if (gsErr != GSERROR_OK) {
121 MEDIA_ERR_LOG("Failed to get colorSpaceType from surfaceBuffer!");
122 return colorSpace;
123 } else {
124 MEDIA_INFO_LOG("Get current colorSpaceType is : %{public}d", colorSpaceType);
125 }
126 CM_ColorSpaceType_V2_1 type2_1 = static_cast<CM_ColorSpaceType_V2_1>(colorSpaceType);
127 auto it = COLORSPACE_MAP.find(type2_1);
128 if (it != COLORSPACE_MAP.end()) {
129 colorSpace = it->second;
130 MEDIA_INFO_LOG("Current get colorSpaceName: %{public}d", colorSpace);
131 } else {
132 MEDIA_ERR_LOG("Current colorSpace is not supported!");
133 return colorSpace;
134 }
135 return colorSpace;
136 }
137
ThumbnailSetColorSpaceAndRotate(std::unique_ptr<Media::PixelMap> & pixelMap,sptr<SurfaceBuffer> surfaceBuffer,OHOS::ColorManager::ColorSpaceName colorSpaceName)138 void ThumbnailSetColorSpaceAndRotate(std::unique_ptr<Media::PixelMap> &pixelMap, sptr<SurfaceBuffer> surfaceBuffer,
139 OHOS::ColorManager::ColorSpaceName colorSpaceName)
140 {
141 int32_t thumbnailrotation = 0;
142 surfaceBuffer->GetExtraData()->ExtraGet(OHOS::Camera::dataRotation, thumbnailrotation);
143 MEDIA_ERR_LOG("CamThumbnail current rotation is : %{public}d", thumbnailrotation);
144 if (!pixelMap) {
145 MEDIA_ERR_LOG("CamThumbnail Failed to create PixelMap.");
146 } else {
147 pixelMap->InnerSetColorSpace(OHOS::ColorManager::ColorSpace(colorSpaceName));
148 pixelMap->rotate(thumbnailrotation);
149 }
150 }
151
OnThumbnailAvailable(sptr<SurfaceBuffer> surfaceBuffer,int64_t timestamp)152 int32_t HStreamCaptureThumbnailCallbackImpl::OnThumbnailAvailable(sptr<SurfaceBuffer> surfaceBuffer, int64_t timestamp)
153 {
154 CAMERA_SYNC_TRACE;
155 MEDIA_INFO_LOG("CamThumbnail::OnThumbnailAvailable");
156 auto photoOutput = GetPhotoOutput();
157 CHECK_RETURN_RET_ELOG(photoOutput == nullptr, CAMERA_OK,
158 "CamThumbnail::OnThumbnailAvailable photoOutput is nullptr");
159 auto callback = photoOutput->GetAppThumbnailCallback();
160 CHECK_RETURN_RET_ELOG(callback == nullptr, CAMERA_OK,
161 "CamThumbnail::OnThumbnailAvailable callback is nullptr");
162
163 // produce thumbnail
164 int32_t thumbnailWidth = 0;
165 int32_t thumbnailHeight = 0;
166 int32_t burstSeqId = -1;
167 int32_t captureId = 0;
168 surfaceBuffer->GetExtraData()->ExtraGet(OHOS::Camera::dataWidth, thumbnailWidth);
169 surfaceBuffer->GetExtraData()->ExtraGet(OHOS::Camera::dataHeight, thumbnailHeight);
170 surfaceBuffer->GetExtraData()->ExtraGet(OHOS::Camera::burstSequenceId, burstSeqId);
171 surfaceBuffer->GetExtraData()->ExtraGet(OHOS::Camera::captureId, captureId);
172 MEDIA_INFO_LOG("OnThumbnailAvailable width:%{public}d, height: %{public}d, captureId: %{public}d,"
173 "burstSeqId: %{public}d", thumbnailWidth, thumbnailHeight, captureId, burstSeqId);
174 OHOS::ColorManager::ColorSpaceName colorSpace = GetColorSpace(surfaceBuffer);
175 CHECK_RETURN_RET_ELOG(colorSpace == OHOS::ColorManager::ColorSpaceName::NONE, CAMERA_OK,
176 "Thumbnail GetcolorSpace failed!");
177 bool isHdr = colorSpace == OHOS::ColorManager::ColorSpaceName::BT2020_HLG;
178 // create pixelMap
179 std::unique_ptr<Media::PixelMap> pixelMap = CreatePixelMapFromSurfaceBuffer(surfaceBuffer,
180 thumbnailWidth, thumbnailHeight, isHdr);
181 CHECK_PRINT_ELOG(pixelMap == nullptr, "ThumbnailListener create pixelMap is nullptr");
182 ThumbnailSetColorSpaceAndRotate(pixelMap, surfaceBuffer, colorSpace);
183
184 callback->OnThumbnailAvailable(captureId, timestamp, std::move(pixelMap));
185 return CAMERA_OK;
186 }
187
CreatePixelMapFromSurfaceBuffer(sptr<SurfaceBuffer> & surfaceBuffer,int32_t width,int32_t height,bool isHdr)188 std::unique_ptr<Media::PixelMap> HStreamCaptureThumbnailCallbackImpl::CreatePixelMapFromSurfaceBuffer(
189 sptr<SurfaceBuffer> &surfaceBuffer, int32_t width, int32_t height, bool isHdr)
190 {
191 CHECK_RETURN_RET_ELOG(surfaceBuffer == nullptr, nullptr,
192 "CamThumbnail::CreatePixelMapFromSurfaceBuffer surfaceBuffer is nullptr");
193 MEDIA_INFO_LOG("CamThumbnail Width:%{public}d, height:%{public}d, isHdr:%{public}d, format:%{public}d",
194 width, height, isHdr, surfaceBuffer->GetFormat());
195 Media::InitializationOptions options {
196 .size = { .width = width, .height = height } };
197 options.srcPixelFormat = isHdr ? Media::PixelFormat::YCRCB_P010 : Media::PixelFormat::NV12;
198 options.pixelFormat = isHdr ? Media::PixelFormat::YCRCB_P010 : Media::PixelFormat::NV12;
199 options.useDMA = true;
200 options.editable = isHdr;
201 int32_t colorLength = width * height * PIXEL_SIZE_HDR_YUV;
202 colorLength = isHdr ? colorLength : colorLength / HDR_PIXEL_SIZE;
203 std::unique_ptr<Media::PixelMap> pixelMap = Media::PixelMap::Create(options);
204 CHECK_RETURN_RET_ELOG(pixelMap == nullptr, nullptr,
205 "CamThumbnail::CreatePixelMapFromSurfaceBuffer pixelMap is nullptr");
206 void* nativeBuffer = surfaceBuffer.GetRefPtr();
207 RefBase *ref = reinterpret_cast<RefBase *>(nativeBuffer);
208 ref->IncStrongRef(ref);
209 if (isHdr) {
210 pixelMap->SetHdrType(OHOS::Media::ImageHdrType::HDR_VIVID_SINGLE);
211 }
212 pixelMap->SetPixelsAddr(surfaceBuffer->GetVirAddr(), surfaceBuffer.GetRefPtr(), colorLength,
213 Media::AllocatorType::DMA_ALLOC, nullptr);
214
215 MEDIA_DEBUG_LOG("CamThumbnail::CreatePixelMapFromSurfaceBuffer end");
216 return SetPixelMapYuvInfo(surfaceBuffer, std::move(pixelMap), isHdr);
217 }
218
SetPixelMapYuvInfo(sptr<SurfaceBuffer> & surfaceBuffer,std::unique_ptr<Media::PixelMap> pixelMap,bool isHdr)219 std::unique_ptr<Media::PixelMap> HStreamCaptureThumbnailCallbackImpl::SetPixelMapYuvInfo(
220 sptr<SurfaceBuffer> &surfaceBuffer, std::unique_ptr<Media::PixelMap> pixelMap, bool isHdr)
221 {
222 MEDIA_INFO_LOG("CamThumbnail::SetPixelMapYuvInf enter");
223 uint8_t ratio = isHdr ? HDR_PIXEL_SIZE : SDR_PIXEL_SIZE;
224 int32_t srcWidth = pixelMap->GetWidth();
225 int32_t srcHeight = pixelMap->GetHeight();
226 Media::YUVDataInfo yuvDataInfo = { .yWidth = srcWidth,
227 .yHeight = srcHeight,
228 .uvWidth = srcWidth / 2,
229 .uvHeight = srcHeight / 2,
230 .yStride = srcWidth,
231 .uvStride = srcWidth,
232 .uvOffset = srcWidth * srcHeight};
233 if (surfaceBuffer == nullptr) {
234 pixelMap->SetImageYUVInfo(yuvDataInfo);
235 return pixelMap;
236 }
237 OH_NativeBuffer_Planes *planes = nullptr;
238 GSError retVal = surfaceBuffer->GetPlanesInfo(reinterpret_cast<void**>(&planes));
239 if (retVal != OHOS::GSERROR_OK || planes == nullptr) {
240 pixelMap->SetImageYUVInfo(yuvDataInfo);
241 return pixelMap;
242 }
243
244 yuvDataInfo.yStride = planes->planes[PLANE_Y].columnStride / ratio;
245 yuvDataInfo.uvStride = planes->planes[PLANE_U].columnStride / ratio;
246 yuvDataInfo.yOffset = planes->planes[PLANE_Y].offset / ratio;
247 yuvDataInfo.uvOffset = planes->planes[PLANE_U].offset / ratio;
248
249 pixelMap->SetImageYUVInfo(yuvDataInfo);
250 MEDIA_INFO_LOG("CamThumbnail::SetPixelMapYuvInf end");
251 return pixelMap;
252 }
253
PhotoNativeConsumer(wptr<PhotoOutput> photoOutput)254 PhotoNativeConsumer::PhotoNativeConsumer(wptr<PhotoOutput> photoOutput) : innerPhotoOutput_(photoOutput)
255 {
256 MEDIA_INFO_LOG("PhotoNativeConsumer new E");
257 }
258
~PhotoNativeConsumer()259 PhotoNativeConsumer::~PhotoNativeConsumer()
260 {
261 MEDIA_INFO_LOG("PhotoNativeConsumer ~ E");
262 ClearTaskManager();
263 }
264
OnBufferAvailable()265 void PhotoNativeConsumer::OnBufferAvailable()
266 {
267 MEDIA_INFO_LOG("PhotoNativeConsumer OnBufferAvailable E");
268 auto photoOutput = innerPhotoOutput_.promote();
269 CHECK_RETURN_ELOG(!photoOutput, "OnBufferAvailable photoOutput is null");
270 CHECK_RETURN_ELOG(!photoOutput->photoSurface_, "OnBufferAvailable photoNative surface is null");
271 auto taskManager = GetDefaultTaskManager();
272 CHECK_RETURN_ELOG(!taskManager, "PhotoNativeConsumer OnBufferAvailable task is null");
273 wptr<PhotoNativeConsumer> thisPtr(this);
274 taskManager->SubmitTask([thisPtr]() {
275 auto listener = thisPtr.promote();
276 CHECK_EXECUTE(listener, listener->ExecuteOnBufferAvailable());
277 });
278 MEDIA_INFO_LOG("PhotoNativeConsumer OnBufferAvailable X");
279 }
280
ExecuteOnBufferAvailable()281 void PhotoNativeConsumer::ExecuteOnBufferAvailable()
282 {
283 MEDIA_INFO_LOG("PN_ExecuteOnBufferAvailable E");
284 CAMERA_SYNC_TRACE;
285 auto photoOutput = innerPhotoOutput_.promote();
286 CHECK_RETURN_ELOG(!photoOutput, "ExecuteOnBufferAvailable photoOutput is null");
287 CHECK_RETURN_ELOG(!photoOutput->photoSurface_, "ExecuteOnBufferAvailable photoNative surface is null");
288 sptr<SurfaceBuffer> surfaceBuffer = nullptr;
289 int32_t fence = -1;
290 int64_t timestamp;
291 OHOS::Rect damage;
292 SurfaceError surfaceRet = photoOutput->photoSurface_->AcquireBuffer(surfaceBuffer, fence, timestamp, damage);
293 CHECK_RETURN_ELOG(surfaceRet != SURFACE_ERROR_OK, "PhotoNativeConsumer Failed to acquire surface buffer");
294 int32_t isDegradedImage = CameraSurfaceBufferUtil::GetIsDegradedImage(surfaceBuffer);
295 MEDIA_INFO_LOG("PhotoNativeConsumer ts isDegradedImage:%{public}d", isDegradedImage);
296 MEDIA_INFO_LOG("PhotoNativeConsumer ts is:%{public}" PRId64, timestamp);
297 // deep copy surfaceBuffer
298 sptr<SurfaceBuffer> newSurfaceBuffer = CameraSurfaceBufferUtil::DeepCopyBuffer(surfaceBuffer);
299 // release surfaceBuffer to bufferQueue
300 photoOutput->photoSurface_->ReleaseBuffer(surfaceBuffer, -1);
301 CHECK_RETURN_ELOG(newSurfaceBuffer == nullptr, "newSurfaceBuffer is null");
302 if ((photoOutput->callbackFlag_ & CAPTURE_PHOTO_ASSET) != 0) {
303 ExecutePhotoAssetAvailable(newSurfaceBuffer, timestamp);
304 } else if (isDegradedImage == 0 && (photoOutput->callbackFlag_ & CAPTURE_PHOTO) != 0) {
305 ExecutePhotoAvailable(newSurfaceBuffer, timestamp);
306 } else if (isDegradedImage != 0 && (photoOutput->callbackFlag_ & CAPTURE_DEFERRED_PHOTO) != 0) {
307 MEDIA_INFO_LOG("PN_ExecuteOnBufferAvailable on abandon callback");
308 } else {
309 MEDIA_INFO_LOG("PN_ExecuteOnBufferAvailable on error callback");
310 }
311 MEDIA_INFO_LOG("PN_ExecuteOnBufferAvailable X");
312 }
313
ExecutePhotoAvailable(sptr<SurfaceBuffer> surfaceBuffer,int64_t timestamp)314 void PhotoNativeConsumer::ExecutePhotoAvailable(sptr<SurfaceBuffer> surfaceBuffer, int64_t timestamp)
315 {
316 MEDIA_INFO_LOG("PN_ExecutePhotoAvailable E");
317 CAMERA_SYNC_TRACE;
318 CHECK_RETURN_ELOG(surfaceBuffer == nullptr, "ExecutePhotoAvailable surfaceBuffer is null");
319 auto photoOutput = innerPhotoOutput_.promote();
320 CHECK_RETURN_ELOG(!photoOutput, "ExecutePhotoAvailable photoOutput is null");
321 auto callback = photoOutput->GetAppPhotoCallback();
322 CHECK_RETURN_ELOG(callback == nullptr, "ExecutePhotoAvailable callback is nullptr");
323 std::shared_ptr<CameraBufferProcessor> bufferProcessor;
324 std::shared_ptr<Media::NativeImage> image =
325 std::make_shared<Media::NativeImage>(surfaceBuffer, bufferProcessor, timestamp);
326 callback->OnPhotoAvailable(image, false);
327 MEDIA_INFO_LOG("PN_ExecutePhotoAvailable X");
328 }
329
ExecutePhotoAssetAvailable(sptr<SurfaceBuffer> newSurfaceBuffer,int64_t timestamp)330 void PhotoNativeConsumer::ExecutePhotoAssetAvailable(sptr<SurfaceBuffer> newSurfaceBuffer, int64_t timestamp)
331 {
332 MEDIA_INFO_LOG("PN_ExecutePhotoAssetAvailable E");
333 CAMERA_SYNC_TRACE;
334 CHECK_RETURN_ELOG(newSurfaceBuffer == nullptr, "ExecutePhotoAssetAvailable surfaceBuffer is null");
335 auto photoOutput = innerPhotoOutput_.promote();
336 CHECK_RETURN_ELOG(!photoOutput, "ExecutePhotoAssetAvailable photoOutput is null");
337 auto callback = photoOutput->GetAppPhotoAssetCallback();
338 CHECK_RETURN_ELOG(callback == nullptr, "ExecutePhotoAssetAvailable callback is nullptr");
339 // prepare CameraPhotoProxy
340 BufferHandle* bufferHandle = newSurfaceBuffer->GetBufferHandle();
341 newSurfaceBuffer->Map();
342 int32_t format = bufferHandle->format;
343 int32_t photoWidth = CameraSurfaceBufferUtil::GetDataWidth(newSurfaceBuffer);
344 int32_t photoHeight = CameraSurfaceBufferUtil::GetDataWidth(newSurfaceBuffer);
345 bool isHighQuality = (CameraSurfaceBufferUtil::GetIsDegradedImage(newSurfaceBuffer) == 0);
346 int32_t captureId = CameraSurfaceBufferUtil::GetCaptureId(newSurfaceBuffer);
347 int32_t burstSeqId = -1;
348 sptr<CameraPhotoProxy> photoProxy = new (std::nothrow)
349 CameraPhotoProxy(bufferHandle, format, photoWidth, photoHeight, isHighQuality, captureId, burstSeqId);
350 // ipc CreateMediaLibrary
351 string uri = "";
352 int32_t cameraShotType = 0;
353 std::string burstKey = "";
354 photoOutput->CreateMediaLibrary(photoProxy, uri, cameraShotType, burstKey, timestamp);
355 MEDIA_INFO_LOG("PN_ExecutePhotoAssetAvailable CreateMediaLibrary get uri:%{public}s", uri.c_str());
356 callback->OnPhotoAssetAvailable(captureId, uri, cameraShotType, burstKey);
357 MEDIA_INFO_LOG("PN_ExecutePhotoAssetAvailable X");
358 }
359
ClearTaskManager()360 void PhotoNativeConsumer::ClearTaskManager()
361 {
362 std::lock_guard<std::mutex> lock(taskManagerMutex_);
363 if (taskManager_ != nullptr) {
364 taskManager_->CancelAllTasks();
365 taskManager_ = nullptr;
366 }
367 }
368
GetDefaultTaskManager()369 std::shared_ptr<DeferredProcessing::TaskManager> PhotoNativeConsumer::GetDefaultTaskManager()
370 {
371 constexpr int32_t numThreads = 1;
372 std::lock_guard<std::mutex> lock(taskManagerMutex_);
373 if (taskManager_ == nullptr) {
374 taskManager_ = std::make_shared<DeferredProcessing::TaskManager>("PhotoListener", numThreads, false);
375 }
376 return taskManager_;
377 }
378 } // namespace CameraStandard
379 } // namespace OHOS
380