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 <js_native_api.h>
17 #include "napi/native_api.h"
18 #include "native_effect/effect_filter.h"
19 #include "native_effect/effect_types.h"
20 #include <multimedia/image_framework/image/pixelmap_native.h>
21 #include <multimedia/image_framework/image/image_packer_native.h>
22 #include <multimedia/image_framework/image/image_source_native.h>
23 #include "multimedia/image_framework/image_pixel_map_mdk.h"
24 #include "hilog/log.h"
25
26 #define SUCCESS 0
27 #define FAIL (-1)
28 #define DOUBLE_NUM_05 0.5
29 #define DOUBLE_NUM_15 1.5
30 #define ARR_NUM_0 0
31 #define ARR_NUM_1 1
32 #define ARR_NUM_2 2
33 #define ARR_NUM_3 3
34 #define UNAUTHORIZED 401
35
36 namespace {
37 constexpr int8_t ARGB_8888_BYTES = 4;
38 }
39
CreatePixelMap(OH_PixelmapNative *** pixelmap)40 static void CreatePixelMap(OH_PixelmapNative*** pixelmap)
41 {
42 OH_Pixelmap_InitializationOptions *ops = nullptr;
43 OH_PixelmapInitializationOptions_Create(&ops);
44 // 2 means alphaType
45 OH_PixelmapInitializationOptions_SetAlphaType(ops, 2);
46 // 4 means height
47 OH_PixelmapInitializationOptions_SetHeight(ops, 4);
48 // 4 means width
49 OH_PixelmapInitializationOptions_SetWidth(ops, 4);
50 // 4 means pixelFormat
51 OH_PixelmapInitializationOptions_SetPixelFormat(ops, 4);
52 // 255 means rgba data
53 uint8_t data[] = {
54 255, 255, 0, 255,
55 255, 255, 0, 255,
56 255, 255, 0, 255,
57 255, 255, 0, 255
58 };
59 // 16 means data length
60 size_t dataLength = 16;
61 OH_PixelmapNative_CreatePixelmap(data, dataLength, ops, *pixelmap);
62 }
63
OHFilterCreateEffect(napi_env env,napi_callback_info info)64 static napi_value OHFilterCreateEffect(napi_env env, napi_callback_info info)
65 {
66 napi_value result = nullptr;
67 OH_PixelmapNative *pixmap = nullptr;
68 OH_PixelmapNative **pixMap = &pixmap;
69 CreatePixelMap(&pixMap);
70 OH_Filter *filter = nullptr;
71 EffectErrorCode effectErrorCode = OH_Filter_CreateEffect(*pixMap, &filter);
72 if (effectErrorCode == EffectErrorCode::EFFECT_SUCCESS) {
73 napi_create_int32(env, SUCCESS, &result);
74 } else {
75 napi_create_int32(env, FAIL, &result);
76 }
77 OH_Filter_Release(filter);
78 OH_PixelmapNative_Release(*pixMap);
79 return result;
80 }
81
OHFilterCreateEffect001(napi_env env,napi_callback_info info)82 static napi_value OHFilterCreateEffect001(napi_env env, napi_callback_info info)
83 {
84 napi_value result = nullptr;
85 OH_PixelmapNative *pixmap = nullptr;
86 OH_PixelmapNative **pixMap = &pixmap;
87 CreatePixelMap(&pixMap);
88 OH_Filter *filter = nullptr;
89 if ((OH_Filter_CreateEffect(nullptr, &filter) != EffectErrorCode::EFFECT_SUCCESS) ||
90 (OH_Filter_CreateEffect(*pixMap, nullptr) != EffectErrorCode::EFFECT_SUCCESS)) {
91 napi_create_int32(env, SUCCESS, &result);
92 } else {
93 napi_create_int32(env, FAIL, &result);
94 }
95 OH_Filter_Release(filter);
96 OH_PixelmapNative_Release(*pixMap);
97 return result;
98 }
99
OHFilterInvert(napi_env env,napi_callback_info info)100 static napi_value OHFilterInvert(napi_env env, napi_callback_info info)
101 {
102 napi_value result = nullptr;
103 OH_PixelmapNative *pixmap = nullptr;
104 OH_PixelmapNative **pixMap = &pixmap;
105 CreatePixelMap(&pixMap);
106 OH_Filter *filter = nullptr;
107 OH_Filter_CreateEffect(*pixMap, &filter);
108 EffectErrorCode effectErrorCode = OH_Filter_Invert(nullptr);
109 if (effectErrorCode == EffectErrorCode::EFFECT_BAD_PARAMETER) {
110 napi_create_int32(env, SUCCESS, &result);
111 } else {
112 napi_create_int32(env, FAIL, &result);
113 }
114 OH_Filter_Release(filter);
115 OH_PixelmapNative_Release(*pixMap);
116 return result;
117 }
118
OHFilterInvert001(napi_env env,napi_callback_info info)119 static napi_value OHFilterInvert001(napi_env env, napi_callback_info info)
120 {
121 napi_value result = nullptr;
122 OH_PixelmapNative *pixmap = nullptr;
123 OH_PixelmapNative **pixMap = &pixmap;
124 CreatePixelMap(&pixMap);
125 OH_Filter *filter = nullptr;
126 OH_Filter_CreateEffect(*pixMap, &filter);
127 EffectErrorCode effectErrorCode = OH_Filter_Invert(filter);
128 if (effectErrorCode == EffectErrorCode::EFFECT_SUCCESS) {
129 napi_create_int32(env, SUCCESS, &result);
130 } else {
131 napi_create_int32(env, FAIL, &result);
132 }
133 OH_Filter_Release(filter);
134 OH_PixelmapNative_Release(*pixMap);
135 return result;
136 }
137
OHFilterBlur(napi_env env,napi_callback_info info)138 static napi_value OHFilterBlur(napi_env env, napi_callback_info info)
139 {
140 napi_value result = nullptr;
141 OH_PixelmapNative *pixmap = nullptr;
142 /** pixmap is necessary, otherwize can not create pixelmap*/
143 OH_PixelmapNative **pixMap = &pixmap;
144 CreatePixelMap(&pixMap);
145 OH_Filter *filter = nullptr;
146 OH_Filter_CreateEffect(*pixMap, &filter);
147 EffectErrorCode effectErrorCode = OH_Filter_Blur(filter, 0.5f);
148 if (effectErrorCode == EffectErrorCode::EFFECT_SUCCESS) {
149 napi_create_int32(env, SUCCESS, &result);
150 } else {
151 napi_create_int32(env, FAIL, &result);
152 }
153 OH_Filter_Release(filter);
154 OH_PixelmapNative_Release(*pixMap);
155 return result;
156 }
157
OHFilterBlur001(napi_env env,napi_callback_info info)158 static napi_value OHFilterBlur001(napi_env env, napi_callback_info info)
159 {
160 napi_value result = nullptr;
161 OH_PixelmapNative *pixmap = nullptr;
162 /** pixmap is necessary, otherwize can not create pixelmap*/
163 OH_PixelmapNative **pixMap = &pixmap;
164 CreatePixelMap(&pixMap);
165 OH_Filter *filter = nullptr;
166 OH_Filter_CreateEffect(*pixMap, &filter);
167 EffectErrorCode effectErrorCode = OH_Filter_Blur(nullptr, 0.5);
168 if (effectErrorCode == EffectErrorCode::EFFECT_BAD_PARAMETER) {
169 napi_create_int32(env, SUCCESS, &result);
170 } else {
171 napi_create_int32(env, FAIL, &result);
172 }
173 OH_Filter_Release(filter);
174 OH_PixelmapNative_Release(*pixMap);
175 return result;
176 }
177
OHFilterGrayScale(napi_env env,napi_callback_info info)178 static napi_value OHFilterGrayScale(napi_env env, napi_callback_info info)
179 {
180 napi_value result = nullptr;
181 OH_PixelmapNative *pixmap = nullptr;
182 /** pixmap is necessary, otherwize can not create pixelmap*/
183 OH_PixelmapNative **pixMap = &pixmap;
184 CreatePixelMap(&pixMap);
185 OH_Filter *filter = nullptr;
186 OH_Filter_CreateEffect(*pixMap, &filter);
187 EffectErrorCode effectErrorCode = OH_Filter_GrayScale(filter);
188 if (effectErrorCode == EffectErrorCode::EFFECT_SUCCESS) {
189 napi_create_int32(env, SUCCESS, &result);
190 } else {
191 napi_create_int32(env, FAIL, &result);
192 }
193 OH_Filter_Release(filter);
194 OH_PixelmapNative_Release(*pixMap);
195 return result;
196 }
197
OHFilterGrayScale001(napi_env env,napi_callback_info info)198 static napi_value OHFilterGrayScale001(napi_env env, napi_callback_info info)
199 {
200 napi_value result = nullptr;
201 OH_PixelmapNative *pixmap = nullptr;
202 /** pixmap is necessary, otherwize can not create pixelmap*/
203 OH_PixelmapNative **pixMap = &pixmap;
204 CreatePixelMap(&pixMap);
205 OH_Filter *filter = nullptr;
206 OH_Filter_CreateEffect(*pixMap, &filter);
207 EffectErrorCode effectErrorCode = OH_Filter_GrayScale(nullptr);
208 if (effectErrorCode == EffectErrorCode::EFFECT_BAD_PARAMETER) {
209 napi_create_int32(env, SUCCESS, &result);
210 } else {
211 napi_create_int32(env, FAIL, &result);
212 }
213 OH_Filter_Release(filter);
214 OH_PixelmapNative_Release(*pixMap);
215 return result;
216 }
217
OHFilterBrighten(napi_env env,napi_callback_info info)218 static napi_value OHFilterBrighten(napi_env env, napi_callback_info info)
219 {
220 napi_value result = nullptr;
221 OH_PixelmapNative *pixmap = nullptr;
222 /** pixmap is necessary, otherwize can not create pixelmap*/
223 OH_PixelmapNative **pixMap = &pixmap;
224 CreatePixelMap(&pixMap);
225 OH_Filter *filter = nullptr;
226 OH_Filter_CreateEffect(*pixMap, &filter);
227 EffectErrorCode effectErrorCode = OH_Filter_Brighten(filter, 0.5);
228 if (effectErrorCode == EffectErrorCode::EFFECT_SUCCESS) {
229 napi_create_int32(env, SUCCESS, &result);
230 } else {
231 napi_create_int32(env, FAIL, &result);
232 }
233 OH_Filter_Release(filter);
234 OH_PixelmapNative_Release(*pixMap);
235 return result;
236 }
237
OHFilterBrighten001(napi_env env,napi_callback_info info)238 static napi_value OHFilterBrighten001(napi_env env, napi_callback_info info)
239 {
240 napi_value result = nullptr;
241 OH_PixelmapNative *pixmap = nullptr;
242 /** pixmap is necessary, otherwize can not create pixelmap*/
243 OH_PixelmapNative **pixMap = &pixmap;
244 CreatePixelMap(&pixMap);
245 OH_Filter *filter = nullptr;
246 OH_Filter_CreateEffect(*pixMap, &filter);
247 EffectErrorCode effectErrorCode = OH_Filter_Brighten(nullptr, 0.5);
248 if (effectErrorCode == EffectErrorCode::EFFECT_BAD_PARAMETER) {
249 napi_create_int32(env, SUCCESS, &result);
250 } else {
251 napi_create_int32(env, FAIL, &result);
252 }
253 OH_Filter_Release(filter);
254 OH_PixelmapNative_Release(*pixMap);
255 return result;
256 }
257
OHFilterSetColorMatrix(napi_env env,napi_callback_info info)258 static napi_value OHFilterSetColorMatrix(napi_env env, napi_callback_info info)
259 {
260 napi_value result = nullptr;
261 OH_PixelmapNative *pixmap = nullptr;
262 /** pixmap is necessary, otherwize can not create pixelmap*/
263 OH_PixelmapNative **pixMap = &pixmap;
264 CreatePixelMap(&pixMap);
265 OH_Filter *filter = nullptr;
266 OH_Filter_CreateEffect(*pixMap, &filter);
267 OH_Filter_ColorMatrix matrix {
268 -1.0, 0, 0, 0, 1,
269 0, -1.0, 0, 0, 1,
270 0, 0, -1.0, 0, 1,
271 0, 0, 0, 1, 0
272 };
273 EffectErrorCode effectErrorCode = OH_Filter_SetColorMatrix(filter, &matrix);
274 if (effectErrorCode == EffectErrorCode::EFFECT_SUCCESS) {
275 napi_create_int32(env, SUCCESS, &result);
276 } else {
277 napi_create_int32(env, FAIL, &result);
278 }
279 OH_Filter_Release(filter);
280 OH_PixelmapNative_Release(*pixMap);
281 return result;
282 }
283
OHFilterSetColorMatrix001(napi_env env,napi_callback_info info)284 static napi_value OHFilterSetColorMatrix001(napi_env env, napi_callback_info info)
285 {
286 napi_value result = nullptr;
287 OH_PixelmapNative *pixmap = nullptr;
288 /** pixmap is necessary, otherwize can not create pixelmap*/
289 OH_PixelmapNative **pixMap = &pixmap;
290 CreatePixelMap(&pixMap);
291 OH_Filter *filter = nullptr;
292 OH_Filter_CreateEffect(*pixMap, &filter);
293 OH_Filter_ColorMatrix matrix {
294 -1.0, 0, 0, 0, 1,
295 0, -1.0, 0, 0, 1,
296 0, 0, -1.0, 0, 1,
297 0, 0, 0, 1, 0
298 };
299 EffectErrorCode effectErrorCode = OH_Filter_SetColorMatrix(nullptr, &matrix);
300 if (effectErrorCode == EffectErrorCode::EFFECT_BAD_PARAMETER) {
301 napi_create_int32(env, SUCCESS, &result);
302 } else {
303 napi_create_int32(env, FAIL, &result);
304 }
305 OH_Filter_Release(filter);
306 OH_PixelmapNative_Release(*pixMap);
307 return result;
308 }
309
OHFilterGetEffectPixelMap(napi_env env,napi_callback_info info)310 static napi_value OHFilterGetEffectPixelMap(napi_env env, napi_callback_info info)
311 {
312 napi_value result = nullptr;
313 OH_PixelmapNative *pixmap = nullptr;
314 /** pixmap is necessary, otherwize can not create pixelmap*/
315 OH_PixelmapNative **pixMap = &pixmap;
316 CreatePixelMap(&pixMap);
317 OH_Filter *filter = nullptr;
318 OH_Filter_CreateEffect(*pixMap, &filter);
319 OH_Filter_Invert(filter);
320 OH_PixelmapNative *pixelMap1 = nullptr;
321 EffectErrorCode effectErrorCode = OH_Filter_GetEffectPixelMap(filter, &pixelMap1);
322 if (effectErrorCode == EffectErrorCode::EFFECT_SUCCESS) {
323 napi_create_int32(env, SUCCESS, &result);
324 } else {
325 napi_create_int32(env, FAIL, &result);
326 }
327 OH_Filter_Release(filter);
328 OH_PixelmapNative_Release(*pixMap);
329 OH_PixelmapNative_Release(pixelMap1);
330 return result;
331 }
332
OHFilterRelease(napi_env env,napi_callback_info info)333 static napi_value OHFilterRelease(napi_env env, napi_callback_info info)
334 {
335 napi_value result = nullptr;
336 OH_PixelmapNative *pixmap = nullptr;
337 /** pixmap is necessary, otherwize can not create pixelmap*/
338 OH_PixelmapNative **pixMap = &pixmap;
339 CreatePixelMap(&pixMap);
340 OH_Filter *filter = nullptr;
341 OH_Filter_CreateEffect(*pixMap, &filter);
342 OH_Filter_Invert(filter);
343 EffectErrorCode effectErrorCode = OH_Filter_Release(filter);
344 if (effectErrorCode == EffectErrorCode::EFFECT_SUCCESS) {
345 napi_create_int32(env, SUCCESS, &result);
346 } else {
347 napi_create_int32(env, FAIL, &result);
348 }
349 OH_PixelmapNative_Release(*pixMap);
350 return result;
351 }
352
OHFilterRelease001(napi_env env,napi_callback_info info)353 static napi_value OHFilterRelease001(napi_env env, napi_callback_info info)
354 {
355 napi_value result = nullptr;
356 OH_PixelmapNative *pixmap = nullptr;
357 /** pixmap is necessary, otherwize can not create pixelmap*/
358 OH_PixelmapNative **pixMap = &pixmap;
359 CreatePixelMap(&pixMap);
360 OH_Filter *filter = nullptr;
361 OH_Filter_CreateEffect(*pixMap, &filter);
362 OH_Filter_Invert(filter);
363 EffectErrorCode effectErrorCode = OH_Filter_Release(nullptr);
364 if (effectErrorCode == EffectErrorCode::EFFECT_BAD_PARAMETER) {
365 napi_create_int32(env, SUCCESS, &result);
366 } else {
367 napi_create_int32(env, FAIL, &result);
368 }
369 OH_PixelmapNative_Release(*pixMap);
370 return result;
371 }
372
OHFilterBlurWithTileMode001(napi_env env,napi_callback_info info)373 static napi_value OHFilterBlurWithTileMode001(napi_env env, napi_callback_info info)
374 {
375 napi_value result = nullptr;
376 OH_PixelmapNative *pixmap = nullptr;
377 /** pixmap is necessary, otherwize can not create pixelmap*/
378 OH_PixelmapNative **pixMap = &pixmap;
379 CreatePixelMap(&pixMap);
380 OH_Filter *filter = nullptr;
381 if ((OH_Filter_CreateEffect(*pixMap, &filter) == EFFECT_SUCCESS) &&
382 (OH_Filter_BlurWithTileMode(filter, 0.5f, CLAMP) == EFFECT_SUCCESS) &&
383 (OH_Filter_BlurWithTileMode(nullptr, DOUBLE_NUM_05, CLAMP) == EFFECT_BAD_PARAMETER) &&
384 (OH_Filter_Release(filter) == EFFECT_SUCCESS)) {
385 napi_create_int32(env, SUCCESS, &result);
386 } else {
387 napi_create_int32(env, FAIL, &result);
388 }
389 OH_PixelmapNative_Release(*pixMap);
390 return result;
391 }
392
OHPixelmapNativeCreateScaledPixelMap001(napi_env env,napi_callback_info info)393 static napi_value OHPixelmapNativeCreateScaledPixelMap001(napi_env env, napi_callback_info info)
394 {
395 napi_value result = nullptr;
396 OH_PixelmapNative *srcPixelmap = nullptr;
397 OH_Pixelmap_ImageInfo *srcImageInfoBefore = nullptr;
398 OH_PixelmapImageInfo_Create(&srcImageInfoBefore);
399 OH_PixelmapNative_GetImageInfo(srcPixelmap, srcImageInfoBefore);
400
401 OH_PixelmapNative *dstPixelmap = nullptr;
402 float scaleX = DOUBLE_NUM_15;
403 float scaleY = DOUBLE_NUM_15;
404 Image_ErrorCode ret = OH_PixelmapNative_CreateScaledPixelMap(srcPixelmap, &dstPixelmap, scaleX, scaleY);
405 if (ret == IMAGE_BAD_PARAMETER) {
406 napi_create_int32(env, SUCCESS, &result);
407 } else {
408 napi_create_int32(env, FAIL, &result);
409 }
410 return result;
411 }
412
OHPixelmapNativeCreateScaledPixelMapWithAntiAliasing001(napi_env env,napi_callback_info info)413 static napi_value OHPixelmapNativeCreateScaledPixelMapWithAntiAliasing001(napi_env env, napi_callback_info info)
414 {
415 napi_value result = nullptr;
416 OH_PixelmapNative *srcPixelmap = nullptr;
417 OH_Pixelmap_ImageInfo *srcImageInfoBefore = nullptr;
418 OH_PixelmapImageInfo_Create(&srcImageInfoBefore);
419 OH_PixelmapNative_GetImageInfo(srcPixelmap, srcImageInfoBefore);
420
421 OH_PixelmapNative *dstPixelmap = nullptr;
422 float scaleX = DOUBLE_NUM_05;
423 float scaleY = DOUBLE_NUM_05;
424 Image_ErrorCode ret = OH_PixelmapNative_CreateScaledPixelMapWithAntiAliasing(srcPixelmap, &dstPixelmap,
425 scaleX, scaleY, OH_PixelmapNative_AntiAliasingLevel::OH_PixelmapNative_AntiAliasing_HIGH);
426 if (ret == IMAGE_BAD_PARAMETER) {
427 napi_create_int32(env, SUCCESS, &result);
428 } else {
429 napi_create_int32(env, FAIL, &result);
430 }
431 return result;
432 }
433
OHPixelmapNativeGetByteCount001(napi_env env,napi_callback_info info)434 static napi_value OHPixelmapNativeGetByteCount001(napi_env env, napi_callback_info info)
435 {
436 napi_value result = nullptr;
437 napi_create_array_with_length(env, ARR_NUM_3, &result);
438 napi_value result1 = nullptr;
439 napi_value result2 = nullptr;
440 napi_value result3 = nullptr;
441
442 OH_Pixelmap_InitializationOptions *options = nullptr;
443 OH_PixelmapInitializationOptions_Create(&options);
444 OH_PixelmapInitializationOptions_SetWidth(options, 1);
445 OH_PixelmapInitializationOptions_SetHeight(options, 1);
446 OH_PixelmapNative *pixelmap = nullptr;
447 Image_ErrorCode ret = OH_PixelmapNative_CreateEmptyPixelmap(options, &pixelmap);
448 if (ret == IMAGE_SUCCESS) {
449 napi_create_int32(env, SUCCESS, &result1);
450 } else {
451 napi_create_int32(env, FAIL, &result1);
452 }
453 napi_set_element(env, result, ARR_NUM_0, result1);
454
455 uint32_t byteCount = 0;
456 ret = OH_PixelmapNative_GetByteCount(pixelmap, &byteCount);
457 if (ret == IMAGE_SUCCESS) {
458 napi_create_int32(env, SUCCESS, &result2);
459 } else {
460 napi_create_int32(env, FAIL, &result2);
461 }
462 napi_set_element(env, result, ARR_NUM_1, result2);
463
464 uint32_t allocByteCount = 0;
465 ret = OH_PixelmapNative_GetAllocationByteCount(pixelmap, &allocByteCount);
466 if ((ret == IMAGE_SUCCESS) && (byteCount == ARGB_8888_BYTES) && (allocByteCount >= byteCount)) {
467 napi_create_int32(env, SUCCESS, &result3);
468 } else {
469 napi_create_int32(env, FAIL, &result3);
470 }
471 napi_set_element(env, result, ARR_NUM_2, result3);
472 return result;
473 }
474
OHPixelmapNativeAccessPixels001(napi_env env,napi_callback_info info)475 static napi_value OHPixelmapNativeAccessPixels001(napi_env env, napi_callback_info info)
476 {
477 napi_value result = nullptr;
478 OH_Pixelmap_InitializationOptions *options = nullptr;
479 OH_PixelmapInitializationOptions_Create(&options);
480 OH_PixelmapInitializationOptions_SetWidth(options, 1);
481 OH_PixelmapInitializationOptions_SetHeight(options, 1);
482 OH_PixelmapNative *srcPixelmap = nullptr;
483 OH_PixelmapNative_CreateEmptyPixelmap(options, &srcPixelmap);
484 void *dstPixelmap = nullptr;
485 Image_ErrorCode ret = OH_PixelmapNative_AccessPixels(srcPixelmap, &dstPixelmap);
486 if (ret == IMAGE_SUCCESS) {
487 napi_create_int32(env, SUCCESS, &result);
488 } else {
489 napi_create_int32(env, FAIL, &result);
490 }
491 return result;
492 }
493
OHPixelmapNativeUnaccessPixels001(napi_env env,napi_callback_info info)494 static napi_value OHPixelmapNativeUnaccessPixels001(napi_env env, napi_callback_info info)
495 {
496 napi_value result = nullptr;
497 OH_Pixelmap_InitializationOptions *options = nullptr;
498 OH_PixelmapInitializationOptions_Create(&options);
499 OH_PixelmapInitializationOptions_SetWidth(options, 1);
500 OH_PixelmapInitializationOptions_SetHeight(options, 1);
501 OH_PixelmapNative *srcPixelmap = nullptr;
502 OH_PixelmapNative_CreateEmptyPixelmap(options, &srcPixelmap);
503 Image_ErrorCode ret = OH_PixelmapNative_UnaccessPixels(srcPixelmap);
504 if (ret == IMAGE_SUCCESS) {
505 napi_create_int32(env, SUCCESS, &result);
506 } else {
507 napi_create_int32(env, FAIL, &result);
508 }
509 return result;
510 }
511
OHPixelmapInitializationOptionsEditable001(napi_env env,napi_callback_info info)512 static napi_value OHPixelmapInitializationOptionsEditable001(napi_env env, napi_callback_info info)
513 {
514 napi_value result = nullptr;
515 napi_create_array_with_length(env, ARR_NUM_2, &result);
516 napi_value result1 = nullptr;
517 napi_value result2 = nullptr;
518
519 OH_Pixelmap_InitializationOptions *ops = nullptr;
520 OH_PixelmapInitializationOptions_Create(&ops);
521 bool editable = false;
522 OH_PixelmapInitializationOptions_GetEditable(ops, &editable);
523 if (editable == true) {
524 napi_create_int32(env, SUCCESS, &result1);
525 } else {
526 napi_create_int32(env, FAIL, &result1);
527 }
528 napi_set_element(env, result, ARR_NUM_0, result1);
529
530 OH_PixelmapInitializationOptions_SetEditable(ops, false);
531 OH_PixelmapInitializationOptions_GetEditable(ops, &editable);
532 if ((editable == false) && (OH_PixelmapInitializationOptions_SetEditable(nullptr, true) == UNAUTHORIZED) &&
533 (OH_PixelmapInitializationOptions_SetEditable(nullptr, false) == UNAUTHORIZED) &&
534 (OH_PixelmapInitializationOptions_GetEditable(nullptr, &editable) == UNAUTHORIZED)) {
535 napi_create_int32(env, SUCCESS, &result2);
536 } else {
537 napi_create_int32(env, FAIL, &result2);
538 }
539 napi_set_element(env, result, ARR_NUM_1, result2);
540 OH_PixelmapInitializationOptions_Release(ops);
541 return result;
542 }
543
OHPixelmapNativeDestroy001(napi_env env,napi_callback_info info)544 static napi_value OHPixelmapNativeDestroy001(napi_env env, napi_callback_info info)
545 {
546 napi_value result = nullptr;
547 napi_create_array_with_length(env, ARR_NUM_2, &result);
548 napi_value result1 = nullptr;
549 napi_value result2 = nullptr;
550
551 size_t dataSize = ARGB_8888_BYTES;
552 uint8_t data[] = {0x01, 0x02, 0x03, 0xFF};
553 OH_Pixelmap_InitializationOptions *createOpts;
554 OH_PixelmapInitializationOptions_Create(&createOpts);
555 OH_PixelmapInitializationOptions_SetWidth(createOpts, 1);
556 OH_PixelmapInitializationOptions_SetHeight(createOpts, 1);
557 OH_PixelmapInitializationOptions_SetPixelFormat(createOpts, PIXEL_FORMAT_BGRA_8888);
558 OH_PixelmapNative *pixelMap = nullptr;
559 Image_ErrorCode errCode = OH_PixelmapNative_CreatePixelmap(data, dataSize, createOpts, &pixelMap);
560 if (errCode == IMAGE_SUCCESS) {
561 napi_create_int32(env, SUCCESS, &result1);
562 } else {
563 napi_create_int32(env, FAIL, &result1);
564 }
565 napi_set_element(env, result, ARR_NUM_0, result1);
566
567 OH_PixelmapNative_Destroy(&pixelMap);
568 if ((pixelMap == nullptr) && (OH_PixelmapNative_Destroy(nullptr) == UNAUTHORIZED)) {
569 napi_create_int32(env, SUCCESS, &result2);
570 } else {
571 napi_create_int32(env, FAIL, &result2);
572 }
573 napi_set_element(env, result, ARR_NUM_1, result2);
574 OH_PixelmapInitializationOptions_Release(createOpts);
575 return result;
576 }
577
578 EXTERN_C_START
Init(napi_env env,napi_value exports)579 static napi_value Init(napi_env env, napi_value exports)
580 {
581 napi_property_descriptor desc[] = {
582 {"oHFilterCreateEffect", nullptr, OHFilterCreateEffect, nullptr, nullptr, nullptr,
583 napi_default, nullptr},
584 {"oHFilterCreateEffect001", nullptr, OHFilterCreateEffect001, nullptr, nullptr, nullptr,
585 napi_default, nullptr},
586 {"oHFilterInvert", nullptr, OHFilterInvert, nullptr, nullptr, nullptr,
587 napi_default, nullptr},
588 {"oHFilterInvert001", nullptr, OHFilterInvert001, nullptr, nullptr, nullptr,
589 napi_default, nullptr},
590 {"oHFilterBlur", nullptr, OHFilterBlur, nullptr, nullptr, nullptr,
591 napi_default, nullptr},
592 {"oHFilterBlur001", nullptr, OHFilterBlur001, nullptr, nullptr, nullptr,
593 napi_default, nullptr},
594 {"oHFilterGrayScale", nullptr, OHFilterGrayScale, nullptr, nullptr, nullptr,
595 napi_default, nullptr},
596 {"oHFilterGrayScale001", nullptr, OHFilterGrayScale001, nullptr, nullptr, nullptr,
597 napi_default, nullptr},
598 {"oHFilterBrighten", nullptr, OHFilterBrighten, nullptr, nullptr, nullptr,
599 napi_default, nullptr},
600 {"oHFilterBrighten001", nullptr, OHFilterBrighten001, nullptr, nullptr, nullptr,
601 napi_default, nullptr},
602 {"oHFilterSetColorMatrix", nullptr, OHFilterSetColorMatrix, nullptr, nullptr, nullptr,
603 napi_default, nullptr},
604 {"oHFilterSetColorMatrix001", nullptr, OHFilterSetColorMatrix001, nullptr, nullptr, nullptr,
605 napi_default, nullptr},
606 {"oHFilterGetEffectPixelMap", nullptr, OHFilterGetEffectPixelMap, nullptr, nullptr, nullptr,
607 napi_default, nullptr},
608 {"oHFilterRelease", nullptr, OHFilterRelease, nullptr, nullptr, nullptr,
609 napi_default, nullptr},
610 {"oHFilterRelease001", nullptr, OHFilterRelease001, nullptr, nullptr, nullptr,
611 napi_default, nullptr},
612 {"oHFilterBlurWithTileMode001", nullptr, OHFilterBlurWithTileMode001, nullptr, nullptr, nullptr,
613 napi_default, nullptr},
614 {"oHPixelmapNativeCreateScaledPixelMap001", nullptr, OHPixelmapNativeCreateScaledPixelMap001,
615 nullptr, nullptr, nullptr, napi_default, nullptr},
616 {"oHPixelmapNativeCreateScaledPixelMapWithAntiAliasing001", nullptr,
617 OHPixelmapNativeCreateScaledPixelMapWithAntiAliasing001,
618 nullptr, nullptr, nullptr, napi_default, nullptr},
619 {"oHPixelmapNativeGetByteCount001", nullptr, OHPixelmapNativeGetByteCount001,
620 nullptr, nullptr, nullptr, napi_default, nullptr},
621 {"oHPixelmapNativeAccessPixels001", nullptr, OHPixelmapNativeAccessPixels001,
622 nullptr, nullptr, nullptr, napi_default, nullptr},
623 {"oHPixelmapNativeUnaccessPixels001", nullptr, OHPixelmapNativeUnaccessPixels001,
624 nullptr, nullptr, nullptr, napi_default, nullptr},
625 {"oHPixelmapInitializationOptionsEditable001", nullptr, OHPixelmapInitializationOptionsEditable001,
626 nullptr, nullptr, nullptr, napi_default, nullptr},
627 {"oHPixelmapNativeDestroy001", nullptr, OHPixelmapNativeDestroy001,
628 nullptr, nullptr, nullptr, napi_default, nullptr},
629 };
630 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
631 return exports;
632 }
633
634 EXTERN_C_END
635
636 static napi_module demoModule = {
637 .nm_version = 1,
638 .nm_flags = 0,
639 .nm_filename = nullptr,
640 .nm_register_func = Init,
641 .nm_modname = "nativeEffectNdk",
642 .nm_priv = ((void *)0),
643 .reserved = {0},
644 };
645
RegisterEntryModule(void)646 extern "C" __attribute__((constructor)) void RegisterEntryModule(void) { napi_module_register(&demoModule); }