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 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 EFFECT_LOGI("effectMutex_ acquired successfully.");
327 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
328 "SetOutputSurface: input parameter imageEffect is null!");
329 CHECK_AND_RETURN_RET_LOG(nativeWindow != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
330 "SetOutputSurface: input parameter nativeWindow is null!");
331
332 ErrorCode errorCode = imageEffect->imageEffect_->SetOutNativeWindow(nativeWindow);
333 if (errorCode != ErrorCode::SUCCESS) {
334 EFFECT_LOGE("SetOutputSurface: set output surface fail! errorCode=%{public}d", errorCode);
335 return ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID;
336 }
337 EFFECT_LOGI("SetOutputSurface: set output surface success!.");
338
339 EventInfo eventInfo = {
340 .dataType = EventDataType::SURFACE,
341 };
342 EventReport::ReportHiSysEvent(INPUT_DATA_TYPE_STATISTIC, eventInfo);
343 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
344 }
345
346 EFFECT_EXPORT
OH_ImageEffect_GetInputSurface(OH_ImageEffect * imageEffect,NativeWindow ** nativeWindow)347 ImageEffect_ErrorCode OH_ImageEffect_GetInputSurface(OH_ImageEffect *imageEffect, NativeWindow **nativeWindow)
348 {
349 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
350 "GetInputSurface: input parameter imageEffect is null!");
351 CHECK_AND_RETURN_RET_LOG(nativeWindow != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
352 "GetInputSurface: input parameter surfaceId is null!");
353
354 OHOS::sptr<OHOS::Surface> surface = imageEffect->imageEffect_->GetInputSurface();
355 CHECK_AND_RETURN_RET_LOG(surface != nullptr, ImageEffect_ErrorCode::EFFECT_UNKNOWN,
356 "GetInputSurface: get input surface fail! surface is null!");
357
358 *nativeWindow = OH_NativeWindow_CreateNativeWindow(&surface);
359
360 EventInfo eventInfo = {
361 .dataType = EventDataType::SURFACE,
362 };
363 EventReport::ReportHiSysEvent(OUTPUT_DATA_TYPE_STATISTIC, eventInfo);
364 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
365 }
366
367 EFFECT_EXPORT
OH_ImageEffect_SetInputPixelmap(OH_ImageEffect * imageEffect,OH_PixelmapNative * pixelmap)368 ImageEffect_ErrorCode OH_ImageEffect_SetInputPixelmap(OH_ImageEffect *imageEffect, OH_PixelmapNative *pixelmap)
369 {
370 std::unique_lock<std::mutex> lock(effectMutex_);
371 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
372 "SetInputPixelmap: input parameter imageEffect is null!");
373 CHECK_AND_RETURN_RET_LOG(pixelmap != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
374 "SetInputPixelmap: input parameter pixelmap is null!");
375
376 ErrorCode errorCode =
377 imageEffect->imageEffect_->SetInputPixelMap(NativeCommonUtils::GetPixelMapFromOHPixelmap(pixelmap));
378 CHECK_AND_RETURN_RET_LOG(errorCode == ErrorCode::SUCCESS, ImageEffect_ErrorCode::EFFECT_PARAM_ERROR,
379 "SetInputPixelMap: set input pixelmap fail! errorCode=%{public}d", errorCode);
380
381 EventInfo eventInfo = {
382 .dataType = EventDataType::PIXEL_MAP,
383 };
384 EventReport::ReportHiSysEvent(INPUT_DATA_TYPE_STATISTIC, eventInfo);
385 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
386 }
387
388 EFFECT_EXPORT
OH_ImageEffect_SetOutputPixelmap(OH_ImageEffect * imageEffect,OH_PixelmapNative * pixelmap)389 ImageEffect_ErrorCode OH_ImageEffect_SetOutputPixelmap(OH_ImageEffect *imageEffect, OH_PixelmapNative *pixelmap)
390 {
391 std::unique_lock<std::mutex> lock(effectMutex_);
392 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
393 "SetOutputPixelmap: input parameter imageEffect is null!");
394
395 ErrorCode errorCode =
396 imageEffect->imageEffect_->SetOutputPixelMap(NativeCommonUtils::GetPixelMapFromOHPixelmap(pixelmap));
397 CHECK_AND_RETURN_RET_LOG(errorCode == ErrorCode::SUCCESS, ImageEffect_ErrorCode::EFFECT_PARAM_ERROR,
398 "SetOutputPixelmap: set output pixelmap fail! errorCode=%{public}d", errorCode);
399
400 EventInfo eventInfo = {
401 .dataType = EventDataType::PIXEL_MAP,
402 };
403 EventReport::ReportHiSysEvent(OUTPUT_DATA_TYPE_STATISTIC, eventInfo);
404 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
405 }
406
407 EFFECT_EXPORT
OH_ImageEffect_SetInputNativeBuffer(OH_ImageEffect * imageEffect,OH_NativeBuffer * nativeBuffer)408 ImageEffect_ErrorCode OH_ImageEffect_SetInputNativeBuffer(OH_ImageEffect *imageEffect, OH_NativeBuffer *nativeBuffer)
409 {
410 std::unique_lock<std::mutex> lock(effectMutex_);
411 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
412 "SetInputNativeBuffer: input parameter imageEffect is null!");
413 CHECK_AND_RETURN_RET_LOG(nativeBuffer != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
414 "SetInputNativeBuffer: input parameter input nativeBuffer is null!");
415
416 OHOS::SurfaceBuffer *surfaceBuffer = OHOS::SurfaceBuffer::NativeBufferToSurfaceBuffer(nativeBuffer);
417
418 ErrorCode errorCode = imageEffect->imageEffect_->SetInputSurfaceBuffer(surfaceBuffer);
419 CHECK_AND_RETURN_RET_LOG(errorCode == ErrorCode::SUCCESS,
420 ImageEffect_ErrorCode::EFFECT_PARAM_ERROR,
421 "SetInputNativeBuffer: set input native buffer fail! errorCode=%{public}d", errorCode);
422
423 EventInfo eventInfo = {
424 .dataType = EventDataType::SURFACE_BUFFER,
425 };
426 EventReport::ReportHiSysEvent(INPUT_DATA_TYPE_STATISTIC, eventInfo);
427 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
428 }
429
430 EFFECT_EXPORT
OH_ImageEffect_SetOutputNativeBuffer(OH_ImageEffect * imageEffect,OH_NativeBuffer * nativeBuffer)431 ImageEffect_ErrorCode OH_ImageEffect_SetOutputNativeBuffer(OH_ImageEffect *imageEffect, OH_NativeBuffer *nativeBuffer)
432 {
433 std::unique_lock<std::mutex> lock(effectMutex_);
434 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
435 "SetOutputNativeBuffer: input parameter imageEffect is null!");
436
437 OHOS::SurfaceBuffer *surfaceBuffer = OHOS::SurfaceBuffer::NativeBufferToSurfaceBuffer(nativeBuffer);
438
439 ErrorCode errorCode = imageEffect->imageEffect_->SetOutputSurfaceBuffer(surfaceBuffer);
440 CHECK_AND_RETURN_RET_LOG(errorCode == ErrorCode::SUCCESS, ImageEffect_ErrorCode::EFFECT_PARAM_ERROR,
441 "SetOutputNativeBuffer: set output native buffer fail! errorCode=%{public}d", errorCode);
442
443 EventInfo eventInfo = {
444 .dataType = EventDataType::SURFACE_BUFFER,
445 };
446 EventReport::ReportHiSysEvent(OUTPUT_DATA_TYPE_STATISTIC, eventInfo);
447 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
448 }
449
450 EFFECT_EXPORT
OH_ImageEffect_SetInputUri(OH_ImageEffect * imageEffect,const char * uri)451 ImageEffect_ErrorCode OH_ImageEffect_SetInputUri(OH_ImageEffect *imageEffect, const char *uri)
452 {
453 std::unique_lock<std::mutex> lock(effectMutex_);
454 EFFECT_LOGD("Set input uri");
455 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
456 "SetInputUri: input parameter imageEffect is null!");
457 CHECK_AND_RETURN_RET_LOG(uri != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
458 "SetInputUri: input parameter input uri is null!");
459 CHECK_AND_RETURN_RET_LOG(strlen(uri) < MAX_CHAR_LEN, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
460 "SetInputUri: the length of input parameter uri is too long! len = %{public}zu", strlen(uri));
461
462 ErrorCode errorCode = imageEffect->imageEffect_->SetInputUri(uri);
463 if (errorCode != ErrorCode::SUCCESS) {
464 EFFECT_LOGE("SetInputUri: set input uri fail! errorCode=%{public}d", errorCode);
465 return ImageEffect_ErrorCode::EFFECT_PARAM_ERROR;
466 }
467
468 EventInfo eventInfo = {
469 .dataType = EventDataType::URI,
470 };
471 EventReport::ReportHiSysEvent(INPUT_DATA_TYPE_STATISTIC, eventInfo);
472 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
473 }
474
475 EFFECT_EXPORT
OH_ImageEffect_SetOutputUri(OH_ImageEffect * imageEffect,const char * uri)476 ImageEffect_ErrorCode OH_ImageEffect_SetOutputUri(OH_ImageEffect *imageEffect, const char *uri)
477 {
478 std::unique_lock<std::mutex> lock(effectMutex_);
479 EFFECT_LOGD("Set output uri.");
480 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
481 "SetOutputUri: input parameter imageEffect is null!");
482 CHECK_AND_RETURN_RET_LOG(uri != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
483 "SetOutputUri: input parameter uri is null!");
484 CHECK_AND_RETURN_RET_LOG(strlen(uri) < MAX_CHAR_LEN, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
485 "SetOutputUri: the length of input parameter uri is too long! len = %{public}zu", strlen(uri));
486
487 std::string strUri;
488 if (uri != nullptr) {
489 strUri = uri;
490 }
491 ErrorCode errorCode = imageEffect->imageEffect_->SetOutputUri(strUri);
492 if (errorCode != ErrorCode::SUCCESS) {
493 EFFECT_LOGE("SetOutputUri: set output uri fail! errorCode=%{public}d", errorCode);
494 return ImageEffect_ErrorCode::EFFECT_PARAM_ERROR;
495 }
496
497 EventInfo eventInfo = {
498 .dataType = EventDataType::URI,
499 };
500 EventReport::ReportHiSysEvent(OUTPUT_DATA_TYPE_STATISTIC, eventInfo);
501 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
502 }
503
504 EFFECT_EXPORT
OH_ImageEffect_SetInputPicture(OH_ImageEffect * imageEffect,OH_PictureNative * picture)505 ImageEffect_ErrorCode OH_ImageEffect_SetInputPicture(OH_ImageEffect *imageEffect, OH_PictureNative *picture)
506 {
507 std::unique_lock<std::mutex> lock(effectMutex_);
508 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
509 "SetInputPicture: input parameter imageEffect is null!");
510 CHECK_AND_RETURN_RET_LOG(picture != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
511 "SetInputPicture: input parameter picture is null!");
512
513 ErrorCode errorCode =
514 imageEffect->imageEffect_->SetInputPicture(NativeCommonUtils::GetPictureFromNativePicture(picture));
515 CHECK_AND_RETURN_RET_LOG(errorCode == ErrorCode::SUCCESS, ImageEffect_ErrorCode::EFFECT_PARAM_ERROR,
516 "SetInputPicture: set input picture fail! errorCode=%{public}d", errorCode);
517
518 EventInfo eventInfo = {
519 .dataType = EventDataType::PICTURE,
520 };
521 EventReport::ReportHiSysEvent(INPUT_DATA_TYPE_STATISTIC, eventInfo);
522 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
523 }
524
525 EFFECT_EXPORT
OH_ImageEffect_SetOutputPicture(OH_ImageEffect * imageEffect,OH_PictureNative * picture)526 ImageEffect_ErrorCode OH_ImageEffect_SetOutputPicture(OH_ImageEffect *imageEffect, OH_PictureNative *picture)
527 {
528 std::unique_lock<std::mutex> lock(effectMutex_);
529 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
530 "SetOutputPicture: input parameter imageEffect is null!");
531
532 ErrorCode errorCode =
533 imageEffect->imageEffect_->SetOutputPicture(NativeCommonUtils::GetPictureFromNativePicture(picture));
534 CHECK_AND_RETURN_RET_LOG(errorCode == ErrorCode::SUCCESS, ImageEffect_ErrorCode::EFFECT_PARAM_ERROR,
535 "SetOutputPicture: set output picture fail! errorCode=%{public}d", errorCode);
536
537 EventInfo eventInfo = {
538 .dataType = EventDataType::PICTURE,
539 };
540 EventReport::ReportHiSysEvent(OUTPUT_DATA_TYPE_STATISTIC, eventInfo);
541 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
542 }
543
544 EFFECT_EXPORT
OH_ImageEffect_SetInputTextureId(OH_ImageEffect * imageEffect,int32_t textureId,int32_t colorSpace)545 ImageEffect_ErrorCode OH_ImageEffect_SetInputTextureId(OH_ImageEffect *imageEffect, int32_t textureId,
546 int32_t colorSpace)
547 {
548 std::unique_lock<std::mutex> lock(effectMutex_);
549 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
550 "SetInputTextureId: input parameter imageEffect is null!");
551 CHECK_AND_RETURN_RET_LOG(textureId > 0, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
552 "SetInputTextureId: input parameter imageEffect is null!");
553 CHECK_AND_RETURN_RET_LOG(colorSpace >= 0, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
554 "SetInputTextureId: input parameter imageEffect is null!");
555 ErrorCode errorCode = imageEffect->imageEffect_->SetInputTexture(textureId, colorSpace);
556 CHECK_AND_RETURN_RET_LOG(errorCode == ErrorCode::SUCCESS, ImageEffect_ErrorCode::EFFECT_PARAM_ERROR,
557 "SetInputTextureId: set output picture fail! errorCode=%{public}d", errorCode);
558 EventInfo eventInfo = {
559 .dataType = EventDataType::TEX,
560 };
561 EventReport::ReportHiSysEvent(INPUT_DATA_TYPE_STATISTIC, eventInfo);
562 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
563 }
564
565 EFFECT_EXPORT
OH_ImageEffect_SetOutputTextureId(OH_ImageEffect * imageEffect,int32_t textureId)566 ImageEffect_ErrorCode OH_ImageEffect_SetOutputTextureId(OH_ImageEffect *imageEffect, int32_t textureId)
567 {
568 std::unique_lock<std::mutex> lock(effectMutex_);
569 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
570 "SetOutputTextureId: output parameter imageEffect is null!");
571 CHECK_AND_RETURN_RET_LOG(textureId > 0, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
572 "SetOutputTextureId: output parameter imageEffect is null!");
573 ErrorCode errorCode = imageEffect->imageEffect_->SetOutputTexture(textureId);
574 CHECK_AND_RETURN_RET_LOG(errorCode == ErrorCode::SUCCESS, ImageEffect_ErrorCode::EFFECT_PARAM_ERROR,
575 "SetOutputTextureId: set output picture fail! errorCode=%{public}d", errorCode);
576 EventInfo eventInfo = {
577 .dataType = EventDataType::TEX,
578 };
579 EventReport::ReportHiSysEvent(OUTPUT_DATA_TYPE_STATISTIC, eventInfo);
580 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
581 }
582
583 EFFECT_EXPORT
OH_ImageEffect_Start(OH_ImageEffect * imageEffect)584 ImageEffect_ErrorCode OH_ImageEffect_Start(OH_ImageEffect *imageEffect)
585 {
586 std::unique_lock<std::mutex> lock(effectMutex_);
587 if (imageEffect == nullptr) {
588 ImageEffect_ErrorCode errorCode = ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID;
589 NativeCommonUtils::ReportEventStartFailed(errorCode, "OH_ImageEffect_Start: imageEffect is null");
590 EFFECT_LOGE("Start: input parameter imageEffect is null!");
591 return errorCode;
592 }
593
594 ErrorCode errorCode = imageEffect->imageEffect_->Start();
595 if (errorCode != ErrorCode::SUCCESS) {
596 ImageEffect_ErrorCode res = NativeCommonUtils::ConvertStartResult(errorCode);
597 NativeCommonUtils::ReportEventStartFailed(res, "OH_ImageEffect_Start fail!");
598 EFFECT_LOGE("Start: start fail! errorCode=%{public}d", errorCode);
599 return res;
600 }
601
602 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
603 }
604
605 EFFECT_EXPORT
OH_ImageEffect_Stop(OH_ImageEffect * imageEffect)606 ImageEffect_ErrorCode OH_ImageEffect_Stop(OH_ImageEffect *imageEffect)
607 {
608 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
609 "Stop: input parameter imageEffect is null!");
610 imageEffect->imageEffect_->Stop();
611 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
612 }
613
614 EFFECT_EXPORT
OH_ImageEffect_Release(OH_ImageEffect * imageEffect)615 ImageEffect_ErrorCode OH_ImageEffect_Release(OH_ImageEffect *imageEffect)
616 {
617 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
618 "Release: input parameter imageEffect is null!");
619 EFFECT_LOGI("Release imageEffect.");
620 delete imageEffect;
621 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
622 }
623
624 EFFECT_EXPORT
OH_ImageEffect_Save(OH_ImageEffect * imageEffect,char ** info)625 ImageEffect_ErrorCode OH_ImageEffect_Save(OH_ImageEffect *imageEffect, char **info)
626 {
627 EFFECT_LOGD("Save effect.");
628 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
629 "Save: input parameter imageEffect is null!");
630 CHECK_AND_RETURN_RET_LOG(info != nullptr, ImageEffect_ErrorCode::EFFECT_ERROR_PARAM_INVALID,
631 "Save: input parameter info is null!");
632
633 EffectJsonPtr effectInfo = EffectJsonHelper::CreateObject();
634 imageEffect->imageEffect_->Save(effectInfo);
635 std::string infoStr = effectInfo->ToString();
636
637 char *infoChar = new char[infoStr.length() + 1];
638 if (imageEffect->saveJson != nullptr) {
639 delete[] imageEffect->saveJson;
640 }
641 imageEffect->saveJson = infoChar;
642 auto ret = strcpy_s(infoChar, infoStr.length() + 1, infoStr.c_str());
643 if (ret != 0) {
644 EFFECT_LOGE("Save: strcpy for infoChar failed, ret is %{public}d", ret);
645 return ImageEffect_ErrorCode::EFFECT_UNKNOWN;
646 }
647 *info = infoChar;
648
649 EventInfo eventInfo;
650 EventReport::ReportHiSysEvent(SAVE_IMAGE_EFFECT_BEHAVIOR, eventInfo);
651 return ImageEffect_ErrorCode::EFFECT_SUCCESS;
652 }
653
654 EFFECT_EXPORT
OH_ImageEffect_Restore(const char * info)655 OH_ImageEffect *OH_ImageEffect_Restore(const char *info)
656 {
657 CHECK_AND_RETURN_RET_LOG(info != nullptr, nullptr, "Restore: input parameter info is null!");
658 CHECK_AND_RETURN_RET_LOG(strlen(info) < MAX_INFO_LEN, nullptr,
659 "Restore: the length of input parameter info is too long! len = %{public}zu", strlen(info));
660 std::string infoStr = info;
661 const EffectJsonPtr root = EffectJsonHelper::ParseJsonData(infoStr);
662 CHECK_AND_RETURN_RET_LOG(root->HasElement("imageEffect"), nullptr, "OH_ImageEffect_Restore no imageEffect");
663 EffectJsonPtr imageInfo = root->GetElement("imageEffect");
664 CHECK_AND_RETURN_RET_LOG(imageInfo != nullptr, nullptr, "OH_ImageEffect_Restore imageInfo is nullptr");
665 CHECK_AND_RETURN_RET_LOG(imageInfo->HasElement("name"), nullptr, "OH_ImageEffect_Restore no name");
666
667 std::string effectName = imageInfo->GetString("name");
668 CHECK_AND_RETURN_RET_LOG(!effectName.empty(), nullptr, "OH_ImageEffect_Restore imageEffect get name failed");
669 OH_ImageEffect* ohImageEffect = OH_ImageEffect_Create(effectName.c_str());
670 CHECK_AND_RETURN_RET_LOG(ohImageEffect != nullptr, nullptr, "ohImageEffect create failed");
671 CHECK_AND_RETURN_RET_LOG(imageInfo->HasElement("filters"), nullptr, "OH_ImageEffect_Restore no filters");
672 EffectJsonPtr filters = imageInfo->GetElement("filters");
673 CHECK_AND_RETURN_RET_LOG(filters != nullptr, nullptr, "OH_ImageEffect_Restore filters is null!");
674 CHECK_AND_RETURN_RET_LOG(filters->IsArray(), nullptr, "OH_ImageEffect_Restore filters not array");
675 std::vector<EffectJsonPtr> effects = filters->GetArray();
676
677 for (auto &effect : effects) {
678 std::string name = effect->GetString("name");
679 CHECK_AND_CONTINUE_LOG(!name.empty(), "Restore: [name] not exist");
680 std::shared_ptr<IFilterDelegate> filterDelegate = EFilterFactory::Instance()->GetDelegate(name);
681 if (filterDelegate != nullptr) {
682 auto *filter = static_cast<OH_EffectFilter *>(filterDelegate->Restore(effect));
683 CHECK_AND_RETURN_RET_LOG(filter != nullptr, nullptr, "Restore: filter restore fail! name=%{public}s",
684 name.c_str());
685 filter->isCreatedBySystem_ = true;
686 ohImageEffect->imageEffect_->AddEFilter(filter->filter_);
687 ohImageEffect->filters_.emplace_back(filter, filter->filter_->GetName());
688 continue;
689 }
690
691 std::unique_ptr<OH_EffectFilter> nativeEFilter = std::make_unique<OH_EffectFilter>();
692 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Restore(name, effect, nativeEFilter.get());
693 CHECK_AND_RETURN_RET_LOG(efilter != nullptr, nullptr, "Restore: efilter restore fail! name=%{public}s",
694 name.c_str());
695 nativeEFilter->filter_ = efilter;
696 nativeEFilter->isCreatedBySystem_ = true;
697 ohImageEffect->filters_.emplace_back(nativeEFilter.release(), efilter->GetName());
698 ohImageEffect->imageEffect_->AddEFilter(efilter);
699 }
700 ohImageEffect->imageEffect_->SetExtraInfo(root);
701
702 EventInfo eventInfo;
703 EventReport::ReportHiSysEvent(RESTORE_IMAGE_EFFECT_BEHAVIOR, eventInfo);
704 return ohImageEffect;
705 }
706
707 EFFECT_EXPORT
OH_ImageEffect_GetFilterCount(OH_ImageEffect * imageEffect)708 int32_t OH_ImageEffect_GetFilterCount(OH_ImageEffect *imageEffect)
709 {
710 std::unique_lock<std::mutex> lock(effectMutex_);
711 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, 0, "GetFilterCount: input parameter imageEffect is null!");
712 return static_cast<int32_t>(imageEffect->filters_.size());
713 }
714
715 EFFECT_EXPORT
OH_ImageEffect_GetFilter(OH_ImageEffect * imageEffect,uint32_t index)716 OH_EffectFilter *OH_ImageEffect_GetFilter(OH_ImageEffect *imageEffect, uint32_t index)
717 {
718 std::unique_lock<std::mutex> lock(effectMutex_);
719 CHECK_AND_RETURN_RET_LOG(imageEffect != nullptr, nullptr, "GetFilter: input parameter imageEffect is null!");
720 if (index >= static_cast<uint32_t>(imageEffect->filters_.size())) {
721 EFFECT_LOGE("GetFilter: input parameter index is invalid!");
722 return nullptr;
723 }
724 return imageEffect->filters_.at(index).first;
725 }
726
727 #ifdef __cplusplus
728 }
729 #endif
730