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