1 /*
2 * Copyright (C) 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 "image_effect.h"
17
18 #include "effect_log.h"
19 #include "efilter_factory.h"
20 #include "external_loader.h"
21 #include "image_effect_inner.h"
22 #include "effect_json_helper.h"
23 #include "native_effect_base.h"
24 #include "native_common_utils.h"
25 #include "native_window.h"
26 #include "event_report.h"
27
28 #define MAX_EFILTER_NUMS 100
29
30 using namespace OHOS::Media;
31 using namespace OHOS::Media::Effect;
32
33 namespace {
34 std::mutex effectMutex_;
35
36 constexpr int const MAX_CHAR_LEN = 1024;
37 constexpr int const MAX_INFO_LEN = 5 * 1024 * 1024;
38 constexpr const char *EMPTY_NAME = "";
39 }
40
41 #ifdef __cplusplus
42 extern "C" {
43 #endif
44
45 EFFECT_EXPORT
OH_ImageEffect_Create(const char * name)46 OH_ImageEffect *OH_ImageEffect_Create(const char *name)
47 {
48 if (name != nullptr && strlen(name) > MAX_CHAR_LEN) {
49 name = EMPTY_NAME;
50 }
51 if (!ExternLoader::Instance()->IsExtLoad()) {
52 ExternLoader::Instance()->LoadExtSo();
53 }
54
55 EFFECT_LOGI("Creat image effect");
56 std::shared_ptr<ImageEffect> imageEffect = std::make_unique<ImageEffect>(name);
57 std::unique_ptr<OH_ImageEffect> nativeImageEffect = std::make_unique<OH_ImageEffect>();
58 nativeImageEffect->imageEffect_ = imageEffect;
59 return nativeImageEffect.release();
60 }
61
62 EFFECT_EXPORT
OH_ImageEffect_AddFilter(OH_ImageEffect * imageEffect,const char * filterName)63 OH_EffectFilter *OH_ImageEffect_AddFilter(OH_ImageEffect *imageEffect, const char *filterName)
64 {
65 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, nullptr, "AddFilter: input parameter imageEffect is null!");
66 CHECK_AND_RETURN_RET_LOG(imageEffect->filters_.size() < MAX_EFILTER_NUMS, nullptr,
67 "AddFilter: filter nums is out of range!");
68 CHECK_AND_RETURN_RET_LOG(filterName != nullptr, nullptr, "AddFilter: input parameter filterName is null!");
69 CHECK_AND_RETURN_RET_LOG(strlen(filterName) < MAX_CHAR_LEN, nullptr,
70 "AddFilter: the length of input parameter filterName is too long! len = %{public}zu", strlen(filterName));
71
72 OH_EffectFilter *filter = OH_EffectFilter_Create(filterName);
73 CHECK_AND_RETURN_RET_LOG(filter != nullptr, nullptr, "AddFilter: create filter fail! name=%{public}s", filterName);
74
75 filter->isCreatedBySystem_ = true;
76 ImageEffect_ErrorCode errorCode = OH_ImageEffect_AddFilterByFilter(imageEffect, filter);
77 if (errorCode != ImageEffect_ErrorCode::EFFECT_SUCCESS) {
78 OH_EffectFilter_Release(filter);
79 filter = nullptr;
80 }
81 return filter;
82 }
83
84 EFFECT_EXPORT
OH_ImageEffect_AddFilterByFilter(OH_ImageEffect * imageEffect,OH_EffectFilter * filter)85 ImageEffect_ErrorCode OH_ImageEffect_AddFilterByFilter(OH_ImageEffect *imageEffect, OH_EffectFilter *filter)
86 {
87 std::unique_lock<std::mutex> lock(effectMutex_);
88 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
89 "AddFilter: input parameter imageEffect is null!");
90 CHECK_AND_RETURN_RET_LOG(filter != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
91 "AddFilter: input parameter filter is null!");
92 CHECK_AND_RETURN_RET_LOG(imageEffect->filters_.size() < MAX_EFILTER_NUMS,
93 ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID, "AddFilterByFilter: filter nums is out of range!");
94
95 EFFECT_LOGI("Add filter. name=%{public}s", filter->filter_->GetName().c_str());
96
97 imageEffect->imageEffect_->AddEFilter(filter->filter_);
98 imageEffect->filters_.emplace_back(filter, filter->filter_->GetName());
99
100 EventInfo eventInfo = {
101 .filterName = filter->filter_->GetName(),
102 };
103 EventReport::ReportHiSysEvent(ADD_FILTER_STATISTIC, eventInfo);
104 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
105 }
106
107 EFFECT_EXPORT
OH_ImageEffect_InsertFilter(OH_ImageEffect * imageEffect,uint32_t index,const char * filterName)108 OH_EffectFilter *OH_ImageEffect_InsertFilter(OH_ImageEffect *imageEffect, uint32_t index, const char *filterName)
109 {
110 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, nullptr, "InsertFilter: input parameter imageEffect is null!");
111 CHECK_AND_RETURN_RET_LOG(imageEffect->filters_.size() < MAX_EFILTER_NUMS, nullptr,
112 "InsertFilter: filter nums is out of range!");
113 CHECK_AND_RETURN_RET_LOG(filterName != nullptr, nullptr, "InsertFilter: input parameter filterName is null!");
114 CHECK_AND_RETURN_RET_LOG(strlen(filterName) < MAX_CHAR_LEN, nullptr,
115 "InsertFilter: the length of input parameter filterName is too long! len = %{public}zu", strlen(filterName));
116
117 OH_EffectFilter *filter = OH_EffectFilter_Create(filterName);
118 CHECK_AND_RETURN_RET_LOG(filter != nullptr, nullptr, "InsertFilter: create filter fail! filterName=%{public}s",
119 filterName);
120
121 filter->isCreatedBySystem_ = true;
122 ImageEffect_ErrorCode errorCode = OH_ImageEffect_InsertFilterByFilter(imageEffect, index, filter);
123 if (errorCode != ImageEffect_ErrorCode::EFFECT_SUCCESS) {
124 OH_EffectFilter_Release(filter);
125 filter = nullptr;
126 }
127 return filter;
128 }
129
130 EFFECT_EXPORT
OH_ImageEffect_InsertFilterByFilter(OH_ImageEffect * imageEffect,uint32_t index,OH_EffectFilter * filter)131 ImageEffect_ErrorCode OH_ImageEffect_InsertFilterByFilter(OH_ImageEffect *imageEffect, uint32_t index,
132 OH_EffectFilter *filter)
133 {
134 std::unique_lock<std::mutex> lock(effectMutex_);
135 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
136 "InsertFilter: input parameter imageEffect is null!");
137 CHECK_AND_RETURN_RET_LOG(imageEffect->filters_.size() < MAX_EFILTER_NUMS,
138 ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID, "InsertFilter: filter nums is out of range!");
139 CHECK_AND_RETURN_RET_LOG(filter != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
140 "InsertFilter: input parameter filterName is null!");
141 CHECK_AND_RETURN_RET_LOG(index <= static_cast<uint32_t>(imageEffect->filters_.size()),
142 ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
143 "InsertFilter: input parameter index is invalid! index=%{public}d, efilterSize=%{public}zu",
144 index, imageEffect->filters_.size());
145
146 std::string filterName = filter->filter_->GetName();
147 EFFECT_LOGI("Insert filter. name=%{public}s", filterName.c_str());
148
149 ErrorCode result = imageEffect->imageEffect_->InsertEFilter(filter->filter_, index);
150 if (result != ErrorCode::SUCCESS) {
151 EFFECT_LOGE("InsertFilter: insert filter fail! result=%{public}d, name=%{public}s", result, filterName.c_str());
152 return ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID;
153 }
154
155 imageEffect->filters_.emplace(imageEffect->filters_.begin() + index, filter, filterName);
156 EventInfo eventInfo = {
157 .filterName = filterName,
158 };
159 EventReport::ReportHiSysEvent(ADD_FILTER_STATISTIC, eventInfo);
160
161 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
162 }
163
164 EFFECT_EXPORT
OH_ImageEffect_RemoveFilter(OH_ImageEffect * imageEffect,const char * filterName)165 int32_t OH_ImageEffect_RemoveFilter(OH_ImageEffect *imageEffect, const char *filterName)
166 {
167 std::unique_lock<std::mutex> lock(effectMutex_);
168 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, 0, "RemoveFilter: input parameter imageEffect is null!");
169 CHECK_AND_RETURN_RET_LOG(filterName != nullptr, 0, "RemoveFilter: input parameter nativeEffect is null!");
170 CHECK_AND_RETURN_RET_LOG(strlen(filterName) < MAX_CHAR_LEN, 0,
171 "RemoveFilter: the length of input parameter filterName is too long! len = %{public}zu", strlen(filterName));
172
173 int32_t count = 0;
174 for (auto it = imageEffect->filters_.begin(); it != imageEffect->filters_.end();) {
175 if (it->second.compare(filterName) == 0) {
176 imageEffect->imageEffect_->RemoveEFilter(it->first->filter_);
177 auto filter = it->first;
178 if (filter != nullptr && filter->isCreatedBySystem_) {
179 OH_EffectFilter_Release(filter);
180 }
181 it = imageEffect->filters_.erase(it);
182 count++;
183 } else {
184 ++it;
185 }
186 }
187 EFFECT_LOGI("Remove filter. name=%{public}s, count=%{public}d", filterName, count);
188
189 EventInfo eventInfo = {
190 .filterName = filterName,
191 .filterNum = count,
192 };
193 EventReport::ReportHiSysEvent(REMOVE_FILTER_STATISTIC, eventInfo);
194 return count;
195 }
196
197 EFFECT_EXPORT
OH_ImageEffect_RemoveFilterByIndex(OH_ImageEffect * imageEffect,uint32_t index)198 ImageEffect_ErrorCode OH_ImageEffect_RemoveFilterByIndex(OH_ImageEffect *imageEffect, uint32_t index)
199 {
200 std::unique_lock<std::mutex> lock(effectMutex_);
201 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
202 "RemoveFilterByIndex: input parameter imageEffect is null!");
203 CHECK_AND_RETURN_RET_LOG(index < static_cast<uint32_t>(imageEffect->filters_.size()),
204 ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
205 "RemoveFilterByIndex: input parameter index is invalid! index=%{public}d, efilterSize=%{public}zu",
206 index, imageEffect->filters_.size());
207
208 ErrorCode result = imageEffect->imageEffect_->RemoveEFilter(index);
209 if (result != ErrorCode::SUCCESS) {
210 EFFECT_LOGE("RemoveFilterByIndex: remove filter fail! result=%{public}d", result);
211 return ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID;
212 }
213
214 const auto &filter = imageEffect->filters_.at(index);
215 auto ohEFilter = filter.first;
216
217 CHECK_AND_RETURN_RET_LOG(ohEFilter != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
218 "RemoveFilterByIndex: ohEFilter is null!");
219 CHECK_AND_RETURN_RET_LOG(ohEFilter->filter_ != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
220 "RemoveFilterByIndex: filter of ohEFilter is null!");
221
222 std::string filterName = ohEFilter->filter_->GetName();
223 if (ohEFilter->isCreatedBySystem_) {
224 OH_EffectFilter_Release(ohEFilter);
225 }
226 imageEffect->filters_.erase(imageEffect->filters_.begin() + index);
227 EFFECT_LOGI("Remove filter by index. name=%{public}s, index=%{public}d", filterName.c_str(), index);
228
229 EventInfo eventInfo = {
230 .filterName = filterName,
231 .filterNum = 1,
232 };
233 EventReport::ReportHiSysEvent(REMOVE_FILTER_STATISTIC, eventInfo);
234
235 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
236 }
237
238 EFFECT_EXPORT
OH_ImageEffect_ReplaceFilter(OH_ImageEffect * imageEffect,uint32_t index,const char * filterName)239 OH_EffectFilter *OH_ImageEffect_ReplaceFilter(OH_ImageEffect *imageEffect, uint32_t index, const char *filterName)
240 {
241 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, nullptr, "ReplaceFilter: input parameter imageEffect is null!");
242 CHECK_AND_RETURN_RET_LOG(index < static_cast<uint32_t>(imageEffect->filters_.size()), nullptr,
243 "ReplaceFilter: input parameter index is invalid! index=%{public}d, efilterSize=%{public}zu",
244 index, imageEffect->filters_.size());
245
246 CHECK_AND_RETURN_RET_LOG(filterName != nullptr, nullptr, "ReplaceFilter: input parameter filterName is null!");
247 CHECK_AND_RETURN_RET_LOG(strlen(filterName) < MAX_CHAR_LEN, nullptr,
248 "ReplaceFilter: the length of input parameter filterName is too long! len = %{public}zu", strlen(filterName));
249
250 OH_EffectFilter *filter = OH_EffectFilter_Create(filterName);
251 CHECK_AND_RETURN_RET_LOG(filter != nullptr, nullptr,
252 "ReplaceFilter: create filter fail! name=%{public}s", filterName);
253
254 filter->isCreatedBySystem_ = true;
255 ImageEffect_ErrorCode errorCode = OH_ImageEffect_ReplaceFilterByFilter(imageEffect, index, filter);
256 if (errorCode != ImageEffect_ErrorCode::EFFECT_SUCCESS) {
257 OH_EffectFilter_Release(filter);
258 filter = nullptr;
259 }
260 return filter;
261 }
262
263 EFFECT_EXPORT
OH_ImageEffect_ReplaceFilterByFilter(OH_ImageEffect * imageEffect,uint32_t index,OH_EffectFilter * filter)264 ImageEffect_ErrorCode OH_ImageEffect_ReplaceFilterByFilter(OH_ImageEffect *imageEffect, uint32_t index,
265 OH_EffectFilter *filter)
266 {
267 std::unique_lock<std::mutex> lock(effectMutex_);
268 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
269 "ReplaceFilter: input parameter imageEffect is null!");
270 CHECK_AND_RETURN_RET_LOG(index < static_cast<uint32_t>(imageEffect->filters_.size()),
271 ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
272 "ReplaceFilter: input parameter index is invalid! index=%{public}d, efilterSize=%{public}zu",
273 index, imageEffect->filters_.size());
274 CHECK_AND_RETURN_RET_LOG(filter != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
275 "ReplaceFilter: input parameter filterName is null!");
276
277 EFFECT_LOGI("Replace filter. index=%{public}d, name=%{public}s", index, filter->filter_->GetName().c_str());
278
279 ErrorCode result = imageEffect->imageEffect_->ReplaceEFilter(filter->filter_, index);
280 if (result != ErrorCode::SUCCESS) {
281 EFFECT_LOGE("ReplaceFilter fail! result=%{public}d, index=%{public}d", result, index);
282 return ImageEffect_ErrorCode ::EFFECT_ERROR_PARAM_INVALID;
283 }
284
285 auto &originFilter = imageEffect->filters_.at(index);
286 CHECK_AND_RETURN_RET_LOG(originFilter.first != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
287 "ReplaceFilter: originFilter is null!");
288 if (originFilter.first->isCreatedBySystem_) {
289 OH_EffectFilter_Release(originFilter.first);
290 }
291 imageEffect->filters_[index] = std::pair<OH_EffectFilter *, std::string>(filter, filter->filter_->GetName());
292
293 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
294 }
295
296 EFFECT_EXPORT
OH_ImageEffect_Configure(OH_ImageEffect * imageEffect,const char * key,const ImageEffect_Any * value)297 ImageEffect_ErrorCode OH_ImageEffect_Configure(OH_ImageEffect *imageEffect, const char *key,
298 const ImageEffect_Any *value)
299 {
300 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
301 "Configure: input parameter imageEffect is null!");
302 CHECK_AND_RETURN_RET_LOG(key != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
303 "Configure: input parameter key is null!");
304 CHECK_AND_RETURN_RET_LOG(strlen(key) < MAX_CHAR_LEN, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
305 "Configure: the length of input parameter key is too long! len = %{public}zu", strlen(key));
306 CHECK_AND_RETURN_RET_LOG(value != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
307 "Configure: input parameter value is null!");
308
309 Plugin::Any any;
310 ErrorCode result = NativeCommonUtils::ParseOHAny(value, any);
311 CHECK_AND_RETURN_RET_LOG(result == ErrorCode::SUCCESS, ImageEffect_ErrorCode::EFFECT_PARAM_ERROR,
312 "Configure: parse oh any fail! result=%{public}d, key=%{public}s, dataType=%{public}d",
313 result, key, value->dataType);
314
315 result = imageEffect->imageEffect_->Configure(key, any);
316 CHECK_AND_RETURN_RET_LOG(result == ErrorCode::SUCCESS, ImageEffect_ErrorCode::EFFECT_PARAM_ERROR,
317 "Configure: config fail! result=%{public}d, key=%{public}s, dataType=%{public}d", result, key, value->dataType);
318
319 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
320 }
321
322 EFFECT_EXPORT
OH_ImageEffect_SetOutputSurface(OH_ImageEffect * imageEffect,NativeWindow * nativeWindow)323 ImageEffect_ErrorCode OH_ImageEffect_SetOutputSurface(OH_ImageEffect *imageEffect, NativeWindow *nativeWindow)
324 {
325 std::unique_lock<std::mutex> lock(effectMutex_);
326 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
327 "SetOutputSurface: input parameter imageEffect is null!");
328 CHECK_AND_RETURN_RET_LOG(nativeWindow != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
329 "SetOutputSurface: input parameter nativeWindow is null!");
330
331 ErrorCode errorCode = imageEffect->imageEffect_->SetOutNativeWindow(nativeWindow);
332 if (errorCode != ErrorCode::SUCCESS) {
333 EFFECT_LOGE("SetOutputSurface: set output surface fail! errorCode=%{public}d", errorCode);
334 return ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID;
335 }
336
337 EventInfo eventInfo = {
338 .dataType = EventDataType::SURFACE,
339 };
340 EventReport::ReportHiSysEvent(INPUT_DATA_TYPE_STATISTIC, eventInfo);
341 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
342 }
343
344 EFFECT_EXPORT
OH_ImageEffect_GetInputSurface(OH_ImageEffect * imageEffect,NativeWindow ** nativeWindow)345 ImageEffect_ErrorCode OH_ImageEffect_GetInputSurface(OH_ImageEffect *imageEffect, NativeWindow **nativeWindow)
346 {
347 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
348 "GetInputSurface: input parameter imageEffect is null!");
349 CHECK_AND_RETURN_RET_LOG(nativeWindow != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
350 "GetInputSurface: input parameter surfaceId is null!");
351
352 OHOS::sptr<OHOS::Surface> surface = imageEffect->imageEffect_->GetInputSurface();
353 CHECK_AND_RETURN_RET_LOG(surface != nullptr, ImageEffect_ErrorCode::EFFECT_UNKNOWN,
354 "GetInputSurface: get input surface fail! surface is null!");
355
356 *nativeWindow = OH_NativeWindow_CreateNativeWindow(&surface);
357
358 EventInfo eventInfo = {
359 .dataType = EventDataType::SURFACE,
360 };
361 EventReport::ReportHiSysEvent(OUTPUT_DATA_TYPE_STATISTIC, eventInfo);
362 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
363 }
364
365 EFFECT_EXPORT
OH_ImageEffect_SetInputPixelmap(OH_ImageEffect * imageEffect,OH_PixelmapNative * pixelmap)366 ImageEffect_ErrorCode OH_ImageEffect_SetInputPixelmap(OH_ImageEffect *imageEffect, OH_PixelmapNative *pixelmap)
367 {
368 std::unique_lock<std::mutex> lock(effectMutex_);
369 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
370 "SetInputPixelmap: input parameter imageEffect is null!");
371 CHECK_AND_RETURN_RET_LOG(pixelmap != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
372 "SetInputPixelmap: input parameter pixelmap is null!");
373
374 ErrorCode errorCode =
375 imageEffect->imageEffect_->SetInputPixelMap(NativeCommonUtils::GetPixelMapFromOHPixelmap(pixelmap));
376 CHECK_AND_RETURN_RET_LOG(errorCode == ErrorCode::SUCCESS, ImageEffect_ErrorCode::EFFECT_PARAM_ERROR,
377 "SetInputPixelMap: set input pixelmap fail! errorCode=%{public}d", errorCode);
378
379 EventInfo eventInfo = {
380 .dataType = EventDataType::PIXEL_MAP,
381 };
382 EventReport::ReportHiSysEvent(INPUT_DATA_TYPE_STATISTIC, eventInfo);
383 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
384 }
385
386 EFFECT_EXPORT
OH_ImageEffect_SetOutputPixelmap(OH_ImageEffect * imageEffect,OH_PixelmapNative * pixelmap)387 ImageEffect_ErrorCode OH_ImageEffect_SetOutputPixelmap(OH_ImageEffect *imageEffect, OH_PixelmapNative *pixelmap)
388 {
389 std::unique_lock<std::mutex> lock(effectMutex_);
390 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
391 "SetOutputPixelmap: input parameter imageEffect is null!");
392
393 ErrorCode errorCode =
394 imageEffect->imageEffect_->SetOutputPixelMap(NativeCommonUtils::GetPixelMapFromOHPixelmap(pixelmap));
395 CHECK_AND_RETURN_RET_LOG(errorCode == ErrorCode::SUCCESS, ImageEffect_ErrorCode::EFFECT_PARAM_ERROR,
396 "SetOutputPixelmap: set output pixelmap fail! errorCode=%{public}d", errorCode);
397
398 EventInfo eventInfo = {
399 .dataType = EventDataType::PIXEL_MAP,
400 };
401 EventReport::ReportHiSysEvent(OUTPUT_DATA_TYPE_STATISTIC, eventInfo);
402 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
403 }
404
405 EFFECT_EXPORT
OH_ImageEffect_SetInputNativeBuffer(OH_ImageEffect * imageEffect,OH_NativeBuffer * nativeBuffer)406 ImageEffect_ErrorCode OH_ImageEffect_SetInputNativeBuffer(OH_ImageEffect *imageEffect, OH_NativeBuffer *nativeBuffer)
407 {
408 std::unique_lock<std::mutex> lock(effectMutex_);
409 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
410 "SetInputNativeBuffer: input parameter imageEffect is null!");
411 CHECK_AND_RETURN_RET_LOG(nativeBuffer != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
412 "SetInputNativeBuffer: input parameter input nativeBuffer is null!");
413
414 OHOS::SurfaceBuffer *surfaceBuffer = OHOS::SurfaceBuffer::NativeBufferToSurfaceBuffer(nativeBuffer);
415
416 ErrorCode errorCode = imageEffect->imageEffect_->SetInputSurfaceBuffer(surfaceBuffer);
417 CHECK_AND_RETURN_RET_LOG(errorCode == ErrorCode::SUCCESS,
418 ImageEffect_ErrorCode::EFFECT_PARAM_ERROR,
419 "SetInputNativeBuffer: set input native buffer fail! errorCode=%{public}d", errorCode);
420
421 EventInfo eventInfo = {
422 .dataType = EventDataType::SURFACE_BUFFER,
423 };
424 EventReport::ReportHiSysEvent(INPUT_DATA_TYPE_STATISTIC, eventInfo);
425 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
426 }
427
428 EFFECT_EXPORT
OH_ImageEffect_SetOutputNativeBuffer(OH_ImageEffect * imageEffect,OH_NativeBuffer * nativeBuffer)429 ImageEffect_ErrorCode OH_ImageEffect_SetOutputNativeBuffer(OH_ImageEffect *imageEffect, OH_NativeBuffer *nativeBuffer)
430 {
431 std::unique_lock<std::mutex> lock(effectMutex_);
432 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
433 "SetOutputNativeBuffer: input parameter imageEffect is null!");
434
435 OHOS::SurfaceBuffer *surfaceBuffer = OHOS::SurfaceBuffer::NativeBufferToSurfaceBuffer(nativeBuffer);
436
437 ErrorCode errorCode = imageEffect->imageEffect_->SetOutputSurfaceBuffer(surfaceBuffer);
438 CHECK_AND_RETURN_RET_LOG(errorCode == ErrorCode::SUCCESS, ImageEffect_ErrorCode::EFFECT_PARAM_ERROR,
439 "SetOutputNativeBuffer: set output native buffer fail! errorCode=%{public}d", errorCode);
440
441 EventInfo eventInfo = {
442 .dataType = EventDataType::SURFACE_BUFFER,
443 };
444 EventReport::ReportHiSysEvent(OUTPUT_DATA_TYPE_STATISTIC, eventInfo);
445 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
446 }
447
448 EFFECT_EXPORT
OH_ImageEffect_SetInputUri(OH_ImageEffect * imageEffect,const char * uri)449 ImageEffect_ErrorCode OH_ImageEffect_SetInputUri(OH_ImageEffect *imageEffect, const char *uri)
450 {
451 std::unique_lock<std::mutex> lock(effectMutex_);
452 EFFECT_LOGD("Set input uri");
453 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
454 "SetInputUri: input parameter imageEffect is null!");
455 CHECK_AND_RETURN_RET_LOG(uri != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
456 "SetInputUri: input parameter input uri is null!");
457 CHECK_AND_RETURN_RET_LOG(strlen(uri) < MAX_CHAR_LEN, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
458 "SetInputUri: the length of input parameter uri is too long! len = %{public}zu", strlen(uri));
459
460 ErrorCode errorCode = imageEffect->imageEffect_->SetInputUri(uri);
461 if (errorCode != ErrorCode::SUCCESS) {
462 EFFECT_LOGE("SetInputUri: set input uri fail! errorCode=%{public}d", errorCode);
463 return ImageEffect_ErrorCode::EFFECT_PARAM_ERROR;
464 }
465
466 EventInfo eventInfo = {
467 .dataType = EventDataType::URI,
468 };
469 EventReport::ReportHiSysEvent(INPUT_DATA_TYPE_STATISTIC, eventInfo);
470 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
471 }
472
473 EFFECT_EXPORT
OH_ImageEffect_SetOutputUri(OH_ImageEffect * imageEffect,const char * uri)474 ImageEffect_ErrorCode OH_ImageEffect_SetOutputUri(OH_ImageEffect *imageEffect, const char *uri)
475 {
476 std::unique_lock<std::mutex> lock(effectMutex_);
477 EFFECT_LOGD("Set output uri.");
478 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
479 "SetOutputUri: input parameter imageEffect is null!");
480 CHECK_AND_RETURN_RET_LOG(uri != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
481 "SetOutputUri: input parameter uri is null!");
482 CHECK_AND_RETURN_RET_LOG(strlen(uri) < MAX_CHAR_LEN, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
483 "SetOutputUri: the length of input parameter uri is too long! len = %{public}zu", strlen(uri));
484
485 std::string strUri;
486 if (uri != nullptr) {
487 strUri = uri;
488 }
489 ErrorCode errorCode = imageEffect->imageEffect_->SetOutputUri(strUri);
490 if (errorCode != ErrorCode::SUCCESS) {
491 EFFECT_LOGE("SetOutputUri: set output uri fail! errorCode=%{public}d", errorCode);
492 return ImageEffect_ErrorCode::EFFECT_PARAM_ERROR;
493 }
494
495 EventInfo eventInfo = {
496 .dataType = EventDataType::URI,
497 };
498 EventReport::ReportHiSysEvent(OUTPUT_DATA_TYPE_STATISTIC, eventInfo);
499 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
500 }
501
502 EFFECT_EXPORT
OH_ImageEffect_SetInputPicture(OH_ImageEffect * imageEffect,OH_PictureNative * picture)503 ImageEffect_ErrorCode OH_ImageEffect_SetInputPicture(OH_ImageEffect *imageEffect, OH_PictureNative *picture)
504 {
505 std::unique_lock<std::mutex> lock(effectMutex_);
506 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
507 "SetInputPicture: input parameter imageEffect is null!");
508 CHECK_AND_RETURN_RET_LOG(picture != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
509 "SetInputPicture: input parameter picture is null!");
510
511 ErrorCode errorCode =
512 imageEffect->imageEffect_->SetInputPicture(NativeCommonUtils::GetPictureFromNativePicture(picture));
513 CHECK_AND_RETURN_RET_LOG(errorCode == ErrorCode::SUCCESS, ImageEffect_ErrorCode::EFFECT_PARAM_ERROR,
514 "SetInputPicture: set input picture fail! errorCode=%{public}d", errorCode);
515
516 EventInfo eventInfo = {
517 .dataType = EventDataType::PICTURE,
518 };
519 EventReport::ReportHiSysEvent(INPUT_DATA_TYPE_STATISTIC, eventInfo);
520 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
521 }
522
523 EFFECT_EXPORT
OH_ImageEffect_SetOutputPicture(OH_ImageEffect * imageEffect,OH_PictureNative * picture)524 ImageEffect_ErrorCode OH_ImageEffect_SetOutputPicture(OH_ImageEffect *imageEffect, OH_PictureNative *picture)
525 {
526 std::unique_lock<std::mutex> lock(effectMutex_);
527 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
528 "SetOutputPicture: input parameter imageEffect is null!");
529
530 ErrorCode errorCode =
531 imageEffect->imageEffect_->SetOutputPicture(NativeCommonUtils::GetPictureFromNativePicture(picture));
532 CHECK_AND_RETURN_RET_LOG(errorCode == ErrorCode::SUCCESS, ImageEffect_ErrorCode::EFFECT_PARAM_ERROR,
533 "SetOutputPicture: set output picture fail! errorCode=%{public}d", errorCode);
534
535 EventInfo eventInfo = {
536 .dataType = EventDataType::PICTURE,
537 };
538 EventReport::ReportHiSysEvent(OUTPUT_DATA_TYPE_STATISTIC, eventInfo);
539 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
540 }
541
542 EFFECT_EXPORT
OH_ImageEffect_Start(OH_ImageEffect * imageEffect)543 ImageEffect_ErrorCode OH_ImageEffect_Start(OH_ImageEffect *imageEffect)
544 {
545 std::unique_lock<std::mutex> lock(effectMutex_);
546 if (imageEffect == nullptr) {
547 ImageEffect_ErrorCode errorCode = ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID;
548 NativeCommonUtils::ReportEventStartFailed(errorCode, "OH_ImageEffect_Start: imageEffect is null");
549 EFFECT_LOGE("Start: input parameter imageEffect is null!");
550 return errorCode;
551 }
552
553 ErrorCode errorCode = imageEffect->imageEffect_->Start();
554 if (errorCode != ErrorCode::SUCCESS) {
555 ImageEffect_ErrorCode res = NativeCommonUtils::ConvertStartResult(errorCode);
556 NativeCommonUtils::ReportEventStartFailed(res, "OH_ImageEffect_Start fail!");
557 EFFECT_LOGE("Start: start fail! errorCode=%{public}d", errorCode);
558 return res;
559 }
560
561 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
562 }
563
564 EFFECT_EXPORT
OH_ImageEffect_Stop(OH_ImageEffect * imageEffect)565 ImageEffect_ErrorCode OH_ImageEffect_Stop(OH_ImageEffect *imageEffect)
566 {
567 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
568 "Stop: input parameter imageEffect is null!");
569 imageEffect->imageEffect_->Stop();
570 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
571 }
572
573 EFFECT_EXPORT
OH_ImageEffect_Release(OH_ImageEffect * imageEffect)574 ImageEffect_ErrorCode OH_ImageEffect_Release(OH_ImageEffect *imageEffect)
575 {
576 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
577 "Release: input parameter imageEffect is null!");
578 delete imageEffect;
579 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
580 }
581
582 EFFECT_EXPORT
OH_ImageEffect_Save(OH_ImageEffect * imageEffect,char ** info)583 ImageEffect_ErrorCode OH_ImageEffect_Save(OH_ImageEffect *imageEffect, char **info)
584 {
585 EFFECT_LOGD("Save effect.");
586 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
587 "Save: input parameter imageEffect is null!");
588 CHECK_AND_RETURN_RET_LOG(info != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
589 "Save: input parameter info is null!");
590
591 EffectJsonPtr effectInfo = EffectJsonHelper::CreateObject();
592 imageEffect->imageEffect_->Save(effectInfo);
593 std::string infoStr = effectInfo->ToString();
594
595 char *infoChar = new char[infoStr.length() + 1];
596 imageEffect->saveJson = infoChar;
597 auto ret = strcpy_s(infoChar, infoStr.length() + 1, infoStr.c_str());
598 if (ret != 0) {
599 EFFECT_LOGE("Save: strcpy for infoChar failed, ret is %{public}d", ret);
600 return ImageEffect_ErrorCode::EFFECT_UNKNOWN;
601 }
602 *info = infoChar;
603
604 EventInfo eventInfo;
605 EventReport::ReportHiSysEvent(SAVE_IMAGE_EFFECT_BEHAVIOR, eventInfo);
606 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
607 }
608
609 EFFECT_EXPORT
OH_ImageEffect_Restore(const char * info)610 OH_ImageEffect *OH_ImageEffect_Restore(const char *info)
611 {
612 CHECK_AND_RETURN_RET_LOG(info != nullptr, nullptr, "Restore: input parameter info is null!");
613 CHECK_AND_RETURN_RET_LOG(strlen(info) < MAX_INFO_LEN, nullptr,
614 "Restore: the length of input parameter info is too long! len = %{public}zu", strlen(info));
615 std::string infoStr = info;
616 const EffectJsonPtr root = EffectJsonHelper::ParseJsonData(infoStr);
617 CHECK_AND_RETURN_RET_LOG(root->HasElement("imageEffect"), nullptr, "OH_ImageEffect_Restore no imageEffect");
618 EffectJsonPtr imageInfo = root->GetElement("imageEffect");
619 CHECK_AND_RETURN_RET_LOG(imageInfo != nullptr, nullptr, "OH_ImageEffect_Restore imageInfo is nullptr");
620 CHECK_AND_RETURN_RET_LOG(imageInfo->HasElement("name"), nullptr, "OH_ImageEffect_Restore no name");
621
622 std::string effectName = imageInfo->GetString("name");
623 CHECK_AND_RETURN_RET_LOG(!effectName.empty(), nullptr, "OH_ImageEffect_Restore imageEffect get name failed");
624 OH_ImageEffect* ohImageEffect = OH_ImageEffect_Create(effectName.c_str());
625 CHECK_AND_RETURN_RET_LOG(ohImageEffect != nullptr, nullptr, "ohImageEffect create failed");
626 CHECK_AND_RETURN_RET_LOG(imageInfo->HasElement("filters"), nullptr, "OH_ImageEffect_Restore no filters");
627 EffectJsonPtr filters = imageInfo->GetElement("filters");
628 CHECK_AND_RETURN_RET_LOG(filters != nullptr, nullptr, "OH_ImageEffect_Restore filters is null!");
629 CHECK_AND_RETURN_RET_LOG(filters->IsArray(), nullptr, "OH_ImageEffect_Restore filters not array");
630 std::vector<EffectJsonPtr> effects = filters->GetArray();
631
632 for (auto &effect : effects) {
633 std::string name = effect->GetString("name");
634 CHECK_AND_CONTINUE_LOG(!name.empty(), "Restore: [name] not exist");
635 std::shared_ptr<IFilterDelegate> filterDelegate = EFilterFactory::Instance()->GetDelegate(name);
636 if (filterDelegate != nullptr) {
637 auto *filter = static_cast<OH_EffectFilter *>(filterDelegate->Restore(effect));
638 CHECK_AND_CONTINUE_LOG(filter != nullptr, "Restore: filter restore fail! name=%{public}s", name.c_str());
639 filter->isCreatedBySystem_ = true;
640 ohImageEffect->imageEffect_->AddEFilter(filter->filter_);
641 ohImageEffect->filters_.emplace_back(filter, filter->filter_->GetName());
642 continue;
643 }
644
645 std::unique_ptr<OH_EffectFilter> nativeEFilter = std::make_unique<OH_EffectFilter>();
646 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Restore(name, effect, nativeEFilter.get());
647 CHECK_AND_CONTINUE_LOG(efilter != nullptr, "Restore: efilter restore fail! name=%{public}s", name.c_str());
648 nativeEFilter->filter_ = efilter;
649 nativeEFilter->isCreatedBySystem_ = true;
650 ohImageEffect->filters_.emplace_back(nativeEFilter.release(), efilter->GetName());
651 ohImageEffect->imageEffect_->AddEFilter(efilter);
652 }
653 ohImageEffect->imageEffect_->SetExtraInfo(root);
654
655 EventInfo eventInfo;
656 EventReport::ReportHiSysEvent(RESTORE_IMAGE_EFFECT_BEHAVIOR, eventInfo);
657 return ohImageEffect;
658 }
659
660 EFFECT_EXPORT
OH_ImageEffect_GetFilterCount(OH_ImageEffect * imageEffect)661 int32_t OH_ImageEffect_GetFilterCount(OH_ImageEffect *imageEffect)
662 {
663 std::unique_lock<std::mutex> lock(effectMutex_);
664 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, 0, "GetFilterCount: input parameter imageEffect is null!");
665 return static_cast<int32_t>(imageEffect->filters_.size());
666 }
667
668 EFFECT_EXPORT
OH_ImageEffect_GetFilter(OH_ImageEffect * imageEffect,uint32_t index)669 OH_EffectFilter *OH_ImageEffect_GetFilter(OH_ImageEffect *imageEffect, uint32_t index)
670 {
671 std::unique_lock<std::mutex> lock(effectMutex_);
672 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, nullptr, "GetFilter: input parameter imageEffect is null!");
673 if (index >= static_cast<uint32_t>(imageEffect->filters_.size())) {
674 EFFECT_LOGE("GetFilter: input parameter index is invalid!");
675 return nullptr;
676 }
677 return imageEffect->filters_.at(index).first;
678 }
679
680 #ifdef __cplusplus
681 }
682 #endif