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