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 "imageEffect.h"
17
18 #include "napi/native_api.h"
19 #include "utils/common_utils.h"
20 #include "utils/pixelmap_helper.h"
21 #include <bits/alltypes.h>
22 #include <hilog/log.h>
23 #include <multimedia/image_effect/image_effect.h>
24 #include <multimedia/image_effect/image_effect_errors.h>
25 #include <multimedia/image_effect/image_effect_filter.h>
26 #include <multimedia/image_framework/image_pixel_map_mdk.h>
27 #include <multimedia/image_framework/image/picture_native.h>
28 #include <native_window/external_window.h>
29 #include <string>
30
31 #define MY_LOG_DOMAIN 0x0000
32 #define MY_LOG_TAG "ImageEffectNDK"
33 #define LOG(fmt, ...) (void)OH_LOG_Print(LOG_APP, LOG_DEBUG, MY_LOG_DOMAIN, MY_LOG_TAG, fmt, ##__VA_ARGS__)
34
35 #define OH_EFFECT_BRIGHTNESS_FILTER "Brightness"
36 #define OH_EFFECT_CONTRAST_FILTER "Contrast"
37 #define OH_EFFECT_CROP_FILTER "Crop"
38 #define KEY_FILTER_INTENSITY "FilterIntensity"
39 #define IMAGE_EFFECT_NAME "imageEdit"
40 #define CUSTOM_FILTER "CustomCrop"
41
42 #define CASE_INDEX_1 1
43 #define CASE_INDEX_2 2
44 #define CASE_INDEX_3 3
45 #define CASE_INDEX_4 4
46 #define CASE_INDEX_5 5
47 #define CASE_INDEX_6 6
48 #define CASE_INDEX_7 7
49 #define CASE_INDEX_8 8
50 #define CASE_INDEX_9 9
51 #define CASE_INDEX_10 10
52 #define CASE_INDEX_11 11
53
54 #define IMAGE_EFFECT_2 2
55 #define IMAGE_EFFECT_100 100
56 #define IMAGE_EFFECT_100F 100.f
57 #define IMAGE_EFFECT_50F 50.f
58 #define IMAGE_EFFECT_100D 100.0
59 #define IMAGE_EFFECT_1000 1000
60 #define IMAGE_EFFECT_1024 1024
61 #define IMAGE_EFFECT_1048576 1048576
62 #define IMAGE_EFFECT_1073741824 1073741824
63 #define IMAGE_EFFECT_1080 1080
64 #define IMAGE_EFFECT_4090 4090
65 #define IMAGE_EFFECT_5120 5120
66 #define IMAGE_EFFECT_CODE_401 401
67 #define IMAGE_EFFECT_1722514390000 1722514390000
68
69 const std::string g_jpgUri = std::string("file:///data/test/resource/image_effect_1k_test1.jpg");
70 static std::string imagePath;
71 static std::string outImagePath;
72
savePixelMapForPath(napi_env env,napi_callback_info info)73 napi_value savePixelMapForPath(napi_env env, napi_callback_info info)
74 {
75 napi_value result = nullptr;
76 napi_get_undefined(env, &result);
77 size_t argc = 1;
78 napi_value args[1] = {nullptr};
79 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
80 imagePath = CommonUtils::GetStringArgument(env, args[0]);
81 napi_value ret;
82 int status = -1;
83 if (imagePath.length() > 0) {
84 status = 0;
85 }
86 napi_create_int32(env, status, &ret);
87 return ret;
88 }
89
creatOutPixeMapForPath(napi_env env,napi_callback_info info)90 napi_value creatOutPixeMapForPath(napi_env env, napi_callback_info info)
91 {
92 napi_value result = nullptr;
93 napi_get_undefined(env, &result);
94 size_t argc = 1;
95 napi_value args[1] = {nullptr};
96 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
97 outImagePath = CommonUtils::GetStringArgument(env, args[0]);
98 napi_value ret;
99 int status = -1;
100 if (outImagePath.length() > 0) {
101 status = 0;
102 }
103 napi_create_int32(env, status, &ret);
104 return ret;
105 }
106
getFilterDelegate()107 ImageEffect_FilterDelegate getFilterDelegate()
108 {
109 ImageEffect_FilterDelegate filterDelegate = {
110 .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return true; },
111 .render = [](OH_EffectFilter *filter, OH_EffectBufferInfo *info,
112 OH_EffectFilterDelegate_PushData pushData) { return true; },
113 .save = [](OH_EffectFilter *filter, char **info) { return true; },
114 .restore = [](const char *info) {
115 OH_EffectFilter *filter = OH_EffectFilter_Create(CUSTOM_FILTER);
116 return filter;
117 }
118 };
119 return filterDelegate;
120 }
121
122 /**---------------------------------------------- EffectFilterRender ------------------------------------------------**/
OHEffectFilterRender(napi_env env,napi_callback_info info)123 napi_value OHEffectFilterRender(napi_env env, napi_callback_info info)
124 {
125 size_t argc = 1;
126 napi_value args[1] = {nullptr};
127 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
128 int32_t index;
129 napi_get_value_int32(env, args[0], &index);
130 std::shared_ptr<OH_PixelmapNative> pixelmapNativePtr = PixelMapHelper::Decode(imagePath);
131 OH_PixelmapNative *inputPixelmap = pixelmapNativePtr.get();
132 OH_PixelmapNative *outputPixelmap = inputPixelmap;
133 ImageEffect_FilterDelegate filterDelegate = getFilterDelegate();
134 // 创建 OH_EffectFilterInfo 实例
135 OH_EffectFilterInfo *customFilterInfo = OH_EffectFilterInfo_Create();
136 // 设置自定义滤镜滤镜名
137 OH_EffectFilterInfo_SetFilterName(customFilterInfo, CUSTOM_FILTER);
138 // 设置自定义滤镜所支持的内存类型
139 ImageEffect_BufferType bufferTypeArray[] = {ImageEffect_BufferType::EFFECT_BUFFER_TYPE_PIXEL};
140 OH_EffectFilterInfo_SetSupportedBufferTypes(
141 customFilterInfo, sizeof(bufferTypeArray) / sizeof(ImageEffect_BufferType), bufferTypeArray);
142 // 设置自定义滤镜所支持的像素格式
143 ImageEffect_Format formatArray[] = {ImageEffect_Format::EFFECT_PIXEL_FORMAT_RGBA8888};
144 OH_EffectFilterInfo_SetSupportedFormats(customFilterInfo, sizeof(formatArray) / sizeof(ImageEffect_Format),
145 formatArray);
146 // 注册自定义滤镜
147 ImageEffect_ErrorCode errorCode = OH_EffectFilter_Register(customFilterInfo, &filterDelegate);
148 // 创建滤镜。比如：创建对比度效果器
149 OH_EffectFilter *filter = OH_EffectFilter_Create(CUSTOM_FILTER);
150
151 std::shared_ptr<OH_PixelmapNative> outPixePtr = PixelMapHelper::Decode(outImagePath);
152
153 // 生效滤镜效果
154 switch (index) {
155 case CASE_INDEX_1:
156 outputPixelmap = nullptr;
157 break;
158 case CASE_INDEX_2:
159 outputPixelmap = inputPixelmap;
160 break;
161 case CASE_INDEX_3:
162 outputPixelmap = outPixePtr.get();
163 break;
164 default:
165 break;
166 }
167 errorCode = OH_EffectFilter_Render(filter, inputPixelmap, outputPixelmap);
168 OH_EffectFilter_Release(filter);
169 napi_value ret;
170 napi_create_int32(env, errorCode, &ret);
171 return ret;
172 }
173
174 /**-------------------------------------------------- Effect -------------------------------------------------------**/
OHImageEffectCreate(napi_env env,napi_callback_info info)175 napi_value OHImageEffectCreate(napi_env env, napi_callback_info info)
176 {
177 size_t argc = 1;
178 napi_value args[1] = {nullptr};
179 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
180 int32_t index;
181 napi_get_value_int32(env, args[0], &index);
182
183 OH_ImageEffect *imageEffect = nullptr;
184 switch (index) {
185 case CASE_INDEX_1:
186 imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
187 break;
188 case CASE_INDEX_2:
189 imageEffect = OH_ImageEffect_Create(nullptr);
190 break;
191 default:
192 break;
193 }
194
195 int code = IMAGE_EFFECT_CODE_401;
196 if (imageEffect != nullptr) {
197 OH_ImageEffect_Release(imageEffect);
198 code = 0;
199 }
200 napi_value ret;
201 napi_create_int32(env, code, &ret);
202 return ret;
203 }
204
OHImageEffectConfigure(napi_env env,napi_callback_info info)205 napi_value OHImageEffectConfigure(napi_env env, napi_callback_info info)
206 {
207 size_t argc = 1;
208 napi_value args[1] = {nullptr};
209 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
210 int32_t index;
211 napi_get_value_int32(env, args[0], &index);
212
213 OH_ImageEffect *imageEffect = nullptr;
214 const char *key = nullptr;
215 ImageEffect_Any value;
216 switch (index) {
217 case CASE_INDEX_1:
218 imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
219 key = "runningType";
220 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32;
221 value.dataValue.int32Value = IMAGE_EFFECT_2;
222 break;
223 case CASE_INDEX_2:
224 key = "runningType";
225 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
226 value.dataValue.floatValue = IMAGE_EFFECT_100F;
227 imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
228 break;
229 case CASE_INDEX_3:
230 imageEffect = nullptr;
231 key = "runningType";
232 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
233 value.dataValue.floatValue = IMAGE_EFFECT_100F;
234 break;
235 case CASE_INDEX_4:
236 imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
237 key = nullptr;
238 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
239 value.dataValue.floatValue = IMAGE_EFFECT_100F;
240 break;
241 case CASE_INDEX_5:
242 imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
243 key = nullptr;
244 default:
245 break;
246 }
247 ImageEffect_ErrorCode code = OH_ImageEffect_Configure(imageEffect, key, &value);
248 OH_ImageEffect_Release(imageEffect);
249
250 napi_value ret;
251 napi_create_int32(env, code, &ret);
252 return ret;
253 }
254
OHImageEffectAddFilter(napi_env env,napi_callback_info info)255 napi_value OHImageEffectAddFilter(napi_env env, napi_callback_info info)
256 {
257 size_t argc = 1;
258 napi_value args[1] = {nullptr};
259 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
260 int32_t index;
261 napi_get_value_int32(env, args[0], &index);
262
263 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
264 OH_EffectFilter *filter = nullptr;
265 switch (index) {
266 case CASE_INDEX_1:
267 filter = OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_BRIGHTNESS_FILTER);
268 break;
269 case CASE_INDEX_2:
270 filter = OH_ImageEffect_AddFilter(nullptr, OH_EFFECT_BRIGHTNESS_FILTER);
271 break;
272 case CASE_INDEX_3:
273 filter = OH_ImageEffect_AddFilter(imageEffect, nullptr);
274 break;
275 default:
276 break;
277 }
278 OH_ImageEffect_Release(imageEffect);
279
280 int code = IMAGE_EFFECT_CODE_401;
281 if (filter != nullptr) {
282 code = 0;
283 }
284 napi_value ret;
285 napi_create_int32(env, code, &ret);
286 return ret;
287 }
288
OHImageEffectAddFilterByFilter(napi_env env,napi_callback_info info)289 napi_value OHImageEffectAddFilterByFilter(napi_env env, napi_callback_info info)
290 {
291 size_t argc = 1;
292 napi_value args[1] = {nullptr};
293 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
294 int32_t index;
295 napi_get_value_int32(env, args[0], &index);
296
297 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
298 ImageEffect_ErrorCode errorCode = ImageEffect_ErrorCode::EFFECT_SUCCESS;
299 OH_EffectFilter *filter = OH_EffectFilter_Create(OH_EFFECT_BRIGHTNESS_FILTER);
300 switch (index) {
301 case CASE_INDEX_1:
302 errorCode = OH_ImageEffect_AddFilterByFilter(imageEffect, filter);
303 break;
304 case CASE_INDEX_2:
305 errorCode = OH_ImageEffect_AddFilterByFilter(nullptr, filter);
306 break;
307 case CASE_INDEX_3:
308 errorCode = OH_ImageEffect_AddFilterByFilter(imageEffect, nullptr);
309 break;
310 default:
311 break;
312 }
313 OH_EffectFilter_Release(filter);
314 OH_ImageEffect_Release(imageEffect);
315
316 napi_value ret;
317 napi_create_int32(env, errorCode, &ret);
318 return ret;
319 }
320
OHImageEffectGetFilter(napi_env env,napi_callback_info info)321 napi_value OHImageEffectGetFilter(napi_env env, napi_callback_info info)
322 {
323 size_t argc = 1;
324 napi_value args[1] = {nullptr};
325 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
326 int32_t index;
327 napi_get_value_int32(env, args[0], &index);
328
329 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
330 OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_BRIGHTNESS_FILTER);
331 int32_t getFilterIndex;
332 switch (index) {
333 case CASE_INDEX_1:
334 getFilterIndex = 0;
335 break;
336 case CASE_INDEX_2:
337 getFilterIndex = 1;
338 break;
339 default:
340 break;
341 }
342 OH_EffectFilter *getFilter = OH_ImageEffect_GetFilter(imageEffect, getFilterIndex);
343 OH_ImageEffect_Release(imageEffect);
344
345 int status = IMAGE_EFFECT_CODE_401;
346 if (getFilter != nullptr) {
347 status = 0;
348 }
349 napi_value ret;
350 napi_create_int32(env, status, &ret);
351 return ret;
352 }
353
OHImageEffectGetFilterCount(napi_env env,napi_callback_info info)354 napi_value OHImageEffectGetFilterCount(napi_env env, napi_callback_info info)
355 {
356 size_t argc = 1;
357 napi_value args[1] = {nullptr};
358 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
359 int32_t index;
360 napi_get_value_int32(env, args[0], &index);
361
362 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
363 int32_t count = 0;
364 switch (index) {
365 case CASE_INDEX_1:
366 OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_BRIGHTNESS_FILTER);
367 count = OH_ImageEffect_GetFilterCount(imageEffect);
368 break;
369 case CASE_INDEX_2:
370 OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_BRIGHTNESS_FILTER);
371 OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_CONTRAST_FILTER);
372 count = OH_ImageEffect_GetFilterCount(imageEffect);
373 break;
374 case CASE_INDEX_3:
375 OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_BRIGHTNESS_FILTER);
376 OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_CONTRAST_FILTER);
377 OH_ImageEffect_RemoveFilter(imageEffect, OH_EFFECT_CONTRAST_FILTER);
378 count = OH_ImageEffect_GetFilterCount(imageEffect);
379 break;
380 case CASE_INDEX_4:
381 count = OH_ImageEffect_GetFilterCount(nullptr);
382 break;
383 default:
384 break;
385 }
386 OH_ImageEffect_Release(imageEffect);
387
388 int status = IMAGE_EFFECT_CODE_401;
389 if (count >= 0) {
390 status = 0;
391 }
392 napi_value ret;
393 napi_create_int32(env, status, &ret);
394 return ret;
395 }
396
OHImageEffectGetInputSurface(napi_env env,napi_callback_info info)397 napi_value OHImageEffectGetInputSurface(napi_env env, napi_callback_info info)
398 {
399 size_t argc = 1;
400 napi_value args[1] = {nullptr};
401 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
402 int32_t index;
403 napi_get_value_int32(env, args[0], &index);
404
405 OH_ImageEffect *imageEffect = nullptr;
406 switch (index) {
407 case CASE_INDEX_1:
408 imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
409 break;
410 case CASE_INDEX_2:
411 imageEffect = nullptr;
412 break;
413 default:
414 break;
415 }
416 OHNativeWindow *nativeWindow = nullptr;
417 ImageEffect_ErrorCode code = OH_ImageEffect_GetInputSurface(imageEffect, &nativeWindow);
418 OH_ImageEffect_Release(imageEffect);
419
420 napi_value ret;
421 napi_create_int32(env, code, &ret);
422 return ret;
423 }
424
OHImageEffectInsertFilter(napi_env env,napi_callback_info info)425 napi_value OHImageEffectInsertFilter(napi_env env, napi_callback_info info)
426 {
427 size_t argc = 1;
428 napi_value args[1] = {nullptr};
429 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
430 int32_t index;
431 napi_get_value_int32(env, args[0], &index);
432
433 OH_EffectFilter *insertFilter = nullptr;
434 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
435 switch (index) {
436 case CASE_INDEX_1:
437 insertFilter = OH_ImageEffect_InsertFilter(imageEffect, 1, OH_EFFECT_BRIGHTNESS_FILTER);
438 break;
439 case CASE_INDEX_2:
440 insertFilter = OH_ImageEffect_InsertFilter(nullptr, 0, OH_EFFECT_BRIGHTNESS_FILTER);
441 break;
442 case CASE_INDEX_3:
443 insertFilter = OH_ImageEffect_InsertFilter(imageEffect, -1, OH_EFFECT_BRIGHTNESS_FILTER);
444 break;
445 case CASE_INDEX_4:
446 insertFilter = OH_ImageEffect_InsertFilter(imageEffect, 0, nullptr);
447 break;
448 default:
449 break;
450 }
451 OH_ImageEffect_Release(imageEffect);
452
453 int status = IMAGE_EFFECT_CODE_401;
454 if (insertFilter != nullptr) {
455 status = 0;
456 }
457 napi_value ret;
458 napi_create_int32(env, status, &ret);
459 return ret;
460 }
461
OHImageEffectInsertFilterByFilter(napi_env env,napi_callback_info info)462 napi_value OHImageEffectInsertFilterByFilter(napi_env env, napi_callback_info info)
463 {
464 size_t argc = 1;
465 napi_value args[1] = {nullptr};
466 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
467 int32_t index;
468 napi_get_value_int32(env, args[0], &index);
469
470 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
471 OH_EffectFilter *filter = OH_EffectFilter_Create(OH_EFFECT_BRIGHTNESS_FILTER);
472 ImageEffect_ErrorCode errorCode = ImageEffect_ErrorCode::EFFECT_SUCCESS;
473 switch (index) {
474 case CASE_INDEX_1:
475 errorCode = OH_ImageEffect_InsertFilterByFilter(imageEffect, 1, filter);
476 break;
477 case CASE_INDEX_2:
478 errorCode = OH_ImageEffect_InsertFilterByFilter(nullptr, 0, filter);
479 break;
480 case CASE_INDEX_3:
481 errorCode = OH_ImageEffect_InsertFilterByFilter(imageEffect, -1, filter);
482 break;
483 case CASE_INDEX_4:
484 errorCode = OH_ImageEffect_InsertFilterByFilter(imageEffect, 0, nullptr);
485 break;
486 default:
487 break;
488 }
489 OH_EffectFilter_Release(filter);
490 OH_ImageEffect_Release(imageEffect);
491
492 napi_value ret;
493 napi_create_int32(env, errorCode, &ret);
494 return ret;
495 }
496
OHImageEffectReplaceFilter(napi_env env,napi_callback_info info)497 napi_value OHImageEffectReplaceFilter(napi_env env, napi_callback_info info)
498 {
499 size_t argc = 1;
500 napi_value args[1] = {nullptr};
501 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
502 int32_t index;
503 napi_get_value_int32(env, args[0], &index);
504
505 OH_EffectFilter *replaceFilter = nullptr;
506 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
507 OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_CONTRAST_FILTER);
508 switch (index) {
509 case CASE_INDEX_1:
510 replaceFilter = OH_ImageEffect_ReplaceFilter(imageEffect, 0, OH_EFFECT_BRIGHTNESS_FILTER);
511 break;
512 case CASE_INDEX_2:
513 replaceFilter = OH_ImageEffect_ReplaceFilter(nullptr, 0, OH_EFFECT_BRIGHTNESS_FILTER);
514 break;
515 case CASE_INDEX_3:
516 replaceFilter = OH_ImageEffect_ReplaceFilter(imageEffect, -1, OH_EFFECT_BRIGHTNESS_FILTER);
517 break;
518 case CASE_INDEX_4:
519 replaceFilter = OH_ImageEffect_ReplaceFilter(imageEffect, 0, nullptr);
520 break;
521 default:
522 break;
523 }
524 OH_ImageEffect_Release(imageEffect);
525
526 int status = IMAGE_EFFECT_CODE_401;
527 if (replaceFilter != nullptr) {
528 status = 0;
529 }
530 napi_value ret;
531 napi_create_int32(env, status, &ret);
532 return ret;
533 }
534
OHImageEffectReplaceFilterByFilter(napi_env env,napi_callback_info info)535 napi_value OHImageEffectReplaceFilterByFilter(napi_env env, napi_callback_info info)
536 {
537 size_t argc = 1;
538 napi_value args[1] = {nullptr};
539 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
540 int32_t index;
541 napi_get_value_int32(env, args[0], &index);
542
543 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
544 OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_CONTRAST_FILTER);
545 OH_EffectFilter *filter = OH_EffectFilter_Create(OH_EFFECT_BRIGHTNESS_FILTER);
546 ImageEffect_ErrorCode errorCode = ImageEffect_ErrorCode::EFFECT_SUCCESS;
547 switch (index) {
548 case CASE_INDEX_1:
549 OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_CONTRAST_FILTER);
550 errorCode = OH_ImageEffect_ReplaceFilterByFilter(imageEffect, 0, filter);
551 break;
552 case CASE_INDEX_2:
553 errorCode = OH_ImageEffect_ReplaceFilterByFilter(nullptr, 0, filter);
554 break;
555 case CASE_INDEX_3:
556 errorCode = OH_ImageEffect_ReplaceFilterByFilter(imageEffect, -1, filter);
557 break;
558 case CASE_INDEX_4:
559 errorCode = OH_ImageEffect_ReplaceFilterByFilter(imageEffect, 0, nullptr);
560 break;
561 default:
562 break;
563 }
564 OH_EffectFilter_Release(filter);
565 OH_ImageEffect_Release(imageEffect);
566
567 napi_value ret;
568 napi_create_int32(env, errorCode, &ret);
569 return ret;
570 }
571
OHImageEffectRelease(napi_env env,napi_callback_info info)572 napi_value OHImageEffectRelease(napi_env env, napi_callback_info info)
573 {
574 size_t argc = 1;
575 napi_value args[1] = {nullptr};
576 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
577 int32_t index;
578 napi_get_value_int32(env, args[0], &index);
579
580 OH_ImageEffect *imageEffect = nullptr;
581 switch (index) {
582 case CASE_INDEX_1:
583 imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
584 break;
585 case CASE_INDEX_2:
586 imageEffect = nullptr;
587 break;
588 default:
589 break;
590 }
591 ImageEffect_ErrorCode code = OH_ImageEffect_Release(imageEffect);
592 napi_value ret;
593 napi_create_int32(env, code, &ret);
594 return ret;
595 }
596
OHImageEffectRemoveFilter(napi_env env,napi_callback_info info)597 napi_value OHImageEffectRemoveFilter(napi_env env, napi_callback_info info)
598 {
599 size_t argc = 1;
600 napi_value args[1] = {nullptr};
601 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
602 int32_t index;
603 napi_get_value_int32(env, args[0], &index);
604
605 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
606 int32_t result;
607 switch (index) {
608 case CASE_INDEX_1:
609 OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_BRIGHTNESS_FILTER);
610 result = OH_ImageEffect_RemoveFilter(imageEffect, OH_EFFECT_BRIGHTNESS_FILTER);
611 break;
612 case CASE_INDEX_2:
613 OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_BRIGHTNESS_FILTER);
614 OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_CROP_FILTER);
615 result = OH_ImageEffect_RemoveFilter(imageEffect, OH_EFFECT_CROP_FILTER);
616 break;
617 case CASE_INDEX_3:
618 result = OH_ImageEffect_RemoveFilter(imageEffect, OH_EFFECT_BRIGHTNESS_FILTER);
619 break;
620 default:
621 break;
622 }
623 OH_ImageEffect_Release(imageEffect);
624
625 napi_value ret;
626 int32_t status = IMAGE_EFFECT_CODE_401;
627 if (result > 0) {
628 status = 0;
629 }
630 napi_create_int32(env, status, &ret);
631 return ret;
632 }
633
OHImageEffectRemoveFilterByIndex(napi_env env,napi_callback_info info)634 napi_value OHImageEffectRemoveFilterByIndex(napi_env env, napi_callback_info info)
635 {
636 size_t argc = 1;
637 napi_value args[1] = {nullptr};
638 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
639 int32_t index;
640 napi_get_value_int32(env, args[0], &index);
641
642 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
643 int32_t errorCode = ImageEffect_ErrorCode::EFFECT_SUCCESS;
644 OH_EffectFilter *brightnessFilter = OH_EffectFilter_Create(OH_EFFECT_BRIGHTNESS_FILTER);
645 switch (index) {
646 case CASE_INDEX_1:
647 OH_ImageEffect_AddFilterByFilter(imageEffect, brightnessFilter);
648 errorCode = OH_ImageEffect_RemoveFilterByIndex(imageEffect, 0);
649 break;
650 case CASE_INDEX_2:
651 OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_CONTRAST_FILTER);
652 OH_ImageEffect_AddFilterByFilter(imageEffect, brightnessFilter);
653 errorCode = OH_ImageEffect_RemoveFilterByIndex(imageEffect, 1);
654 errorCode |= OH_ImageEffect_RemoveFilterByIndex(imageEffect, 0);
655 break;
656 case CASE_INDEX_3:
657 errorCode = OH_ImageEffect_RemoveFilterByIndex(imageEffect, 0);
658 break;
659 default:
660 break;
661 }
662 OH_EffectFilter_Release(brightnessFilter);
663 OH_ImageEffect_Release(imageEffect);
664
665 napi_value ret;
666 napi_create_int32(env, errorCode, &ret);
667 return ret;
668 }
669
OHImageEffectSave(napi_env env,napi_callback_info info)670 napi_value OHImageEffectSave(napi_env env, napi_callback_info info)
671 {
672 size_t argc = 1;
673 napi_value args[1] = {nullptr};
674 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
675 int32_t index;
676 napi_get_value_int32(env, args[0], &index);
677
678 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
679 ImageEffect_ErrorCode code;
680 char *imageEffectInfo = nullptr;
681 switch (index) {
682 case CASE_INDEX_1:
683 code = OH_ImageEffect_Save(imageEffect, &imageEffectInfo);
684 break;
685 case CASE_INDEX_2:
686 code = OH_ImageEffect_Save(nullptr, &imageEffectInfo);
687 break;
688 case CASE_INDEX_3:
689 code = OH_ImageEffect_Save(imageEffect, nullptr);
690 break;
691 default:
692 break;
693 }
694 OH_ImageEffect_Release(imageEffect);
695
696 napi_value ret;
697 napi_create_int32(env, code, &ret);
698 return ret;
699 }
700
OHImageEffectRestore(napi_env env,napi_callback_info info)701 napi_value OHImageEffectRestore(napi_env env, napi_callback_info info)
702 {
703 size_t argc = 1;
704 napi_value args[1] = {nullptr};
705 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
706 int32_t index;
707 napi_get_value_int32(env, args[0], &index);
708
709 OH_ImageEffect *saveImageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
710 OH_ImageEffect *restoreImageEffect = nullptr;
711 char *imageEffectInfo = nullptr;
712 switch (index) {
713 case CASE_INDEX_1:
714 OH_ImageEffect_Save(saveImageEffect, &imageEffectInfo);
715 restoreImageEffect = OH_ImageEffect_Restore(imageEffectInfo);
716 break;
717 case CASE_INDEX_2:
718 restoreImageEffect = OH_ImageEffect_Restore("");
719 break;
720 case CASE_INDEX_3:
721 restoreImageEffect = OH_ImageEffect_Restore(nullptr);
722 break;
723 default:
724 break;
725 }
726
727 int32_t code = 401;
728 if (restoreImageEffect != nullptr) {
729 code = 0;
730 }
731 napi_value ret = nullptr;
732 napi_create_int32(env, code, &ret);
733 return ret;
734 }
735
736 OH_NativeBuffer_Config config{
737 .width = 0x100,
738 .height = 0x100,
739 };
740
OHImageEffectSetInputNativeBuffer(napi_env env,napi_callback_info info)741 napi_value OHImageEffectSetInputNativeBuffer(napi_env env, napi_callback_info info)
742 {
743 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
744 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_BRIGHTNESS_FILTER);
745
746 ImageEffect_Any value;
747 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
748 value.dataValue.floatValue = IMAGE_EFFECT_100F;
749 ImageEffect_ErrorCode code = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
750
751 OH_NativeBuffer *buffer = (OH_NativeBuffer *)0x1;
752 code = OH_ImageEffect_SetInputNativeBuffer(imageEffect, buffer);
753 napi_value ret;
754 napi_create_int32(env, code, &ret);
755 return ret;
756 }
757
OHImageEffectSetInputPixelmap(napi_env env,napi_callback_info info)758 napi_value OHImageEffectSetInputPixelmap(napi_env env, napi_callback_info info)
759 {
760 size_t argc = 1;
761 napi_value args[1] = {nullptr};
762 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
763 int32_t index;
764 napi_get_value_int32(env, args[0], &index);
765
766 std::shared_ptr<OH_PixelmapNative> pixelmapNativePtr = PixelMapHelper::Decode(imagePath);
767 OH_PixelmapNative *inputPixelmap = pixelmapNativePtr.get();
768 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
769 ImageEffect_ErrorCode code = EFFECT_UNKNOWN;
770 switch (index) {
771 case CASE_INDEX_1:
772 code = OH_ImageEffect_SetInputPixelmap(imageEffect, inputPixelmap);
773 break;
774 case CASE_INDEX_2:
775 code = OH_ImageEffect_SetInputPixelmap(nullptr, inputPixelmap);
776 break;
777 case CASE_INDEX_3:
778 code = OH_ImageEffect_SetInputPixelmap(imageEffect, nullptr);
779 break;
780 default:
781 break;
782 }
783 OH_ImageEffect_Release(imageEffect);
784 napi_value ret;
785 napi_create_int32(env, code, &ret);
786 return ret;
787 }
788
SetInputUri1(int32_t index,OH_ImageEffect * imageEffect,OH_EffectFilter * filter)789 ImageEffect_ErrorCode SetInputUri1(int32_t index, OH_ImageEffect *imageEffect, OH_EffectFilter *filter)
790 {
791 ImageEffect_Any value;
792 ImageEffect_ErrorCode code;
793 switch (index) {
794 case CASE_INDEX_1:
795 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32;
796 value.dataValue.int32Value = INT32_MIN;
797 code = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
798 code = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str());
799 break;
800 case CASE_INDEX_2:
801 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
802 value.dataValue.floatValue = IMAGE_EFFECT_100F;
803 code = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
804 code = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str());
805 break;
806 case CASE_INDEX_3:
807 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_DOUBLE;
808 value.dataValue.doubleValue = IMAGE_EFFECT_100D;
809 code = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
810 code = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str());
811 break;
812 case CASE_INDEX_4:
813 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_CHAR;
814 value.dataValue.charValue = 'A';
815 code = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
816 code = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str());
817 break;
818 default:
819 break;
820 }
821 return code;
822 }
823
SetInputUri2(int32_t index,OH_ImageEffect * imageEffect,OH_EffectFilter * filter)824 ImageEffect_ErrorCode SetInputUri2(int32_t index, OH_ImageEffect *imageEffect, OH_EffectFilter *filter)
825 {
826 ImageEffect_Any value;
827 ImageEffect_ErrorCode code;
828 switch (index) {
829 case CASE_INDEX_5:
830 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_LONG;
831 value.dataValue.longValue = 100L;
832 code = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
833 code = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str());
834 break;
835 case CASE_INDEX_6:
836 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_BOOL;
837 value.dataValue.boolValue = true;
838 code = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
839 code = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str());
840 break;
841 case CASE_INDEX_7:
842 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_PTR;
843 value.dataValue.ptrValue = nullptr;
844 code = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
845 code = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str());
846 break;
847 case CASE_INDEX_8:
848 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32;
849 value.dataValue.int32Value = IMAGE_EFFECT_100;
850 code = OH_EffectFilter_SetValue(filter, nullptr, &value);
851 code = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str());
852 break;
853 default:
854 break;
855 }
856 return code;
857 }
858
OHImageEffectSetInputUri(napi_env env,napi_callback_info info)859 napi_value OHImageEffectSetInputUri(napi_env env, napi_callback_info info)
860 {
861 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
862 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_BRIGHTNESS_FILTER);
863 size_t argc = 1;
864 napi_value args[1] = {nullptr};
865 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
866 int32_t index;
867 napi_get_value_int32(env, args[0], &index);
868 ImageEffect_Any value;
869 ImageEffect_ErrorCode code;
870 switch (index) {
871 case CASE_INDEX_1:
872 case CASE_INDEX_2:
873 case CASE_INDEX_3:
874 case CASE_INDEX_4:
875 code = SetInputUri1(index, imageEffect, filter);
876 break;
877 case CASE_INDEX_5:
878 case CASE_INDEX_6:
879 case CASE_INDEX_7:
880 case CASE_INDEX_8:
881 code = SetInputUri2(index, imageEffect, filter);
882 break;
883 case CASE_INDEX_9:
884 code = OH_ImageEffect_SetInputUri(nullptr, nullptr);
885 break;
886 case CASE_INDEX_10:
887 code = OH_ImageEffect_SetInputUri(nullptr, g_jpgUri.c_str());
888 break;
889 case CASE_INDEX_11:
890 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32;
891 value.dataValue.int32Value = IMAGE_EFFECT_100;
892 code = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
893 code = OH_ImageEffect_SetInputUri(imageEffect, nullptr);
894 break;
895 default:
896 break;
897 }
898 OH_ImageEffect_Release(imageEffect);
899 napi_value ret;
900 napi_create_int32(env, code, &ret);
901 return ret;
902 }
903
OHImageEffectSetOutputNativeBuffer(napi_env env,napi_callback_info info)904 napi_value OHImageEffectSetOutputNativeBuffer(napi_env env, napi_callback_info info)
905 {
906 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
907 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_BRIGHTNESS_FILTER);
908
909 ImageEffect_Any value;
910 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
911 value.dataValue.floatValue = IMAGE_EFFECT_100F;
912 ImageEffect_ErrorCode code = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
913
914 OH_NativeBuffer *nativeBuffer = (OH_NativeBuffer *)0x1;
915 if (code == EFFECT_SUCCESS) {
916 code = OH_ImageEffect_SetInputNativeBuffer(imageEffect, nativeBuffer);
917 }
918 OH_NativeBuffer *outNativeBuffer = (OH_NativeBuffer *)0x2;
919 if (code == EFFECT_SUCCESS) {
920 code = OH_ImageEffect_SetOutputNativeBuffer(imageEffect, outNativeBuffer);
921 }
922 napi_value ret;
923 napi_create_int32(env, code, &ret);
924 return ret;
925 }
926
OHImageEffectSetOutputPixelmap(napi_env env,napi_callback_info info)927 napi_value OHImageEffectSetOutputPixelmap(napi_env env, napi_callback_info info)
928 {
929 size_t argc = 1;
930 napi_value args[1] = {nullptr};
931 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
932 int32_t index;
933 napi_get_value_int32(env, args[0], &index);
934
935 std::shared_ptr<OH_PixelmapNative> pixelmapNativePtr = PixelMapHelper::Decode(imagePath);
936 OH_PixelmapNative *outputPixelmap = pixelmapNativePtr.get();
937 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
938 ImageEffect_ErrorCode code = EFFECT_UNKNOWN;
939 switch (index) {
940 case CASE_INDEX_1:
941 code = OH_ImageEffect_SetOutputPixelmap(imageEffect, outputPixelmap);
942 break;
943 case CASE_INDEX_2:
944 code = OH_ImageEffect_SetOutputPixelmap(nullptr, outputPixelmap);
945 break;
946 case CASE_INDEX_3:
947 code = OH_ImageEffect_SetOutputPixelmap(imageEffect, nullptr);
948 break;
949 default:
950 break;
951 }
952 OH_ImageEffect_Release(imageEffect);
953 napi_value ret;
954 napi_create_int32(env, code, &ret);
955 return ret;
956 }
957
OHImageEffectSetOutputSurface(napi_env env,napi_callback_info info)958 napi_value OHImageEffectSetOutputSurface(napi_env env, napi_callback_info info)
959 {
960 size_t argc = 1;
961 napi_value args[1] = {nullptr};
962 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
963 int32_t index;
964 napi_get_value_int32(env, args[0], &index);
965
966 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
967 OHNativeWindow *nativeWindow = nullptr;
968 ImageEffect_ErrorCode code;
969 switch (index) {
970 case CASE_INDEX_1:
971 OH_ImageEffect_GetInputSurface(imageEffect, &nativeWindow);
972 code = OH_ImageEffect_SetOutputSurface(imageEffect, nativeWindow);
973 break;
974 case CASE_INDEX_2:
975 OH_ImageEffect_GetInputSurface(imageEffect, &nativeWindow);
976 code = OH_ImageEffect_SetOutputSurface(nullptr, nativeWindow);
977 break;
978 default:
979 break;
980 }
981
982 napi_value ret;
983 napi_create_int32(env, code, &ret);
984 return ret;
985 }
986
SetInputUri3(int32_t index,OH_ImageEffect * imageEffect,OH_EffectFilter * filter)987 ImageEffect_ErrorCode SetInputUri3(int32_t index, OH_ImageEffect *imageEffect, OH_EffectFilter *filter)
988 {
989 ImageEffect_Any value;
990 ImageEffect_ErrorCode code;
991 switch (index) {
992 case CASE_INDEX_1:
993 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32;
994 value.dataValue.int32Value = INT32_MIN;
995 code = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
996 code = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str());
997 break;
998 case CASE_INDEX_2:
999 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
1000 value.dataValue.floatValue = IMAGE_EFFECT_100F;
1001 code = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
1002 code = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str());
1003 break;
1004 case CASE_INDEX_3:
1005 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_DOUBLE;
1006 value.dataValue.doubleValue = IMAGE_EFFECT_100D;
1007 code = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
1008 code = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str());
1009 break;
1010 case CASE_INDEX_4:
1011 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_CHAR;
1012 value.dataValue.charValue = 'A';
1013 code = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
1014 code = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str());
1015 break;
1016 default:
1017 break;
1018 }
1019 return code;
1020 }
1021
SetInputUri4(int32_t index,OH_ImageEffect * imageEffect,OH_EffectFilter * filter)1022 ImageEffect_ErrorCode SetInputUri4(int32_t index, OH_ImageEffect *imageEffect, OH_EffectFilter *filter)
1023 {
1024 ImageEffect_Any value;
1025 ImageEffect_ErrorCode code;
1026 switch (index) {
1027 case CASE_INDEX_5:
1028 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_LONG;
1029 value.dataValue.longValue = 100L;
1030 code = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
1031 code = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str());
1032 break;
1033 case CASE_INDEX_6:
1034 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_BOOL;
1035 value.dataValue.boolValue = true;
1036 code = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
1037 code = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str());
1038 break;
1039 case CASE_INDEX_7:
1040 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_PTR;
1041 value.dataValue.ptrValue = nullptr;
1042 code = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
1043 code = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str());
1044 break;
1045 case CASE_INDEX_8:
1046 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32;
1047 value.dataValue.int32Value = IMAGE_EFFECT_100;
1048 code = OH_EffectFilter_SetValue(filter, nullptr, &value);
1049 code = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str());
1050 break;
1051 default:
1052 break;
1053 }
1054 return code;
1055 }
1056
OHImageEffectSetOutputUri(napi_env env,napi_callback_info info)1057 napi_value OHImageEffectSetOutputUri(napi_env env, napi_callback_info info)
1058 {
1059 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
1060 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_BRIGHTNESS_FILTER);
1061 size_t argc = 1;
1062 napi_value args[1] = {nullptr};
1063 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1064 int32_t index;
1065 napi_get_value_int32(env, args[0], &index);
1066 ImageEffect_Any value;
1067 ImageEffect_ErrorCode code;
1068 switch (index) {
1069 case CASE_INDEX_1:
1070 case CASE_INDEX_2:
1071 case CASE_INDEX_3:
1072 case CASE_INDEX_4:
1073 code = SetInputUri3(index, imageEffect, filter);
1074 break;
1075 case CASE_INDEX_5:
1076 case CASE_INDEX_6:
1077 case CASE_INDEX_7:
1078 case CASE_INDEX_8:
1079 code = SetInputUri4(index, imageEffect, filter);
1080 break;
1081 case CASE_INDEX_9:
1082 code = OH_ImageEffect_SetInputUri(nullptr, nullptr);
1083 break;
1084 case CASE_INDEX_10:
1085 code = OH_ImageEffect_SetInputUri(nullptr, g_jpgUri.c_str());
1086 break;
1087 case CASE_INDEX_11:
1088 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32;
1089 value.dataValue.int32Value = IMAGE_EFFECT_100;
1090 code = OH_EffectFilter_SetValue(filter, nullptr, &value);
1091 code = OH_ImageEffect_SetInputUri(imageEffect, nullptr);
1092 break;
1093 default:
1094 break;
1095 }
1096 if (code == EFFECT_SUCCESS) {
1097 code = OH_ImageEffect_SetOutputUri(imageEffect, g_jpgUri.c_str());
1098 }
1099 OH_ImageEffect_Release(imageEffect);
1100 napi_value ret;
1101 napi_create_int32(env, code, &ret);
1102 return ret;
1103 }
1104
OHImageEffectStart(napi_env env,napi_callback_info info)1105 napi_value OHImageEffectStart(napi_env env, napi_callback_info info)
1106 {
1107 std::shared_ptr<OH_PixelmapNative> pixelmapNativePtr = PixelMapHelper::Decode(imagePath);
1108
1109 OH_PixelmapNative *inputPixelmap = pixelmapNativePtr.get();
1110 OH_PixelmapNative *outputPixelmap = inputPixelmap;
1111
1112 // 1、创建imageEffect实例，“ImageEdit”是imageEffect实例别名。
1113 OH_ImageEffect *imageEffect = OH_ImageEffect_Create("ImageEdit");
1114
1115 // 2、添加滤镜，多次调用该接口可以添加多个滤镜，组成滤镜链。
1116 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_BRIGHTNESS_FILTER);
1117
1118 // 3、设置滤镜参数, 滤镜强度设置为50
1119 ImageEffect_Any value;
1120 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
1121 value.dataValue.floatValue = IMAGE_EFFECT_50F;
1122 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
1123
1124 // 4、设置输入的Pixelmap
1125 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, inputPixelmap);
1126 if (errorCode != EFFECT_SUCCESS) {
1127 napi_value ret;
1128 napi_create_int32(env, errorCode, &ret);
1129 return ret;
1130 }
1131 // 5、设置输出的Pixelmap（可选），不调用该接口时会在输入Pixelmap上直接生效滤镜效果
1132 errorCode = OH_ImageEffect_SetOutputPixelmap(imageEffect, outputPixelmap);
1133 if (errorCode != EFFECT_SUCCESS) {
1134 napi_value ret;
1135 napi_create_int32(env, errorCode, &ret);
1136 return ret;
1137 }
1138 // 6、执行生效滤镜效果
1139 errorCode = OH_ImageEffect_Start(imageEffect);
1140 // 7、释放imageEffect实例资源
1141 OH_ImageEffect_Release(imageEffect);
1142 napi_value ret;
1143 napi_create_int32(env, errorCode, &ret);
1144 return ret;
1145 }
1146
OHImageEffectStop(napi_env env,napi_callback_info info)1147 napi_value OHImageEffectStop(napi_env env, napi_callback_info info)
1148 {
1149 std::shared_ptr<OH_PixelmapNative> pixelmapNativePtr = PixelMapHelper::Decode(imagePath);
1150
1151 OH_PixelmapNative *inputPixelmap = pixelmapNativePtr.get();
1152 OH_PixelmapNative *outputPixelmap = inputPixelmap;
1153
1154 // 1、创建imageEffect实例，“ImageEdit”是imageEffect实例别名。
1155 OH_ImageEffect *imageEffect = OH_ImageEffect_Create("ImageEdit");
1156
1157 // 2、添加滤镜，多次调用该接口可以添加多个滤镜，组成滤镜链。
1158 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_BRIGHTNESS_FILTER);
1159
1160 // 3、设置滤镜参数, 滤镜强度设置为50
1161 ImageEffect_Any value;
1162 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT;
1163 value.dataValue.floatValue = IMAGE_EFFECT_50F;
1164 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value);
1165
1166 // 4、设置输入的Pixelmap
1167 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, inputPixelmap);
1168 if (errorCode != EFFECT_SUCCESS) {
1169 napi_value ret;
1170 napi_create_int32(env, errorCode, &ret);
1171 return ret;
1172 }
1173 // 5、设置输出的Pixelmap（可选），不调用该接口时会在输入Pixelmap上直接生效滤镜效果
1174 errorCode = OH_ImageEffect_SetOutputPixelmap(imageEffect, outputPixelmap);
1175 if (errorCode != EFFECT_SUCCESS) {
1176 napi_value ret;
1177 napi_create_int32(env, errorCode, &ret);
1178 return ret;
1179 }
1180 // 6、执行生效滤镜效果
1181 errorCode = OH_ImageEffect_Start(imageEffect);
1182 if (errorCode != EFFECT_SUCCESS) {
1183 napi_value ret;
1184 napi_create_int32(env, errorCode, &ret);
1185 return ret;
1186 }
1187 // 7、执行生效滤镜效果
1188 errorCode = OH_ImageEffect_Stop(imageEffect);
1189
1190 // 7、释放imageEffect实例资源
1191 OH_ImageEffect_Release(imageEffect);
1192
1193 napi_value ret;
1194 napi_create_int32(env, errorCode, &ret);
1195 return ret;
1196 }
1197
OHImageEffectSetInputPicture(napi_env env,napi_callback_info info)1198 napi_value OHImageEffectSetInputPicture(napi_env env, napi_callback_info info)
1199 {
1200 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
1201 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_BRIGHTNESS_FILTER);
1202
1203 OH_PictureNative *nativePicture = nullptr;
1204 ImageEffect_ErrorCode code = OH_ImageEffect_SetInputPicture(imageEffect, nativePicture);
1205 LOG("OH_ImageEffect_SetInputPicture code value: %d", code);
1206 napi_value ret;
1207 napi_create_int32(env, code, &ret);
1208 return ret;
1209 }
1210
OHImageEffectSetOutputPicture(napi_env env,napi_callback_info info)1211 napi_value OHImageEffectSetOutputPicture(napi_env env, napi_callback_info info)
1212 {
1213 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME);
1214 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_BRIGHTNESS_FILTER);
1215
1216 OH_PictureNative *outNativePicture = nullptr;
1217 ImageEffect_ErrorCode code = OH_ImageEffect_SetOutputPicture(imageEffect, nullptr);
1218 LOG("OH_ImageEffect_SetOutputPicture code value: %d", code);
1219
1220 napi_value ret;
1221 napi_create_int32(env, code, &ret);
1222 return ret;
1223 }
