1/* 2 * Copyright (c) 2023 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 "napi/native_api.h" 17#include <js_native_api_types.h> 18#include <multimedia/player_framework/native_avcapability.h> 19#include <multimedia/player_framework/native_avcodec_base.h> 20#include <multimedia/player_framework/native_avdemuxer.h> 21#include <multimedia/player_framework/native_avformat.h> 22#include <multimedia/player_framework/native_avsource.h> 23 24#define FAIL (-1) 25#define SUCCESS 0 26#define WIDTH 1920 27#define HEIGHT 1080 28#define PARAM_720 720 29#define PARAM_1280 1280 30#define PARAM_0 0 31#define PARAM_30 30 32const bool isEncoder = true; 33const bool isDecoder = false; 34 35static napi_value OHAvCapabilityGetEncoderQualityRangeAnormal(napi_env env, napi_callback_info info) 36{ 37 napi_value result = nullptr; 38 int backParam = FAIL; 39 OH_AVCapability *capability = nullptr; 40 OH_AVRange qualityRange; 41 OH_AVErrCode checkParam; 42 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isEncoder, HARDWARE); 43 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 44 if (checkParam == AV_ERR_OK) { 45 backParam = SUCCESS; 46 } 47 napi_create_int32(env, backParam, &result); 48 return result; 49} 50 51static napi_value OHAvCapabilityGetEncoderQualityRangeBnormal(napi_env env, napi_callback_info info) 52{ 53 napi_value result = nullptr; 54 int backParam = FAIL; 55 OH_AVCapability *capability = nullptr; 56 OH_AVRange qualityRange; 57 OH_AVErrCode checkParam; 58 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, isEncoder, HARDWARE); 59 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 60 if (checkParam == AV_ERR_OK) { 61 backParam = SUCCESS; 62 } 63 napi_create_int32(env, backParam, &result); 64 return result; 65} 66 67static napi_value OHAvCapabilityGetEncoderQualityRangeCnormal(napi_env env, napi_callback_info info) 68{ 69 napi_value result = nullptr; 70 int backParam = FAIL; 71 OH_AVCapability *capability = nullptr; 72 OH_AVRange qualityRange; 73 OH_AVErrCode checkParam; 74 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, isEncoder, HARDWARE); 75 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 76 if (checkParam == AV_ERR_OK) { 77 backParam = SUCCESS; 78 } 79 napi_create_int32(env, backParam, &result); 80 return result; 81} 82 83static napi_value OHAvCapabilityGetEncoderQualityRangeDnormal(napi_env env, napi_callback_info info) 84{ 85 napi_value result = nullptr; 86 int backParam = FAIL; 87 OH_AVCapability *capability = nullptr; 88 OH_AVRange qualityRange; 89 OH_AVErrCode checkParam; 90 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_MPEG, isEncoder, HARDWARE); 91 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 92 if (checkParam == AV_ERR_OK) { 93 backParam = SUCCESS; 94 } 95 napi_create_int32(env, backParam, &result); 96 return result; 97} 98 99static napi_value OHAvCapabilityGetEncoderQualityRangeEnormal(napi_env env, napi_callback_info info) 100{ 101 napi_value result = nullptr; 102 int backParam = FAIL; 103 OH_AVCapability *capability = nullptr; 104 OH_AVRange qualityRange; 105 OH_AVErrCode checkParam; 106 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, isEncoder, HARDWARE); 107 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 108 if (checkParam == AV_ERR_OK) { 109 backParam = SUCCESS; 110 } 111 napi_create_int32(env, backParam, &result); 112 return result; 113} 114 115static napi_value OHAvCapabilityGetEncoderQualityRangeFnormal(napi_env env, napi_callback_info info) 116{ 117 napi_value result = nullptr; 118 int backParam = FAIL; 119 OH_AVCapability *capability = nullptr; 120 OH_AVRange qualityRange; 121 OH_AVErrCode checkParam; 122 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_AAC, isEncoder, HARDWARE); 123 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 124 if (checkParam == AV_ERR_OK) { 125 backParam = SUCCESS; 126 } 127 napi_create_int32(env, backParam, &result); 128 return result; 129} 130 131static napi_value OHAvCapabilityGetEncoderQualityRangeGnormal(napi_env env, napi_callback_info info) 132{ 133 napi_value result = nullptr; 134 int backParam = FAIL; 135 OH_AVCapability *capability = nullptr; 136 OH_AVRange qualityRange; 137 OH_AVErrCode checkParam; 138 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_JPG, isEncoder, HARDWARE); 139 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 140 if (checkParam == AV_ERR_OK) { 141 backParam = SUCCESS; 142 } 143 napi_create_int32(env, backParam, &result); 144 return result; 145} 146 147static napi_value OHAvCapabilityGetEncoderQualityRangeHnormal(napi_env env, napi_callback_info info) 148{ 149 napi_value result = nullptr; 150 int backParam = FAIL; 151 OH_AVCapability *capability = nullptr; 152 OH_AVRange qualityRange; 153 OH_AVErrCode checkParam; 154 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_PNG, isEncoder, HARDWARE); 155 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 156 if (checkParam == AV_ERR_OK) { 157 backParam = SUCCESS; 158 } 159 napi_create_int32(env, backParam, &result); 160 return result; 161} 162 163static napi_value OHAvCapabilityGetEncoderQualityRangeInormal(napi_env env, napi_callback_info info) 164{ 165 napi_value result = nullptr; 166 int backParam = FAIL; 167 OH_AVCapability *capability = nullptr; 168 OH_AVRange qualityRange; 169 OH_AVErrCode checkParam; 170 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_BMP, isEncoder, HARDWARE); 171 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 172 if (checkParam == AV_ERR_OK) { 173 backParam = SUCCESS; 174 } 175 napi_create_int32(env, backParam, &result); 176 return result; 177} 178 179static napi_value OHAvCapabilityGetEncoderQualityRangeJnormal(napi_env env, napi_callback_info info) 180{ 181 napi_value result = nullptr; 182 int backParam = FAIL; 183 OH_AVCapability *capability = nullptr; 184 OH_AVRange qualityRange; 185 OH_AVErrCode checkParam; 186 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isDecoder, SOFTWARE); 187 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 188 if (checkParam == AV_ERR_OK) { 189 backParam = SUCCESS; 190 } 191 napi_create_int32(env, backParam, &result); 192 return result; 193} 194 195static napi_value OHAvCapabilityGetEncoderQualityRangeKnormal(napi_env env, napi_callback_info info) 196{ 197 napi_value result = nullptr; 198 int backParam = FAIL; 199 OH_AVCapability *capability = nullptr; 200 OH_AVRange qualityRange; 201 OH_AVErrCode checkParam; 202 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, isDecoder, SOFTWARE); 203 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 204 if (checkParam == AV_ERR_OK) { 205 backParam = SUCCESS; 206 } 207 napi_create_int32(env, backParam, &result); 208 return result; 209} 210 211static napi_value OHAvCapabilityGetEncoderQualityRangeLnormal(napi_env env, napi_callback_info info) 212{ 213 napi_value result = nullptr; 214 int backParam = FAIL; 215 OH_AVCapability *capability = nullptr; 216 OH_AVRange qualityRange; 217 OH_AVErrCode checkParam; 218 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, isDecoder, SOFTWARE); 219 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 220 if (checkParam == AV_ERR_OK) { 221 backParam = SUCCESS; 222 } 223 napi_create_int32(env, backParam, &result); 224 return result; 225} 226 227static napi_value OHAvCapabilityGetEncoderQualityRangeMnormal(napi_env env, napi_callback_info info) 228{ 229 napi_value result = nullptr; 230 int backParam = FAIL; 231 OH_AVCapability *capability = nullptr; 232 OH_AVRange qualityRange; 233 OH_AVErrCode checkParam; 234 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_MPEG, isDecoder, SOFTWARE); 235 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 236 if (checkParam == AV_ERR_OK) { 237 backParam = SUCCESS; 238 } 239 napi_create_int32(env, backParam, &result); 240 return result; 241} 242 243static napi_value OHAvCapabilityGetEncoderQualityRangeNnormal(napi_env env, napi_callback_info info) 244{ 245 napi_value result = nullptr; 246 int backParam = FAIL; 247 OH_AVCapability *capability = nullptr; 248 OH_AVRange qualityRange; 249 OH_AVErrCode checkParam; 250 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, isDecoder, SOFTWARE); 251 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 252 if (checkParam == AV_ERR_OK) { 253 backParam = SUCCESS; 254 } 255 napi_create_int32(env, backParam, &result); 256 return result; 257} 258 259static napi_value OHAvCapabilityGetEncoderQualityRangeOnormal(napi_env env, napi_callback_info info) 260{ 261 napi_value result = nullptr; 262 int backParam = FAIL; 263 OH_AVCapability *capability = nullptr; 264 OH_AVRange qualityRange; 265 OH_AVErrCode checkParam; 266 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_AAC, isDecoder, SOFTWARE); 267 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 268 if (checkParam == AV_ERR_OK) { 269 backParam = SUCCESS; 270 } 271 napi_create_int32(env, backParam, &result); 272 return result; 273} 274 275static napi_value OHAvCapabilityGetEncoderQualityRangePnormal(napi_env env, napi_callback_info info) 276{ 277 napi_value result = nullptr; 278 int backParam = FAIL; 279 OH_AVCapability *capability = nullptr; 280 OH_AVRange qualityRange; 281 OH_AVErrCode checkParam; 282 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_JPG, isDecoder, SOFTWARE); 283 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 284 if (checkParam == AV_ERR_OK) { 285 backParam = SUCCESS; 286 } 287 napi_create_int32(env, backParam, &result); 288 return result; 289} 290 291static napi_value OHAvCapabilityGetEncoderQualityRangeQnormal(napi_env env, napi_callback_info info) 292{ 293 napi_value result = nullptr; 294 int backParam = FAIL; 295 OH_AVCapability *capability = nullptr; 296 OH_AVRange qualityRange; 297 OH_AVErrCode checkParam; 298 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_PNG, isDecoder, SOFTWARE); 299 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 300 if (checkParam == AV_ERR_OK) { 301 backParam = SUCCESS; 302 } 303 napi_create_int32(env, backParam, &result); 304 return result; 305} 306 307static napi_value OHAvCapabilityGetEncoderQualityRangeRnormal(napi_env env, napi_callback_info info) 308{ 309 napi_value result = nullptr; 310 int backParam = FAIL; 311 OH_AVCapability *capability = nullptr; 312 OH_AVRange qualityRange; 313 OH_AVErrCode checkParam; 314 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_BMP, isDecoder, SOFTWARE); 315 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 316 if (checkParam == AV_ERR_OK) { 317 backParam = SUCCESS; 318 } 319 napi_create_int32(env, backParam, &result); 320 return result; 321} 322 323static napi_value OHAvCapabilityGetEncoderQualityRangeSnormal(napi_env env, napi_callback_info info) 324{ 325 napi_value result = nullptr; 326 int backParam = FAIL; 327 OH_AVCapability *capability = nullptr; 328 OH_AVRange qualityRange; 329 OH_AVErrCode checkParam; 330 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isDecoder, SOFTWARE); 331 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 332 if (checkParam == AV_ERR_OK) { 333 backParam = SUCCESS; 334 } 335 napi_create_int32(env, backParam, &result); 336 return result; 337} 338 339static napi_value OHAvCapabilityGetEncoderQualityRangeTnormal(napi_env env, napi_callback_info info) 340{ 341 napi_value result = nullptr; 342 int backParam = FAIL; 343 OH_AVCapability *capability = nullptr; 344 OH_AVRange qualityRange; 345 OH_AVErrCode checkParam; 346 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isDecoder, HARDWARE); 347 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 348 if (checkParam == AV_ERR_OK) { 349 backParam = SUCCESS; 350 } 351 napi_create_int32(env, backParam, &result); 352 return result; 353} 354 355static napi_value OHAvCapabilityGetEncoderQualityRangeUnormal(napi_env env, napi_callback_info info) 356{ 357 napi_value result = nullptr; 358 int backParam = FAIL; 359 OH_AVCapability *capability = nullptr; 360 OH_AVRange qualityRange; 361 OH_AVErrCode checkParam; 362 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, isDecoder, HARDWARE); 363 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 364 if (checkParam == AV_ERR_OK) { 365 backParam = SUCCESS; 366 } 367 napi_create_int32(env, backParam, &result); 368 return result; 369} 370 371static napi_value OHAvCapabilityGetEncoderQualityRangeVnormal(napi_env env, napi_callback_info info) 372{ 373 napi_value result = nullptr; 374 int backParam = FAIL; 375 OH_AVCapability *capability = nullptr; 376 OH_AVRange qualityRange; 377 OH_AVErrCode checkParam; 378 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, isDecoder, HARDWARE); 379 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 380 if (checkParam == AV_ERR_OK) { 381 backParam = SUCCESS; 382 } 383 napi_create_int32(env, backParam, &result); 384 return result; 385} 386 387static napi_value OHAvCapabilityGetEncoderQualityRangeWnormal(napi_env env, napi_callback_info info) 388{ 389 napi_value result = nullptr; 390 int backParam = FAIL; 391 OH_AVCapability *capability = nullptr; 392 OH_AVRange qualityRange; 393 OH_AVErrCode checkParam; 394 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_MPEG, isDecoder, HARDWARE); 395 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 396 if (checkParam == AV_ERR_OK) { 397 backParam = SUCCESS; 398 } 399 napi_create_int32(env, backParam, &result); 400 return result; 401} 402 403static napi_value OHAvCapabilityGetEncoderQualityRangeXnormal(napi_env env, napi_callback_info info) 404{ 405 napi_value result = nullptr; 406 int backParam = FAIL; 407 OH_AVCapability *capability = nullptr; 408 OH_AVRange qualityRange; 409 OH_AVErrCode checkParam; 410 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, isDecoder, HARDWARE); 411 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 412 if (checkParam == AV_ERR_OK) { 413 backParam = SUCCESS; 414 } 415 napi_create_int32(env, backParam, &result); 416 return result; 417} 418 419static napi_value OHAvCapabilityGetEncoderQualityRangeYnormal(napi_env env, napi_callback_info info) 420{ 421 napi_value result = nullptr; 422 int backParam = FAIL; 423 OH_AVCapability *capability = nullptr; 424 OH_AVRange qualityRange; 425 OH_AVErrCode checkParam; 426 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_AAC, isDecoder, HARDWARE); 427 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 428 if (checkParam == AV_ERR_OK) { 429 backParam = SUCCESS; 430 } 431 napi_create_int32(env, backParam, &result); 432 return result; 433} 434 435static napi_value OHAvCapabilityGetEncoderQualityRangeZnormal(napi_env env, napi_callback_info info) 436{ 437 napi_value result = nullptr; 438 int backParam = FAIL; 439 OH_AVCapability *capability = nullptr; 440 OH_AVRange qualityRange; 441 OH_AVErrCode checkParam; 442 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_JPG, isDecoder, HARDWARE); 443 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 444 if (checkParam == AV_ERR_OK) { 445 backParam = SUCCESS; 446 } 447 napi_create_int32(env, backParam, &result); 448 return result; 449} 450 451static napi_value OHAvCapabilityGetEncoderQualityRangeAAnormal(napi_env env, napi_callback_info info) 452{ 453 napi_value result = nullptr; 454 int backParam = FAIL; 455 OH_AVCapability *capability = nullptr; 456 OH_AVRange qualityRange; 457 OH_AVErrCode checkParam; 458 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_PNG, isDecoder, HARDWARE); 459 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 460 if (checkParam == AV_ERR_OK) { 461 backParam = SUCCESS; 462 } 463 napi_create_int32(env, backParam, &result); 464 return result; 465} 466 467static napi_value OHAvCapabilityGetEncoderQualityRangeABnormal(napi_env env, napi_callback_info info) 468{ 469 napi_value result = nullptr; 470 int backParam = FAIL; 471 OH_AVCapability *capability = nullptr; 472 OH_AVRange qualityRange; 473 OH_AVErrCode checkParam; 474 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_BMP, isDecoder, HARDWARE); 475 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 476 if (checkParam == AV_ERR_OK) { 477 backParam = SUCCESS; 478 } 479 napi_create_int32(env, backParam, &result); 480 return result; 481} 482 483static napi_value OHAvCapabilityGetEncoderQualityRangeACnormal(napi_env env, napi_callback_info info) 484{ 485 napi_value result = nullptr; 486 int backParam = FAIL; 487 OH_AVCapability *capability = nullptr; 488 OH_AVRange qualityRange; 489 OH_AVErrCode checkParam; 490 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isDecoder, HARDWARE); 491 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 492 if (checkParam == AV_ERR_OK) { 493 backParam = SUCCESS; 494 } 495 napi_create_int32(env, backParam, &result); 496 return result; 497} 498 499static napi_value OHAvCapabilityGetEncoderQualityRangeADnormal(napi_env env, napi_callback_info info) 500{ 501 napi_value result = nullptr; 502 int backParam = FAIL; 503 OH_AVCapability *capability = nullptr; 504 OH_AVRange qualityRange; 505 OH_AVErrCode checkParam; 506 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isEncoder, SOFTWARE); 507 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 508 if (checkParam == AV_ERR_OK) { 509 backParam = SUCCESS; 510 } 511 napi_create_int32(env, backParam, &result); 512 return result; 513} 514 515static napi_value OHAvCapabilityGetEncoderQualityRangeAEnormal(napi_env env, napi_callback_info info) 516{ 517 napi_value result = nullptr; 518 int backParam = FAIL; 519 OH_AVCapability *capability = nullptr; 520 OH_AVRange qualityRange; 521 OH_AVErrCode checkParam; 522 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, isEncoder, SOFTWARE); 523 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 524 if (checkParam == AV_ERR_OK) { 525 backParam = SUCCESS; 526 } 527 napi_create_int32(env, backParam, &result); 528 return result; 529} 530 531static napi_value OHAvCapabilityGetEncoderQualityRangeAFnormal(napi_env env, napi_callback_info info) 532{ 533 napi_value result = nullptr; 534 int backParam = FAIL; 535 OH_AVCapability *capability = nullptr; 536 OH_AVRange qualityRange; 537 OH_AVErrCode checkParam; 538 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, isEncoder, SOFTWARE); 539 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 540 if (checkParam == AV_ERR_OK) { 541 backParam = SUCCESS; 542 } 543 napi_create_int32(env, backParam, &result); 544 return result; 545} 546 547static napi_value OHAvCapabilityGetEncoderQualityRangeAGnormal(napi_env env, napi_callback_info info) 548{ 549 napi_value result = nullptr; 550 int backParam = FAIL; 551 OH_AVCapability *capability = nullptr; 552 OH_AVRange qualityRange; 553 OH_AVErrCode checkParam; 554 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_MPEG, isEncoder, SOFTWARE); 555 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 556 if (checkParam == AV_ERR_OK) { 557 backParam = SUCCESS; 558 } 559 napi_create_int32(env, backParam, &result); 560 return result; 561} 562 563static napi_value OHAvCapabilityGetEncoderQualityRangeAHnormal(napi_env env, napi_callback_info info) 564{ 565 napi_value result = nullptr; 566 int backParam = FAIL; 567 OH_AVCapability *capability = nullptr; 568 OH_AVRange qualityRange; 569 OH_AVErrCode checkParam; 570 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, isEncoder, SOFTWARE); 571 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 572 if (checkParam == AV_ERR_OK) { 573 backParam = SUCCESS; 574 } 575 napi_create_int32(env, backParam, &result); 576 return result; 577} 578 579static napi_value OHAvCapabilityGetEncoderQualityRangeAInormal(napi_env env, napi_callback_info info) 580{ 581 napi_value result = nullptr; 582 int backParam = FAIL; 583 OH_AVCapability *capability = nullptr; 584 OH_AVRange qualityRange; 585 OH_AVErrCode checkParam; 586 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_AAC, isEncoder, SOFTWARE); 587 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 588 if (checkParam == AV_ERR_OK) { 589 backParam = SUCCESS; 590 } 591 napi_create_int32(env, backParam, &result); 592 return result; 593} 594 595static napi_value OHAvCapabilityGetEncoderQualityRangeAJnormal(napi_env env, napi_callback_info info) 596{ 597 napi_value result = nullptr; 598 int backParam = FAIL; 599 OH_AVCapability *capability = nullptr; 600 OH_AVRange qualityRange; 601 OH_AVErrCode checkParam; 602 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_JPG, isEncoder, SOFTWARE); 603 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 604 if (checkParam == AV_ERR_OK) { 605 backParam = SUCCESS; 606 } 607 napi_create_int32(env, backParam, &result); 608 return result; 609} 610 611static napi_value OHAvCapabilityGetEncoderQualityRangeAKnormal(napi_env env, napi_callback_info info) 612{ 613 napi_value result = nullptr; 614 int backParam = FAIL; 615 OH_AVCapability *capability = nullptr; 616 OH_AVRange qualityRange; 617 OH_AVErrCode checkParam; 618 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_PNG, isEncoder, SOFTWARE); 619 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 620 if (checkParam == AV_ERR_OK) { 621 backParam = SUCCESS; 622 } 623 napi_create_int32(env, backParam, &result); 624 return result; 625} 626 627static napi_value OHAvCapabilityGetEncoderQualityRangeALnormal(napi_env env, napi_callback_info info) 628{ 629 napi_value result = nullptr; 630 int backParam = FAIL; 631 OH_AVCapability *capability = nullptr; 632 OH_AVRange qualityRange; 633 OH_AVErrCode checkParam; 634 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_BMP, isEncoder, SOFTWARE); 635 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 636 if (checkParam == AV_ERR_OK) { 637 backParam = SUCCESS; 638 } 639 napi_create_int32(env, backParam, &result); 640 return result; 641} 642 643static napi_value OHAvCapabilityGetEncoderQualityRangeAMnormal(napi_env env, napi_callback_info info) 644{ 645 napi_value result = nullptr; 646 int backParam = FAIL; 647 OH_AVCapability *capability = nullptr; 648 OH_AVRange qualityRange; 649 OH_AVErrCode checkParam; 650 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder, SOFTWARE); 651 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 652 if (checkParam == AV_ERR_OK) { 653 backParam = SUCCESS; 654 } 655 napi_create_int32(env, backParam, &result); 656 return result; 657} 658 659static napi_value OHAvCapabilityGetEncoderComplexityRangeAnormal(napi_env env, napi_callback_info info) 660{ 661 napi_value result = nullptr; 662 int backParam = FAIL; 663 OH_AVCapability *capability = nullptr; 664 OH_AVRange complexityRange; 665 OH_AVErrCode checkParam; 666 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_AAC, isEncoder, HARDWARE); 667 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 668 if (checkParam == AV_ERR_OK) { 669 backParam = SUCCESS; 670 } 671 napi_create_int32(env, backParam, &result); 672 return result; 673} 674 675static napi_value OHAvCapabilityGetEncoderComplexityRangeBnormal(napi_env env, napi_callback_info info) 676{ 677 napi_value result = nullptr; 678 int backParam = FAIL; 679 OH_AVCapability *capability = nullptr; 680 OH_AVRange complexityRange; 681 OH_AVErrCode checkParam; 682 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, isEncoder, HARDWARE); 683 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 684 if (checkParam == AV_ERR_OK) { 685 backParam = SUCCESS; 686 } 687 napi_create_int32(env, backParam, &result); 688 return result; 689} 690 691static napi_value OHAvCapabilityGetEncoderComplexityRangeCnormal(napi_env env, napi_callback_info info) 692{ 693 napi_value result = nullptr; 694 int backParam = FAIL; 695 OH_AVCapability *capability = nullptr; 696 OH_AVRange complexityRange; 697 OH_AVErrCode checkParam; 698 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, isEncoder, HARDWARE); 699 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 700 if (checkParam == AV_ERR_OK) { 701 backParam = SUCCESS; 702 } 703 napi_create_int32(env, backParam, &result); 704 return result; 705} 706 707static napi_value OHAvCapabilityGetEncoderComplexityRangeDnormal(napi_env env, napi_callback_info info) 708{ 709 napi_value result = nullptr; 710 int backParam = FAIL; 711 OH_AVCapability *capability = nullptr; 712 OH_AVRange complexityRange; 713 OH_AVErrCode checkParam; 714 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_MPEG, isEncoder, HARDWARE); 715 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 716 if (checkParam == AV_ERR_OK) { 717 backParam = SUCCESS; 718 } 719 napi_create_int32(env, backParam, &result); 720 return result; 721} 722 723static napi_value OHAvCapabilityGetEncoderComplexityRangeEnormal(napi_env env, napi_callback_info info) 724{ 725 napi_value result = nullptr; 726 int backParam = FAIL; 727 OH_AVCapability *capability = nullptr; 728 OH_AVRange complexityRange; 729 OH_AVErrCode checkParam; 730 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isEncoder, HARDWARE); 731 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 732 if (checkParam == AV_ERR_OK) { 733 backParam = SUCCESS; 734 } 735 napi_create_int32(env, backParam, &result); 736 return result; 737} 738 739static napi_value OHAvCapabilityGetEncoderComplexityRangeFnormal(napi_env env, napi_callback_info info) 740{ 741 napi_value result = nullptr; 742 int backParam = FAIL; 743 OH_AVCapability *capability = nullptr; 744 OH_AVRange complexityRange; 745 OH_AVErrCode checkParam; 746 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, isEncoder, HARDWARE); 747 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 748 if (checkParam == AV_ERR_OK) { 749 backParam = SUCCESS; 750 } 751 napi_create_int32(env, backParam, &result); 752 return result; 753} 754 755static napi_value OHAvCapabilityGetEncoderComplexityRangeGnormal(napi_env env, napi_callback_info info) 756{ 757 napi_value result = nullptr; 758 int backParam = FAIL; 759 OH_AVCapability *capability = nullptr; 760 OH_AVRange complexityRange; 761 OH_AVErrCode checkParam; 762 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_JPG, isEncoder, HARDWARE); 763 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 764 if (checkParam == AV_ERR_OK) { 765 backParam = SUCCESS; 766 } 767 napi_create_int32(env, backParam, &result); 768 return result; 769} 770 771static napi_value OHAvCapabilityGetEncoderComplexityRangeHnormal(napi_env env, napi_callback_info info) 772{ 773 napi_value result = nullptr; 774 int backParam = FAIL; 775 OH_AVCapability *capability = nullptr; 776 OH_AVRange complexityRange; 777 OH_AVErrCode checkParam; 778 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_PNG, isEncoder, HARDWARE); 779 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 780 if (checkParam == AV_ERR_OK) { 781 backParam = SUCCESS; 782 } 783 napi_create_int32(env, backParam, &result); 784 return result; 785} 786 787static napi_value OHAvCapabilityGetEncoderComplexityRangeInormal(napi_env env, napi_callback_info info) 788{ 789 napi_value result = nullptr; 790 int backParam = FAIL; 791 OH_AVCapability *capability = nullptr; 792 OH_AVRange complexityRange; 793 OH_AVErrCode checkParam; 794 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_BMP, isEncoder, HARDWARE); 795 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 796 if (checkParam == AV_ERR_OK) { 797 backParam = SUCCESS; 798 } 799 napi_create_int32(env, backParam, &result); 800 return result; 801} 802 803static napi_value OHAvCapabilityGetEncoderComplexityRangeJnormal(napi_env env, napi_callback_info info) 804{ 805 napi_value result = nullptr; 806 int backParam = FAIL; 807 OH_AVCapability *capability = nullptr; 808 OH_AVRange complexityRange; 809 OH_AVErrCode checkParam; 810 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isDecoder, HARDWARE); 811 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 812 if (checkParam == AV_ERR_OK) { 813 backParam = SUCCESS; 814 } 815 napi_create_int32(env, backParam, &result); 816 return result; 817} 818 819static napi_value OHAvCapabilityGetEncoderComplexityRangeKnormal(napi_env env, napi_callback_info info) 820{ 821 napi_value result = nullptr; 822 int backParam = FAIL; 823 OH_AVCapability *capability = nullptr; 824 OH_AVRange complexityRange; 825 OH_AVErrCode checkParam; 826 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_AAC, isDecoder, HARDWARE); 827 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 828 if (checkParam == AV_ERR_OK) { 829 backParam = SUCCESS; 830 } 831 napi_create_int32(env, backParam, &result); 832 return result; 833} 834 835static napi_value OHAvCapabilityGetEncoderComplexityRangeLnormal(napi_env env, napi_callback_info info) 836{ 837 napi_value result = nullptr; 838 int backParam = FAIL; 839 OH_AVCapability *capability = nullptr; 840 OH_AVRange complexityRange; 841 OH_AVErrCode checkParam; 842 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, isDecoder, HARDWARE); 843 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 844 if (checkParam == AV_ERR_OK) { 845 backParam = SUCCESS; 846 } 847 napi_create_int32(env, backParam, &result); 848 return result; 849} 850 851static napi_value OHAvCapabilityGetEncoderComplexityRangeMnormal(napi_env env, napi_callback_info info) 852{ 853 napi_value result = nullptr; 854 int backParam = FAIL; 855 OH_AVCapability *capability = nullptr; 856 OH_AVRange complexityRange; 857 OH_AVErrCode checkParam; 858 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, isDecoder, HARDWARE); 859 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 860 if (checkParam == AV_ERR_OK) { 861 backParam = SUCCESS; 862 } 863 napi_create_int32(env, backParam, &result); 864 return result; 865} 866 867static napi_value OHAvCapabilityGetEncoderComplexityRangeNnormal(napi_env env, napi_callback_info info) 868{ 869 napi_value result = nullptr; 870 int backParam = FAIL; 871 OH_AVCapability *capability = nullptr; 872 OH_AVRange complexityRange; 873 OH_AVErrCode checkParam; 874 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_MPEG, isDecoder, HARDWARE); 875 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 876 if (checkParam == AV_ERR_OK) { 877 backParam = SUCCESS; 878 } 879 napi_create_int32(env, backParam, &result); 880 return result; 881} 882 883static napi_value OHAvCapabilityGetEncoderComplexityRangeOnormal(napi_env env, napi_callback_info info) 884{ 885 napi_value result = nullptr; 886 int backParam = FAIL; 887 OH_AVCapability *capability = nullptr; 888 OH_AVRange complexityRange; 889 OH_AVErrCode checkParam; 890 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isDecoder, HARDWARE); 891 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 892 if (checkParam == AV_ERR_OK) { 893 backParam = SUCCESS; 894 } 895 napi_create_int32(env, backParam, &result); 896 return result; 897} 898 899static napi_value OHAvCapabilityGetEncoderComplexityRangePnormal(napi_env env, napi_callback_info info) 900{ 901 napi_value result = nullptr; 902 int backParam = FAIL; 903 OH_AVCapability *capability = nullptr; 904 OH_AVRange complexityRange; 905 OH_AVErrCode checkParam; 906 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, isDecoder, HARDWARE); 907 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 908 if (checkParam == AV_ERR_OK) { 909 backParam = SUCCESS; 910 } 911 napi_create_int32(env, backParam, &result); 912 return result; 913} 914 915static napi_value OHAvCapabilityGetEncoderComplexityRangeQnormal(napi_env env, napi_callback_info info) 916{ 917 napi_value result = nullptr; 918 int backParam = FAIL; 919 OH_AVCapability *capability = nullptr; 920 OH_AVRange complexityRange; 921 OH_AVErrCode checkParam; 922 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_JPG, isDecoder, HARDWARE); 923 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 924 if (checkParam == AV_ERR_OK) { 925 backParam = SUCCESS; 926 } 927 napi_create_int32(env, backParam, &result); 928 return result; 929} 930 931static napi_value OHAvCapabilityGetEncoderComplexityRangeRnormal(napi_env env, napi_callback_info info) 932{ 933 napi_value result = nullptr; 934 int backParam = FAIL; 935 OH_AVCapability *capability = nullptr; 936 OH_AVRange complexityRange; 937 OH_AVErrCode checkParam; 938 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_PNG, isDecoder, HARDWARE); 939 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 940 if (checkParam == AV_ERR_OK) { 941 backParam = SUCCESS; 942 } 943 napi_create_int32(env, backParam, &result); 944 return result; 945} 946 947static napi_value OHAvCapabilityGetEncoderComplexityRangeSnormal(napi_env env, napi_callback_info info) 948{ 949 napi_value result = nullptr; 950 int backParam = FAIL; 951 OH_AVCapability *capability = nullptr; 952 OH_AVRange complexityRange; 953 OH_AVErrCode checkParam; 954 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_BMP, isDecoder, HARDWARE); 955 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 956 if (checkParam == AV_ERR_OK) { 957 backParam = SUCCESS; 958 } 959 napi_create_int32(env, backParam, &result); 960 return result; 961} 962 963static napi_value OHAvCapabilityGetEncoderComplexityRangeTnormal(napi_env env, napi_callback_info info) 964{ 965 napi_value result = nullptr; 966 int backParam = FAIL; 967 OH_AVCapability *capability = nullptr; 968 OH_AVRange complexityRange; 969 OH_AVErrCode checkParam; 970 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isDecoder, SOFTWARE); 971 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 972 if (checkParam == AV_ERR_OK) { 973 backParam = SUCCESS; 974 } 975 napi_create_int32(env, backParam, &result); 976 return result; 977} 978 979static napi_value OHAvCapabilityGetEncoderComplexityRangeUnormal(napi_env env, napi_callback_info info) 980{ 981 napi_value result = nullptr; 982 int backParam = FAIL; 983 OH_AVCapability *capability = nullptr; 984 OH_AVRange complexityRange; 985 OH_AVErrCode checkParam; 986 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_AAC, isDecoder, SOFTWARE); 987 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 988 if (checkParam == AV_ERR_OK) { 989 backParam = SUCCESS; 990 } 991 napi_create_int32(env, backParam, &result); 992 return result; 993} 994 995static napi_value OHAvCapabilityGetEncoderComplexityRangeVnormal(napi_env env, napi_callback_info info) 996{ 997 napi_value result = nullptr; 998 int backParam = FAIL; 999 OH_AVCapability *capability = nullptr; 1000 OH_AVRange complexityRange; 1001 OH_AVErrCode checkParam; 1002 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, isDecoder, SOFTWARE); 1003 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 1004 if (checkParam == AV_ERR_OK) { 1005 backParam = SUCCESS; 1006 } 1007 napi_create_int32(env, backParam, &result); 1008 return result; 1009} 1010 1011static napi_value OHAvCapabilityGetEncoderComplexityRangeWnormal(napi_env env, napi_callback_info info) 1012{ 1013 napi_value result = nullptr; 1014 int backParam = FAIL; 1015 OH_AVCapability *capability = nullptr; 1016 OH_AVRange complexityRange; 1017 OH_AVErrCode checkParam; 1018 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, isDecoder, SOFTWARE); 1019 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 1020 if (checkParam == AV_ERR_OK) { 1021 backParam = SUCCESS; 1022 } 1023 napi_create_int32(env, backParam, &result); 1024 return result; 1025} 1026 1027static napi_value OHAvCapabilityGetEncoderComplexityRangeXnormal(napi_env env, napi_callback_info info) 1028{ 1029 napi_value result = nullptr; 1030 int backParam = FAIL; 1031 OH_AVCapability *capability = nullptr; 1032 OH_AVRange complexityRange; 1033 OH_AVErrCode checkParam; 1034 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_MPEG, isDecoder, SOFTWARE); 1035 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 1036 if (checkParam == AV_ERR_OK) { 1037 backParam = SUCCESS; 1038 } 1039 napi_create_int32(env, backParam, &result); 1040 return result; 1041} 1042 1043static napi_value OHAvCapabilityGetEncoderComplexityRangeYnormal(napi_env env, napi_callback_info info) 1044{ 1045 napi_value result = nullptr; 1046 int backParam = FAIL; 1047 OH_AVCapability *capability = nullptr; 1048 OH_AVRange complexityRange; 1049 OH_AVErrCode checkParam; 1050 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isDecoder, SOFTWARE); 1051 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 1052 if (checkParam == AV_ERR_OK) { 1053 backParam = SUCCESS; 1054 } 1055 napi_create_int32(env, backParam, &result); 1056 return result; 1057} 1058 1059static napi_value OHAvCapabilityGetEncoderComplexityRangeZnormal(napi_env env, napi_callback_info info) 1060{ 1061 napi_value result = nullptr; 1062 int backParam = FAIL; 1063 OH_AVCapability *capability = nullptr; 1064 OH_AVRange complexityRange; 1065 OH_AVErrCode checkParam; 1066 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, isDecoder, SOFTWARE); 1067 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 1068 if (checkParam == AV_ERR_OK) { 1069 backParam = SUCCESS; 1070 } 1071 napi_create_int32(env, backParam, &result); 1072 return result; 1073} 1074 1075static napi_value OHAvCapabilityGetEncoderComplexityRangeAAnormal(napi_env env, napi_callback_info info) 1076{ 1077 napi_value result = nullptr; 1078 int backParam = FAIL; 1079 OH_AVCapability *capability = nullptr; 1080 OH_AVRange complexityRange; 1081 OH_AVErrCode checkParam; 1082 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_JPG, isDecoder, SOFTWARE); 1083 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 1084 if (checkParam == AV_ERR_OK) { 1085 backParam = SUCCESS; 1086 } 1087 napi_create_int32(env, backParam, &result); 1088 return result; 1089} 1090 1091static napi_value OHAvCapabilityGetEncoderComplexityRangeABnormal(napi_env env, napi_callback_info info) 1092{ 1093 napi_value result = nullptr; 1094 int backParam = FAIL; 1095 OH_AVCapability *capability = nullptr; 1096 OH_AVRange complexityRange; 1097 OH_AVErrCode checkParam; 1098 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_PNG, isDecoder, SOFTWARE); 1099 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 1100 if (checkParam == AV_ERR_OK) { 1101 backParam = SUCCESS; 1102 } 1103 napi_create_int32(env, backParam, &result); 1104 return result; 1105} 1106 1107static napi_value OHAvCapabilityGetEncoderComplexityRangeACnormal(napi_env env, napi_callback_info info) 1108{ 1109 napi_value result = nullptr; 1110 int backParam = FAIL; 1111 OH_AVCapability *capability = nullptr; 1112 OH_AVRange complexityRange; 1113 OH_AVErrCode checkParam; 1114 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_BMP, isDecoder, SOFTWARE); 1115 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 1116 if (checkParam == AV_ERR_OK) { 1117 backParam = SUCCESS; 1118 } 1119 napi_create_int32(env, backParam, &result); 1120 return result; 1121} 1122 1123static napi_value OHAvCapabilityGetEncoderComplexityRangeADnormal(napi_env env, napi_callback_info info) 1124{ 1125 napi_value result = nullptr; 1126 int backParam = FAIL; 1127 OH_AVCapability *capability = nullptr; 1128 OH_AVRange complexityRange; 1129 OH_AVErrCode checkParam; 1130 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder, SOFTWARE); 1131 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 1132 if (checkParam == AV_ERR_OK) { 1133 backParam = SUCCESS; 1134 } 1135 napi_create_int32(env, backParam, &result); 1136 return result; 1137} 1138 1139static napi_value OHAvCapabilityGetEncoderComplexityRangeAEnormal(napi_env env, napi_callback_info info) 1140{ 1141 napi_value result = nullptr; 1142 int backParam = FAIL; 1143 OH_AVCapability *capability = nullptr; 1144 OH_AVRange complexityRange; 1145 OH_AVErrCode checkParam; 1146 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_AAC, isEncoder, SOFTWARE); 1147 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 1148 if (checkParam == AV_ERR_OK) { 1149 backParam = SUCCESS; 1150 } 1151 napi_create_int32(env, backParam, &result); 1152 return result; 1153} 1154 1155static napi_value OHAvCapabilityGetEncoderComplexityRangeAFnormal(napi_env env, napi_callback_info info) 1156{ 1157 napi_value result = nullptr; 1158 int backParam = FAIL; 1159 OH_AVCapability *capability = nullptr; 1160 OH_AVRange complexityRange; 1161 OH_AVErrCode checkParam; 1162 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, isEncoder, SOFTWARE); 1163 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 1164 if (checkParam == AV_ERR_OK) { 1165 backParam = SUCCESS; 1166 } 1167 napi_create_int32(env, backParam, &result); 1168 return result; 1169} 1170 1171static napi_value OHAvCapabilityGetEncoderComplexityRangeAGnormal(napi_env env, napi_callback_info info) 1172{ 1173 napi_value result = nullptr; 1174 int backParam = FAIL; 1175 OH_AVCapability *capability = nullptr; 1176 OH_AVRange complexityRange; 1177 OH_AVErrCode checkParam; 1178 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, isEncoder, SOFTWARE); 1179 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 1180 if (checkParam == AV_ERR_OK) { 1181 backParam = SUCCESS; 1182 } 1183 napi_create_int32(env, backParam, &result); 1184 return result; 1185} 1186 1187static napi_value OHAvCapabilityGetEncoderComplexityRangeAHnormal(napi_env env, napi_callback_info info) 1188{ 1189 napi_value result = nullptr; 1190 int backParam = FAIL; 1191 OH_AVCapability *capability = nullptr; 1192 OH_AVRange complexityRange; 1193 OH_AVErrCode checkParam; 1194 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_MPEG, isEncoder, SOFTWARE); 1195 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 1196 if (checkParam == AV_ERR_OK) { 1197 backParam = SUCCESS; 1198 } 1199 napi_create_int32(env, backParam, &result); 1200 return result; 1201} 1202 1203static napi_value OHAvCapabilityGetEncoderComplexityRangeAInormal(napi_env env, napi_callback_info info) 1204{ 1205 napi_value result = nullptr; 1206 int backParam = FAIL; 1207 OH_AVCapability *capability = nullptr; 1208 OH_AVRange complexityRange; 1209 OH_AVErrCode checkParam; 1210 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isEncoder, SOFTWARE); 1211 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 1212 if (checkParam == AV_ERR_OK) { 1213 backParam = SUCCESS; 1214 } 1215 napi_create_int32(env, backParam, &result); 1216 return result; 1217} 1218 1219static napi_value OHAvCapabilityGetEncoderComplexityRangeAJnormal(napi_env env, napi_callback_info info) 1220{ 1221 napi_value result = nullptr; 1222 int backParam = FAIL; 1223 OH_AVCapability *capability = nullptr; 1224 OH_AVRange complexityRange; 1225 OH_AVErrCode checkParam; 1226 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, isEncoder, SOFTWARE); 1227 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 1228 if (checkParam == AV_ERR_OK) { 1229 backParam = SUCCESS; 1230 } 1231 napi_create_int32(env, backParam, &result); 1232 return result; 1233} 1234 1235static napi_value OHAvCapabilityGetEncoderComplexityRangeAKnormal(napi_env env, napi_callback_info info) 1236{ 1237 napi_value result = nullptr; 1238 int backParam = FAIL; 1239 OH_AVCapability *capability = nullptr; 1240 OH_AVRange complexityRange; 1241 OH_AVErrCode checkParam; 1242 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_JPG, isEncoder, SOFTWARE); 1243 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 1244 if (checkParam == AV_ERR_OK) { 1245 backParam = SUCCESS; 1246 } 1247 napi_create_int32(env, backParam, &result); 1248 return result; 1249} 1250 1251static napi_value OHAvCapabilityGetEncoderComplexityRangeALnormal(napi_env env, napi_callback_info info) 1252{ 1253 napi_value result = nullptr; 1254 int backParam = FAIL; 1255 OH_AVCapability *capability = nullptr; 1256 OH_AVRange complexityRange; 1257 OH_AVErrCode checkParam; 1258 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_PNG, isEncoder, SOFTWARE); 1259 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 1260 if (checkParam == AV_ERR_OK) { 1261 backParam = SUCCESS; 1262 } 1263 napi_create_int32(env, backParam, &result); 1264 return result; 1265} 1266 1267static napi_value OHAvCapabilityGetEncoderComplexityRangeAMnormal(napi_env env, napi_callback_info info) 1268{ 1269 napi_value result = nullptr; 1270 int backParam = FAIL; 1271 OH_AVCapability *capability = nullptr; 1272 OH_AVRange complexityRange; 1273 OH_AVErrCode checkParam; 1274 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_IMAGE_BMP, isEncoder, SOFTWARE); 1275 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 1276 if (checkParam == AV_ERR_OK) { 1277 backParam = SUCCESS; 1278 } 1279 napi_create_int32(env, backParam, &result); 1280 return result; 1281} 1282 1283static napi_value OHAvCapabilityGetAudioSupportedSampleRatesAbnormal(napi_env env, napi_callback_info info) 1284{ 1285 napi_value result = nullptr; 1286 int backParam = FAIL; 1287 OH_AVCapability *capability = nullptr; 1288 OH_AVErrCode checkParam; 1289 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, isEncoder, SOFTWARE); 1290 checkParam = OH_AVCapability_GetAudioSupportedSampleRates(capability, nullptr, nullptr); 1291 if (checkParam == AV_ERR_INVALID_VAL) { 1292 backParam = SUCCESS; 1293 } 1294 napi_create_int32(env, backParam, &result); 1295 return result; 1296} 1297 1298static napi_value OHAvCapabilityGetAudioSupportedSampleRatesAnormal(napi_env env, napi_callback_info info) 1299{ 1300 napi_value result = nullptr; 1301 int backParam = FAIL; 1302 OH_AVCapability *capability = nullptr; 1303 const int32_t *sampleRates = nullptr; 1304 uint32_t sampleRateNum; 1305 OH_AVErrCode checkParam; 1306 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_AAC, isEncoder, SOFTWARE); 1307 checkParam = OH_AVCapability_GetAudioSupportedSampleRates(capability, &sampleRates, &sampleRateNum); 1308 if (checkParam == AV_ERR_OK) { 1309 backParam = SUCCESS; 1310 } 1311 napi_create_int32(env, backParam, &result); 1312 return result; 1313} 1314static napi_value OHAvCapabilityGetAudioSupportedSampleRatesBnormal(napi_env env, napi_callback_info info) 1315{ 1316 napi_value result = nullptr; 1317 int backParam = FAIL; 1318 OH_AVCapability *capability = nullptr; 1319 OH_AVErrCode checkParam; 1320 const int32_t *sampleRates = nullptr; 1321 uint32_t sampleRateNum; 1322 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, isEncoder, SOFTWARE); 1323 checkParam = OH_AVCapability_GetAudioSupportedSampleRates(capability, &sampleRates, &sampleRateNum); 1324 if (checkParam == AV_ERR_OK) { 1325 backParam = SUCCESS; 1326 } 1327 napi_create_int32(env, backParam, &result); 1328 return result; 1329} 1330static napi_value OHAvCapabilityGetAudioSupportedSampleRatesCnormal(napi_env env, napi_callback_info info) 1331{ 1332 napi_value result = nullptr; 1333 int backParam = FAIL; 1334 OH_AVCapability *capability = nullptr; 1335 OH_AVErrCode checkParam; 1336 const int32_t *sampleRates = nullptr; 1337 uint32_t sampleRateNum; 1338 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_MPEG, isEncoder, SOFTWARE); 1339 checkParam = OH_AVCapability_GetAudioSupportedSampleRates(capability, &sampleRates, &sampleRateNum); 1340 if (checkParam == AV_ERR_OK) { 1341 backParam = SUCCESS; 1342 } 1343 napi_create_int32(env, backParam, &result); 1344 return result; 1345} 1346 1347static napi_value OHAvCapabilityGetAudioSupportedSampleRatesDnormal(napi_env env, napi_callback_info info) 1348{ 1349 napi_value result = nullptr; 1350 int backParam = FAIL; 1351 OH_AVCapability *capability = nullptr; 1352 OH_AVErrCode checkParam; 1353 const int32_t *sampleRates = nullptr; 1354 uint32_t sampleRateNum; 1355 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_AAC, isDecoder, SOFTWARE); 1356 checkParam = OH_AVCapability_GetAudioSupportedSampleRates(capability, &sampleRates, &sampleRateNum); 1357 if (checkParam == AV_ERR_OK) { 1358 backParam = SUCCESS; 1359 } 1360 napi_create_int32(env, backParam, &result); 1361 return result; 1362} 1363 1364static napi_value OHAvCapabilityGetAudioSupportedSampleRatesEnormal(napi_env env, napi_callback_info info) 1365{ 1366 napi_value result = nullptr; 1367 int backParam = FAIL; 1368 OH_AVCapability *capability = nullptr; 1369 OH_AVErrCode checkParam; 1370 const int32_t *sampleRates = nullptr; 1371 uint32_t sampleRateNum; 1372 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, isDecoder, SOFTWARE); 1373 checkParam = OH_AVCapability_GetAudioSupportedSampleRates(capability, &sampleRates, &sampleRateNum); 1374 if (checkParam == AV_ERR_OK) { 1375 backParam = SUCCESS; 1376 } 1377 napi_create_int32(env, backParam, &result); 1378 return result; 1379} 1380 1381static napi_value OHAvCapabilityGetAudioSupportedSampleRatesFnormal(napi_env env, napi_callback_info info) 1382{ 1383 napi_value result = nullptr; 1384 int backParam = FAIL; 1385 OH_AVCapability *capability = nullptr; 1386 OH_AVErrCode checkParam; 1387 const int32_t *sampleRates = nullptr; 1388 uint32_t sampleRateNum; 1389 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_MPEG, isDecoder, SOFTWARE); 1390 checkParam = OH_AVCapability_GetAudioSupportedSampleRates(capability, &sampleRates, &sampleRateNum); 1391 if (checkParam == AV_ERR_OK) { 1392 backParam = SUCCESS; 1393 } 1394 napi_create_int32(env, backParam, &result); 1395 return result; 1396} 1397 1398static napi_value OHAvCapabilityGetAudioSupportedSampleRatesGnormal(napi_env env, napi_callback_info info) 1399{ 1400 napi_value result = nullptr; 1401 int backParam = FAIL; 1402 OH_AVCapability *capability = nullptr; 1403 OH_AVErrCode checkParam; 1404 const int32_t *sampleRates = nullptr; 1405 uint32_t sampleRateNum; 1406 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, isEncoder, SOFTWARE); 1407 checkParam = OH_AVCapability_GetAudioSupportedSampleRates(capability, &sampleRates, &sampleRateNum); 1408 if (checkParam == AV_ERR_OK) { 1409 backParam = SUCCESS; 1410 } 1411 napi_create_int32(env, backParam, &result); 1412 return result; 1413} 1414 1415static napi_value OHAvCapabilityGetAudioSupportedSampleRatesHnormal(napi_env env, napi_callback_info info) 1416{ 1417 napi_value result = nullptr; 1418 int backParam = FAIL; 1419 OH_AVCapability *capability = nullptr; 1420 OH_AVErrCode checkParam; 1421 const int32_t *sampleRates = nullptr; 1422 uint32_t sampleRateNum; 1423 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_AAC, isDecoder, HARDWARE); 1424 checkParam = OH_AVCapability_GetAudioSupportedSampleRates(capability, &sampleRates, &sampleRateNum); 1425 if (checkParam == AV_ERR_OK) { 1426 backParam = SUCCESS; 1427 } 1428 napi_create_int32(env, backParam, &result); 1429 return result; 1430} 1431 1432static napi_value OHAvCapabilityGetAudioSupportedSampleRatesInormal(napi_env env, napi_callback_info info) 1433{ 1434 napi_value result = nullptr; 1435 int backParam = FAIL; 1436 OH_AVCapability *capability = nullptr; 1437 OH_AVErrCode checkParam; 1438 const int32_t *sampleRates = nullptr; 1439 uint32_t sampleRateNum; 1440 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, isDecoder, HARDWARE); 1441 checkParam = OH_AVCapability_GetAudioSupportedSampleRates(capability, &sampleRates, &sampleRateNum); 1442 if (checkParam == AV_ERR_OK) { 1443 backParam = SUCCESS; 1444 } 1445 napi_create_int32(env, backParam, &result); 1446 return result; 1447} 1448 1449static napi_value OHAvCapabilityGetAudioSupportedSampleRatesJnormal(napi_env env, napi_callback_info info) 1450{ 1451 napi_value result = nullptr; 1452 int backParam = FAIL; 1453 OH_AVCapability *capability = nullptr; 1454 OH_AVErrCode checkParam; 1455 const int32_t *sampleRates = nullptr; 1456 uint32_t sampleRateNum; 1457 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_MPEG, isDecoder, HARDWARE); 1458 checkParam = OH_AVCapability_GetAudioSupportedSampleRates(capability, &sampleRates, &sampleRateNum); 1459 if (checkParam == AV_ERR_OK) { 1460 backParam = SUCCESS; 1461 } 1462 napi_create_int32(env, backParam, &result); 1463 return result; 1464} 1465 1466static napi_value OHAvCapabilityGetAudioSupportedSampleRatesKnormal(napi_env env, napi_callback_info info) 1467{ 1468 napi_value result = nullptr; 1469 int backParam = FAIL; 1470 OH_AVCapability *capability = nullptr; 1471 OH_AVErrCode checkParam; 1472 const int32_t *sampleRates = nullptr; 1473 uint32_t sampleRateNum; 1474 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, isDecoder, HARDWARE); 1475 checkParam = OH_AVCapability_GetAudioSupportedSampleRates(capability, &sampleRates, &sampleRateNum); 1476 if (checkParam == AV_ERR_OK) { 1477 backParam = SUCCESS; 1478 } 1479 napi_create_int32(env, backParam, &result); 1480 return result; 1481} 1482 1483static napi_value OHAvCapabilityGetAudioSupportedSampleRatesLnormal(napi_env env, napi_callback_info info) 1484{ 1485 napi_value result = nullptr; 1486 int backParam = FAIL; 1487 OH_AVCapability *capability = nullptr; 1488 OH_AVErrCode checkParam; 1489 const int32_t *sampleRates = nullptr; 1490 uint32_t sampleRateNum; 1491 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_AAC, isEncoder, HARDWARE); 1492 checkParam = OH_AVCapability_GetAudioSupportedSampleRates(capability, &sampleRates, &sampleRateNum); 1493 if (checkParam == AV_ERR_OK) { 1494 backParam = SUCCESS; 1495 } 1496 napi_create_int32(env, backParam, &result); 1497 return result; 1498} 1499 1500static napi_value OHAvCapabilityGetAudioSupportedSampleRatesMnormal(napi_env env, napi_callback_info info) 1501{ 1502 napi_value result = nullptr; 1503 int backParam = FAIL; 1504 OH_AVCapability *capability = nullptr; 1505 OH_AVErrCode checkParam; 1506 const int32_t *sampleRates = nullptr; 1507 uint32_t sampleRateNum; 1508 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, isEncoder, HARDWARE); 1509 checkParam = OH_AVCapability_GetAudioSupportedSampleRates(capability, &sampleRates, &sampleRateNum); 1510 if (checkParam == AV_ERR_OK) { 1511 backParam = SUCCESS; 1512 } 1513 napi_create_int32(env, backParam, &result); 1514 return result; 1515} 1516 1517static napi_value OHAvCapabilityGetAudioSupportedSampleRatesNnormal(napi_env env, napi_callback_info info) 1518{ 1519 napi_value result = nullptr; 1520 int backParam = FAIL; 1521 OH_AVCapability *capability = nullptr; 1522 OH_AVErrCode checkParam; 1523 const int32_t *sampleRates = nullptr; 1524 uint32_t sampleRateNum; 1525 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_MPEG, isEncoder, HARDWARE); 1526 checkParam = OH_AVCapability_GetAudioSupportedSampleRates(capability, &sampleRates, &sampleRateNum); 1527 if (checkParam == AV_ERR_OK) { 1528 backParam = SUCCESS; 1529 } 1530 napi_create_int32(env, backParam, &result); 1531 return result; 1532} 1533 1534static napi_value OHAvCapabilityGetAudioSupportedSampleRatesOnormal(napi_env env, napi_callback_info info) 1535{ 1536 napi_value result = nullptr; 1537 int backParam = FAIL; 1538 OH_AVCapability *capability = nullptr; 1539 OH_AVErrCode checkParam; 1540 const int32_t *sampleRates = nullptr; 1541 uint32_t sampleRateNum; 1542 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, isEncoder, HARDWARE); 1543 checkParam = OH_AVCapability_GetAudioSupportedSampleRates(capability, &sampleRates, &sampleRateNum); 1544 if (checkParam == AV_ERR_OK) { 1545 backParam = SUCCESS; 1546 } 1547 napi_create_int32(env, backParam, &result); 1548 return result; 1549} 1550 1551static napi_value OHAvCapabilityGetAudioSupportedSampleRatesPnormal(napi_env env, napi_callback_info info) 1552{ 1553 napi_value result = nullptr; 1554 int backParam = FAIL; 1555 OH_AVCapability *capability = nullptr; 1556 OH_AVErrCode checkParam; 1557 const int32_t *sampleRates = nullptr; 1558 uint32_t sampleRateNum; 1559 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder, HARDWARE); 1560 checkParam = OH_AVCapability_GetAudioSupportedSampleRates(capability, &sampleRates, &sampleRateNum); 1561 if (checkParam == AV_ERR_INVALID_VAL) { 1562 backParam = SUCCESS; 1563 } 1564 napi_create_int32(env, backParam, &result); 1565 return result; 1566} 1567 1568static napi_value OHAvCapabilityGetAudioChannelCountRangeAnormal(napi_env env, napi_callback_info info) 1569{ 1570 napi_value result = nullptr; 1571 int backParam = FAIL; 1572 OH_AVCapability *capability = nullptr; 1573 OH_AVRange channelCountRange; 1574 OH_AVErrCode checkParam; 1575 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isDecoder); 1576 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1577 if (checkParam == AV_ERR_OK) { 1578 backParam = SUCCESS; 1579 } 1580 napi_create_int32(env, backParam, &result); 1581 return result; 1582} 1583 1584static napi_value OHAvCapabilityGetAudioChannelCountRangeBnormal(napi_env env, napi_callback_info info) 1585{ 1586 napi_value result = nullptr; 1587 int backParam = FAIL; 1588 OH_AVCapability *capability = nullptr; 1589 OH_AVRange channelCountRange; 1590 OH_AVErrCode checkParam; 1591 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_AUDIO_AAC, isDecoder); 1592 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1593 if (checkParam == AV_ERR_OK) { 1594 backParam = SUCCESS; 1595 } 1596 napi_create_int32(env, backParam, &result); 1597 return result; 1598} 1599 1600static napi_value OHAvCapabilityGetAudioChannelCountRangeCnormal(napi_env env, napi_callback_info info) 1601{ 1602 napi_value result = nullptr; 1603 int backParam = FAIL; 1604 OH_AVCapability *capability = nullptr; 1605 OH_AVRange channelCountRange; 1606 OH_AVErrCode checkParam; 1607 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, isDecoder); 1608 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1609 if (checkParam == AV_ERR_OK) { 1610 backParam = SUCCESS; 1611 } 1612 napi_create_int32(env, backParam, &result); 1613 return result; 1614} 1615 1616static napi_value OHAvCapabilityGetAudioChannelCountRangeDnormal(napi_env env, napi_callback_info info) 1617{ 1618 napi_value result = nullptr; 1619 int backParam = FAIL; 1620 OH_AVCapability *capability = nullptr; 1621 OH_AVRange channelCountRange; 1622 OH_AVErrCode checkParam; 1623 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_AUDIO_MPEG, isDecoder); 1624 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1625 if (checkParam == AV_ERR_OK) { 1626 backParam = SUCCESS; 1627 } 1628 napi_create_int32(env, backParam, &result); 1629 return result; 1630} 1631 1632static napi_value OHAvCapabilityGetAudioChannelCountRangeEnormal(napi_env env, napi_callback_info info) 1633{ 1634 napi_value result = nullptr; 1635 int backParam = FAIL; 1636 OH_AVCapability *capability = nullptr; 1637 OH_AVRange channelCountRange; 1638 OH_AVErrCode checkParam; 1639 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isDecoder); 1640 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1641 if (checkParam == AV_ERR_OK) { 1642 backParam = SUCCESS; 1643 } 1644 napi_create_int32(env, backParam, &result); 1645 return result; 1646} 1647 1648static napi_value OHAvCapabilityGetAudioChannelCountRangeFnormal(napi_env env, napi_callback_info info) 1649{ 1650 napi_value result = nullptr; 1651 int backParam = FAIL; 1652 OH_AVCapability *capability = nullptr; 1653 OH_AVRange channelCountRange; 1654 OH_AVErrCode checkParam; 1655 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, isDecoder); 1656 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1657 if (checkParam == AV_ERR_OK) { 1658 backParam = SUCCESS; 1659 } 1660 napi_create_int32(env, backParam, &result); 1661 return result; 1662} 1663 1664static napi_value OHAvCapabilityGetAudioChannelCountRangeGnormal(napi_env env, napi_callback_info info) 1665{ 1666 napi_value result = nullptr; 1667 int backParam = FAIL; 1668 OH_AVCapability *capability = nullptr; 1669 OH_AVRange channelCountRange; 1670 OH_AVErrCode checkParam; 1671 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_IMAGE_JPG, isDecoder); 1672 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1673 if (checkParam == AV_ERR_OK) { 1674 backParam = SUCCESS; 1675 } 1676 napi_create_int32(env, backParam, &result); 1677 return result; 1678} 1679 1680static napi_value OHAvCapabilityGetAudioChannelCountRangeHnormal(napi_env env, napi_callback_info info) 1681{ 1682 napi_value result = nullptr; 1683 int backParam = FAIL; 1684 OH_AVCapability *capability = nullptr; 1685 OH_AVRange channelCountRange; 1686 OH_AVErrCode checkParam; 1687 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_IMAGE_PNG, isDecoder); 1688 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1689 if (checkParam == AV_ERR_OK) { 1690 backParam = SUCCESS; 1691 } 1692 napi_create_int32(env, backParam, &result); 1693 return result; 1694} 1695 1696static napi_value OHAvCapabilityGetAudioChannelCountRangeInormal(napi_env env, napi_callback_info info) 1697{ 1698 napi_value result = nullptr; 1699 int backParam = FAIL; 1700 OH_AVCapability *capability = nullptr; 1701 OH_AVRange channelCountRange; 1702 OH_AVErrCode checkParam; 1703 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_IMAGE_BMP, isDecoder); 1704 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1705 if (checkParam == AV_ERR_OK) { 1706 backParam = SUCCESS; 1707 } 1708 napi_create_int32(env, backParam, &result); 1709 return result; 1710} 1711 1712static napi_value OHAvCapabilityGetAudioChannelCountRangeJnormal(napi_env env, napi_callback_info info) 1713{ 1714 napi_value result = nullptr; 1715 int backParam = FAIL; 1716 OH_AVCapability *capability = nullptr; 1717 OH_AVRange channelCountRange; 1718 OH_AVErrCode checkParam; 1719 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, isEncoder); 1720 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1721 if (checkParam == AV_ERR_OK) { 1722 backParam = SUCCESS; 1723 } 1724 napi_create_int32(env, backParam, &result); 1725 return result; 1726} 1727 1728static napi_value OHAvCapabilityGetAudioChannelCountRangeKnormal(napi_env env, napi_callback_info info) 1729{ 1730 napi_value result = nullptr; 1731 int backParam = FAIL; 1732 OH_AVCapability *capability = nullptr; 1733 OH_AVRange channelCountRange; 1734 OH_AVErrCode checkParam; 1735 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder); 1736 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1737 if (checkParam == AV_ERR_OK) { 1738 backParam = SUCCESS; 1739 } 1740 napi_create_int32(env, backParam, &result); 1741 return result; 1742} 1743 1744static napi_value OHAvCapabilityGetAudioChannelCountRangeLnormal(napi_env env, napi_callback_info info) 1745{ 1746 napi_value result = nullptr; 1747 int backParam = FAIL; 1748 OH_AVCapability *capability = nullptr; 1749 OH_AVRange channelCountRange; 1750 OH_AVErrCode checkParam; 1751 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_AUDIO_AAC, isEncoder); 1752 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1753 if (checkParam == AV_ERR_OK) { 1754 backParam = SUCCESS; 1755 } 1756 napi_create_int32(env, backParam, &result); 1757 return result; 1758} 1759 1760static napi_value OHAvCapabilityGetAudioChannelCountRangeMnormal(napi_env env, napi_callback_info info) 1761{ 1762 napi_value result = nullptr; 1763 int backParam = FAIL; 1764 OH_AVCapability *capability = nullptr; 1765 OH_AVRange channelCountRange; 1766 OH_AVErrCode checkParam; 1767 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, isEncoder); 1768 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1769 if (checkParam == AV_ERR_OK) { 1770 backParam = SUCCESS; 1771 } 1772 napi_create_int32(env, backParam, &result); 1773 return result; 1774} 1775 1776static napi_value OHAvCapabilityGetAudioChannelCountRangeNnormal(napi_env env, napi_callback_info info) 1777{ 1778 napi_value result = nullptr; 1779 int backParam = FAIL; 1780 OH_AVCapability *capability = nullptr; 1781 OH_AVRange channelCountRange; 1782 OH_AVErrCode checkParam; 1783 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_AUDIO_MPEG, isEncoder); 1784 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1785 if (checkParam == AV_ERR_OK) { 1786 backParam = SUCCESS; 1787 } 1788 napi_create_int32(env, backParam, &result); 1789 return result; 1790} 1791 1792static napi_value OHAvCapabilityGetAudioChannelCountRangeOnormal(napi_env env, napi_callback_info info) 1793{ 1794 napi_value result = nullptr; 1795 int backParam = FAIL; 1796 OH_AVCapability *capability = nullptr; 1797 OH_AVRange channelCountRange; 1798 OH_AVErrCode checkParam; 1799 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isEncoder); 1800 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1801 if (checkParam == AV_ERR_OK) { 1802 backParam = SUCCESS; 1803 } 1804 napi_create_int32(env, backParam, &result); 1805 return result; 1806} 1807 1808static napi_value OHAvCapabilityGetAudioChannelCountRangePnormal(napi_env env, napi_callback_info info) 1809{ 1810 napi_value result = nullptr; 1811 int backParam = FAIL; 1812 OH_AVCapability *capability = nullptr; 1813 OH_AVRange channelCountRange; 1814 OH_AVErrCode checkParam; 1815 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, isEncoder); 1816 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1817 if (checkParam == AV_ERR_OK) { 1818 backParam = SUCCESS; 1819 } 1820 napi_create_int32(env, backParam, &result); 1821 return result; 1822} 1823 1824static napi_value OHAvCapabilityGetAudioChannelCountRangeQnormal(napi_env env, napi_callback_info info) 1825{ 1826 napi_value result = nullptr; 1827 int backParam = FAIL; 1828 OH_AVCapability *capability = nullptr; 1829 OH_AVRange channelCountRange; 1830 OH_AVErrCode checkParam; 1831 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_IMAGE_JPG, isEncoder); 1832 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1833 if (checkParam == AV_ERR_OK) { 1834 backParam = SUCCESS; 1835 } 1836 napi_create_int32(env, backParam, &result); 1837 return result; 1838} 1839 1840static napi_value OHAvCapabilityGetAudioChannelCountRangeRnormal(napi_env env, napi_callback_info info) 1841{ 1842 napi_value result = nullptr; 1843 int backParam = FAIL; 1844 OH_AVCapability *capability = nullptr; 1845 OH_AVRange channelCountRange; 1846 OH_AVErrCode checkParam; 1847 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_IMAGE_PNG, isEncoder); 1848 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1849 if (checkParam == AV_ERR_OK) { 1850 backParam = SUCCESS; 1851 } 1852 napi_create_int32(env, backParam, &result); 1853 return result; 1854} 1855 1856static napi_value OHAvCapabilityGetAudioChannelCountRangeSnormal(napi_env env, napi_callback_info info) 1857{ 1858 napi_value result = nullptr; 1859 int backParam = FAIL; 1860 OH_AVCapability *capability = nullptr; 1861 OH_AVRange channelCountRange; 1862 OH_AVErrCode checkParam; 1863 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_IMAGE_BMP, isEncoder); 1864 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 1865 if (checkParam == AV_ERR_OK) { 1866 backParam = SUCCESS; 1867 } 1868 napi_create_int32(env, backParam, &result); 1869 return result; 1870} 1871 1872static napi_value OHAvCapabilityGetVideoWidthAlignmentAnormal(napi_env env, napi_callback_info info) 1873{ 1874 napi_value result = nullptr; 1875 int backParam = FAIL; 1876 OH_AVCapability *capability = nullptr; 1877 int32_t widthAlignment; 1878 OH_AVErrCode checkParam; 1879 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, isEncoder, HARDWARE); 1880 checkParam = OH_AVCapability_GetVideoWidthAlignment(capability, &widthAlignment); 1881 if (checkParam == AV_ERR_OK) { 1882 backParam = SUCCESS; 1883 } 1884 napi_create_int32(env, backParam, &result); 1885 return result; 1886} 1887 1888static napi_value OHAvCapabilityGetVideoWidthAlignmentBnormal(napi_env env, napi_callback_info info) 1889{ 1890 napi_value result = nullptr; 1891 int backParam = FAIL; 1892 OH_AVCapability *capability = nullptr; 1893 int32_t widthAlignment; 1894 OH_AVErrCode checkParam; 1895 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isEncoder, HARDWARE); 1896 checkParam = OH_AVCapability_GetVideoWidthAlignment(capability, &widthAlignment); 1897 if (checkParam == AV_ERR_OK) { 1898 backParam = SUCCESS; 1899 } 1900 napi_create_int32(env, backParam, &result); 1901 return result; 1902} 1903 1904static napi_value OHAvCapabilityGetVideoWidthAlignmentCnormal(napi_env env, napi_callback_info info) 1905{ 1906 napi_value result = nullptr; 1907 int backParam = FAIL; 1908 OH_AVCapability *capability = nullptr; 1909 int32_t widthAlignment; 1910 OH_AVErrCode checkParam; 1911 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isDecoder, HARDWARE); 1912 checkParam = OH_AVCapability_GetVideoWidthAlignment(capability, &widthAlignment); 1913 if (checkParam == AV_ERR_OK) { 1914 backParam = SUCCESS; 1915 } 1916 napi_create_int32(env, backParam, &result); 1917 return result; 1918} 1919 1920static napi_value OHAvCapabilityGetVideoWidthAlignmentDnormal(napi_env env, napi_callback_info info) 1921{ 1922 napi_value result = nullptr; 1923 int backParam = FAIL; 1924 OH_AVCapability *capability = nullptr; 1925 int32_t widthAlignment; 1926 OH_AVErrCode checkParam; 1927 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, isDecoder, HARDWARE); 1928 checkParam = OH_AVCapability_GetVideoWidthAlignment(capability, &widthAlignment); 1929 if (checkParam == AV_ERR_OK) { 1930 backParam = SUCCESS; 1931 } 1932 napi_create_int32(env, backParam, &result); 1933 return result; 1934} 1935 1936static napi_value OHAvCapabilityGetVideoWidthAlignmentEnormal(napi_env env, napi_callback_info info) 1937{ 1938 napi_value result = nullptr; 1939 int backParam = FAIL; 1940 OH_AVCapability *capability = nullptr; 1941 int32_t widthAlignment; 1942 OH_AVErrCode checkParam; 1943 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isDecoder, HARDWARE); 1944 checkParam = OH_AVCapability_GetVideoWidthAlignment(capability, &widthAlignment); 1945 if (checkParam == AV_ERR_OK) { 1946 backParam = SUCCESS; 1947 } 1948 napi_create_int32(env, backParam, &result); 1949 return result; 1950} 1951 1952static napi_value OHAvCapabilityGetVideoWidthAlignmentFnormal(napi_env env, napi_callback_info info) 1953{ 1954 napi_value result = nullptr; 1955 int backParam = FAIL; 1956 OH_AVCapability *capability = nullptr; 1957 int32_t widthAlignment; 1958 OH_AVErrCode checkParam; 1959 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isDecoder, SOFTWARE); 1960 checkParam = OH_AVCapability_GetVideoWidthAlignment(capability, &widthAlignment); 1961 if (checkParam == AV_ERR_OK) { 1962 backParam = SUCCESS; 1963 } 1964 napi_create_int32(env, backParam, &result); 1965 return result; 1966} 1967 1968static napi_value OHAvCapabilityGetVideoWidthAlignmentGnormal(napi_env env, napi_callback_info info) 1969{ 1970 napi_value result = nullptr; 1971 int backParam = FAIL; 1972 OH_AVCapability *capability = nullptr; 1973 int32_t widthAlignment; 1974 OH_AVErrCode checkParam; 1975 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, isDecoder, SOFTWARE); 1976 checkParam = OH_AVCapability_GetVideoWidthAlignment(capability, &widthAlignment); 1977 if (checkParam == AV_ERR_OK) { 1978 backParam = SUCCESS; 1979 } 1980 napi_create_int32(env, backParam, &result); 1981 return result; 1982} 1983 1984static napi_value OHAvCapabilityGetVideoWidthAlignmentHnormal(napi_env env, napi_callback_info info) 1985{ 1986 napi_value result = nullptr; 1987 int backParam = FAIL; 1988 OH_AVCapability *capability = nullptr; 1989 int32_t widthAlignment; 1990 OH_AVErrCode checkParam; 1991 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isDecoder, SOFTWARE); 1992 checkParam = OH_AVCapability_GetVideoWidthAlignment(capability, &widthAlignment); 1993 if (checkParam == AV_ERR_OK) { 1994 backParam = SUCCESS; 1995 } 1996 napi_create_int32(env, backParam, &result); 1997 return result; 1998} 1999 2000static napi_value OHAvCapabilityGetVideoWidthAlignmentInormal(napi_env env, napi_callback_info info) 2001{ 2002 napi_value result = nullptr; 2003 int backParam = FAIL; 2004 OH_AVCapability *capability = nullptr; 2005 int32_t widthAlignment; 2006 OH_AVErrCode checkParam; 2007 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder, SOFTWARE); 2008 checkParam = OH_AVCapability_GetVideoWidthAlignment(capability, &widthAlignment); 2009 if (checkParam == AV_ERR_OK) { 2010 backParam = SUCCESS; 2011 } 2012 napi_create_int32(env, backParam, &result); 2013 return result; 2014} 2015 2016static napi_value OHAvCapabilityGetVideoWidthAlignmentJnormal(napi_env env, napi_callback_info info) 2017{ 2018 napi_value result = nullptr; 2019 int backParam = FAIL; 2020 OH_AVCapability *capability = nullptr; 2021 int32_t widthAlignment; 2022 OH_AVErrCode checkParam; 2023 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, isEncoder, SOFTWARE); 2024 checkParam = OH_AVCapability_GetVideoWidthAlignment(capability, &widthAlignment); 2025 if (checkParam == AV_ERR_OK) { 2026 backParam = SUCCESS; 2027 } 2028 napi_create_int32(env, backParam, &result); 2029 return result; 2030} 2031 2032static napi_value OHAvCapabilityGetVideoWidthAlignmentKnormal(napi_env env, napi_callback_info info) 2033{ 2034 napi_value result = nullptr; 2035 int backParam = FAIL; 2036 OH_AVCapability *capability = nullptr; 2037 int32_t widthAlignment; 2038 OH_AVErrCode checkParam; 2039 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isEncoder, SOFTWARE); 2040 checkParam = OH_AVCapability_GetVideoWidthAlignment(capability, &widthAlignment); 2041 if (checkParam == AV_ERR_OK) { 2042 backParam = SUCCESS; 2043 } 2044 napi_create_int32(env, backParam, &result); 2045 return result; 2046} 2047 2048static napi_value OHAvCapabilityGetVideoWidthAlignmentLnormal(napi_env env, napi_callback_info info) 2049{ 2050 napi_value result = nullptr; 2051 int backParam = FAIL; 2052 OH_AVCapability *capability = nullptr; 2053 int32_t widthAlignment; 2054 OH_AVErrCode checkParam; 2055 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, isEncoder, SOFTWARE); 2056 checkParam = OH_AVCapability_GetVideoWidthAlignment(capability, &widthAlignment); 2057 if (checkParam == AV_ERR_INVALID_VAL) { 2058 backParam = SUCCESS; 2059 } 2060 napi_create_int32(env, backParam, &result); 2061 return result; 2062} 2063 2064static napi_value OHAvCapabilityGetVideoWidthAlignmentMnormal(napi_env env, napi_callback_info info) 2065{ 2066 napi_value result = nullptr; 2067 int backParam = FAIL; 2068 OH_AVCapability *capability = nullptr; 2069 OH_AVErrCode checkParam; 2070 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isEncoder, SOFTWARE); 2071 checkParam = OH_AVCapability_GetVideoWidthAlignment(capability, nullptr); 2072 if (checkParam == AV_ERR_INVALID_VAL) { 2073 backParam = SUCCESS; 2074 } 2075 napi_create_int32(env, backParam, &result); 2076 return result; 2077} 2078 2079static napi_value oHAvCapabilityGetVideoHeightAlignmentAnormal(napi_env env, napi_callback_info info) 2080{ 2081 napi_value result = nullptr; 2082 int backParam = FAIL; 2083 OH_AVCapability *capability = nullptr; 2084 int32_t heightAlignment; 2085 OH_AVErrCode checkParam; 2086 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, isEncoder, HARDWARE); 2087 checkParam = OH_AVCapability_GetVideoHeightAlignment(capability, &heightAlignment); 2088 if (checkParam == AV_ERR_OK) { 2089 backParam = SUCCESS; 2090 } 2091 napi_create_int32(env, backParam, &result); 2092 return result; 2093} 2094 2095static napi_value oHAvCapabilityGetVideoHeightAlignmentBnormal(napi_env env, napi_callback_info info) 2096{ 2097 napi_value result = nullptr; 2098 int backParam = FAIL; 2099 OH_AVCapability *capability = nullptr; 2100 int32_t heightAlignment; 2101 OH_AVErrCode checkParam; 2102 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isEncoder, HARDWARE); 2103 checkParam = OH_AVCapability_GetVideoHeightAlignment(capability, &heightAlignment); 2104 if (checkParam == AV_ERR_OK) { 2105 backParam = SUCCESS; 2106 } 2107 napi_create_int32(env, backParam, &result); 2108 return result; 2109} 2110 2111static napi_value oHAvCapabilityGetVideoHeightAlignmentCnormal(napi_env env, napi_callback_info info) 2112{ 2113 napi_value result = nullptr; 2114 int backParam = FAIL; 2115 OH_AVCapability *capability = nullptr; 2116 int32_t heightAlignment; 2117 OH_AVErrCode checkParam; 2118 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isDecoder, HARDWARE); 2119 checkParam = OH_AVCapability_GetVideoHeightAlignment(capability, &heightAlignment); 2120 if (checkParam == AV_ERR_OK) { 2121 backParam = SUCCESS; 2122 } 2123 napi_create_int32(env, backParam, &result); 2124 return result; 2125} 2126 2127static napi_value oHAvCapabilityGetVideoHeightAlignmentDnormal(napi_env env, napi_callback_info info) 2128{ 2129 napi_value result = nullptr; 2130 int backParam = FAIL; 2131 OH_AVCapability *capability = nullptr; 2132 int32_t heightAlignment; 2133 OH_AVErrCode checkParam; 2134 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, isDecoder, HARDWARE); 2135 checkParam = OH_AVCapability_GetVideoHeightAlignment(capability, &heightAlignment); 2136 if (checkParam == AV_ERR_OK) { 2137 backParam = SUCCESS; 2138 } 2139 napi_create_int32(env, backParam, &result); 2140 return result; 2141} 2142 2143static napi_value oHAvCapabilityGetVideoHeightAlignmentEnormal(napi_env env, napi_callback_info info) 2144{ 2145 napi_value result = nullptr; 2146 int backParam = FAIL; 2147 OH_AVCapability *capability = nullptr; 2148 int32_t heightAlignment; 2149 OH_AVErrCode checkParam; 2150 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isDecoder, HARDWARE); 2151 checkParam = OH_AVCapability_GetVideoHeightAlignment(capability, &heightAlignment); 2152 if (checkParam == AV_ERR_OK) { 2153 backParam = SUCCESS; 2154 } 2155 napi_create_int32(env, backParam, &result); 2156 return result; 2157} 2158 2159static napi_value oHAvCapabilityGetVideoHeightAlignmentFnormal(napi_env env, napi_callback_info info) 2160{ 2161 napi_value result = nullptr; 2162 int backParam = FAIL; 2163 OH_AVCapability *capability = nullptr; 2164 int32_t heightAlignment; 2165 OH_AVErrCode checkParam; 2166 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isDecoder, SOFTWARE); 2167 checkParam = OH_AVCapability_GetVideoHeightAlignment(capability, &heightAlignment); 2168 if (checkParam == AV_ERR_OK) { 2169 backParam = SUCCESS; 2170 } 2171 napi_create_int32(env, backParam, &result); 2172 return result; 2173} 2174 2175static napi_value oHAvCapabilityGetVideoHeightAlignmentGnormal(napi_env env, napi_callback_info info) 2176{ 2177 napi_value result = nullptr; 2178 int backParam = FAIL; 2179 OH_AVCapability *capability = nullptr; 2180 int32_t heightAlignment; 2181 OH_AVErrCode checkParam; 2182 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, isDecoder, SOFTWARE); 2183 checkParam = OH_AVCapability_GetVideoHeightAlignment(capability, &heightAlignment); 2184 if (checkParam == AV_ERR_OK) { 2185 backParam = SUCCESS; 2186 } 2187 napi_create_int32(env, backParam, &result); 2188 return result; 2189} 2190 2191static napi_value oHAvCapabilityGetVideoHeightAlignmentHnormal(napi_env env, napi_callback_info info) 2192{ 2193 napi_value result = nullptr; 2194 int backParam = FAIL; 2195 OH_AVCapability *capability = nullptr; 2196 int32_t heightAlignment; 2197 OH_AVErrCode checkParam; 2198 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isDecoder, SOFTWARE); 2199 checkParam = OH_AVCapability_GetVideoHeightAlignment(capability, &heightAlignment); 2200 if (checkParam == AV_ERR_OK) { 2201 backParam = SUCCESS; 2202 } 2203 napi_create_int32(env, backParam, &result); 2204 return result; 2205} 2206 2207static napi_value oHAvCapabilityGetVideoHeightAlignmentInormal(napi_env env, napi_callback_info info) 2208{ 2209 napi_value result = nullptr; 2210 int backParam = FAIL; 2211 OH_AVCapability *capability = nullptr; 2212 int32_t heightAlignment; 2213 OH_AVErrCode checkParam; 2214 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4, isEncoder, SOFTWARE); 2215 checkParam = OH_AVCapability_GetVideoHeightAlignment(capability, &heightAlignment); 2216 if (checkParam == AV_ERR_OK) { 2217 backParam = SUCCESS; 2218 } 2219 napi_create_int32(env, backParam, &result); 2220 return result; 2221} 2222 2223static napi_value oHAvCapabilityGetVideoHeightAlignmentJnormal(napi_env env, napi_callback_info info) 2224{ 2225 napi_value result = nullptr; 2226 int backParam = FAIL; 2227 OH_AVCapability *capability = nullptr; 2228 int32_t heightAlignment; 2229 OH_AVErrCode checkParam; 2230 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isEncoder, SOFTWARE); 2231 checkParam = OH_AVCapability_GetVideoHeightAlignment(capability, &heightAlignment); 2232 if (checkParam == AV_ERR_OK) { 2233 backParam = SUCCESS; 2234 } 2235 napi_create_int32(env, backParam, &result); 2236 return result; 2237} 2238 2239static napi_value oHAvCapabilityGetVideoHeightAlignmentKnormal(napi_env env, napi_callback_info info) 2240{ 2241 napi_value result = nullptr; 2242 int backParam = FAIL; 2243 OH_AVCapability *capability = nullptr; 2244 int32_t heightAlignment; 2245 OH_AVErrCode checkParam; 2246 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder, SOFTWARE); 2247 checkParam = OH_AVCapability_GetVideoHeightAlignment(capability, &heightAlignment); 2248 if (checkParam == AV_ERR_OK) { 2249 backParam = SUCCESS; 2250 } 2251 napi_create_int32(env, backParam, &result); 2252 return result; 2253} 2254 2255static napi_value oHAvCapabilityGetVideoHeightAlignmentLnormal(napi_env env, napi_callback_info info) 2256{ 2257 napi_value result = nullptr; 2258 int backParam = FAIL; 2259 OH_AVCapability *capability = nullptr; 2260 int32_t heightAlignment; 2261 OH_AVErrCode checkParam; 2262 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, isEncoder, HARDWARE); 2263 checkParam = OH_AVCapability_GetVideoHeightAlignment(capability, &heightAlignment); 2264 if (checkParam == AV_ERR_INVALID_VAL) { 2265 backParam = SUCCESS; 2266 } 2267 napi_create_int32(env, backParam, &result); 2268 return result; 2269} 2270 2271static napi_value oHAvCapabilityGetVideoHeightAlignmentMnormal(napi_env env, napi_callback_info info) 2272{ 2273 napi_value result = nullptr; 2274 int backParam = FAIL; 2275 OH_AVCapability *capability = nullptr; 2276 OH_AVErrCode checkParam; 2277 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder, HARDWARE); 2278 checkParam = OH_AVCapability_GetVideoHeightAlignment(capability, nullptr); 2279 if (checkParam == AV_ERR_INVALID_VAL) { 2280 backParam = SUCCESS; 2281 } 2282 napi_create_int32(env, backParam, &result); 2283 return result; 2284} 2285 2286static napi_value AVCapabilityGetEncoderQualityRange(napi_env env, napi_callback_info info) 2287{ 2288 napi_value result = nullptr; 2289 int backParam = FAIL; 2290 OH_AVCapability *capability = nullptr; 2291 OH_AVRange qualityRange; 2292 OH_AVErrCode checkParam; 2293 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder, HARDWARE); 2294 checkParam = OH_AVCapability_GetEncoderQualityRange(capability, &qualityRange); 2295 if (checkParam == AV_ERR_OK) { 2296 backParam = SUCCESS; 2297 } 2298 napi_create_int32(env, backParam, &result); 2299 return result; 2300} 2301 2302static napi_value AVCapabilityGetEncoderComplexityRange(napi_env env, napi_callback_info info) 2303{ 2304 napi_value result = nullptr; 2305 int backParam = FAIL; 2306 OH_AVCapability *capability = nullptr; 2307 OH_AVRange complexityRange; 2308 OH_AVErrCode checkParam; 2309 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder, HARDWARE); 2310 checkParam = OH_AVCapability_GetEncoderComplexityRange(capability, &complexityRange); 2311 if (checkParam == AV_ERR_OK) { 2312 backParam = SUCCESS; 2313 } 2314 napi_create_int32(env, backParam, &result); 2315 return result; 2316} 2317 2318static napi_value AVCapabilityGetAudioSupportedSampleRates(napi_env env, napi_callback_info info) 2319{ 2320 napi_value result = nullptr; 2321 int backParam = FAIL; 2322 OH_AVCapability *capability = nullptr; 2323 const int32_t *sampleRates = nullptr; 2324 uint32_t sampleRateNum; 2325 OH_AVErrCode checkParam; 2326 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, isEncoder, SOFTWARE); 2327 checkParam = OH_AVCapability_GetAudioSupportedSampleRates(capability, &sampleRates, &sampleRateNum); 2328 if (checkParam == AV_ERR_OK) { 2329 backParam = SUCCESS; 2330 } 2331 napi_create_int32(env, backParam, &result); 2332 return result; 2333} 2334 2335static napi_value AVCapabilityGetAudioChannelCountRange(napi_env env, napi_callback_info info) 2336{ 2337 napi_value result = nullptr; 2338 int backParam = FAIL; 2339 OH_AVCapability *capability = nullptr; 2340 OH_AVRange channelCountRange; 2341 OH_AVErrCode checkParam; 2342 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, isDecoder); 2343 checkParam = OH_AVCapability_GetAudioChannelCountRange(capability, &channelCountRange); 2344 if (checkParam == AV_ERR_OK) { 2345 backParam = SUCCESS; 2346 } 2347 napi_create_int32(env, backParam, &result); 2348 return result; 2349} 2350 2351static napi_value AVCapabilityGetVideoWidthAlignment(napi_env env, napi_callback_info info) 2352{ 2353 napi_value result = nullptr; 2354 int backParam = FAIL; 2355 OH_AVCapability *capability = nullptr; 2356 int32_t widthAlignment; 2357 OH_AVErrCode checkParam; 2358 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder, HARDWARE); 2359 checkParam = OH_AVCapability_GetVideoWidthAlignment(capability, &widthAlignment); 2360 if (checkParam == AV_ERR_OK) { 2361 backParam = SUCCESS; 2362 } 2363 napi_create_int32(env, backParam, &result); 2364 return result; 2365} 2366 2367static napi_value AVCapabilityGetVideoHeightAlignment(napi_env env, napi_callback_info info) 2368{ 2369 napi_value result = nullptr; 2370 int backParam = FAIL; 2371 OH_AVCapability *capability = nullptr; 2372 int32_t heightAlignment; 2373 OH_AVErrCode checkParam; 2374 capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder, HARDWARE); 2375 checkParam = OH_AVCapability_GetVideoHeightAlignment(capability, &heightAlignment); 2376 if (checkParam == AV_ERR_OK) { 2377 backParam = SUCCESS; 2378 } 2379 napi_create_int32(env, backParam, &result); 2380 return result; 2381} 2382 2383static napi_value AVCodecGetCapability(napi_env env, napi_callback_info info) 2384{ 2385 napi_value result = nullptr; 2386 int backParam = FAIL; 2387 OH_AVCapability *checkParam = nullptr; 2388 checkParam = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isDecoder); 2389 if (checkParam != nullptr) { 2390 backParam = SUCCESS; 2391 } 2392 napi_create_int32(env, backParam, &result); 2393 return result; 2394} 2395 2396static napi_value AVCodecGetCapabilityByCategory(napi_env env, napi_callback_info info) 2397{ 2398 napi_value result = nullptr; 2399 int backParam = FAIL; 2400 OH_AVCapability *checkParam = nullptr; 2401 checkParam = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, isDecoder, HARDWARE); 2402 if (checkParam != nullptr) { 2403 backParam = SUCCESS; 2404 } 2405 napi_create_int32(env, backParam, &result); 2406 return result; 2407} 2408 2409static napi_value AVCapabilityGetVideoWidthRange(napi_env env, napi_callback_info info) 2410{ 2411 napi_value result = nullptr; 2412 int backParam = FAIL; 2413 OH_AVCapability *capability = nullptr; 2414 OH_AVRange widthRange; 2415 OH_AVErrCode checkParam; 2416 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder); 2417 checkParam = OH_AVCapability_GetVideoWidthRange(capability, &widthRange); 2418 if (checkParam == AV_ERR_OK) { 2419 backParam = SUCCESS; 2420 } 2421 napi_create_int32(env, backParam, &result); 2422 return result; 2423} 2424 2425static napi_value AVCapabilityGetVideoHeightRange(napi_env env, napi_callback_info info) 2426{ 2427 napi_value result = nullptr; 2428 int backParam = FAIL; 2429 OH_AVCapability *capability = nullptr; 2430 OH_AVRange heightRange; 2431 OH_AVErrCode checkParam; 2432 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder); 2433 checkParam = OH_AVCapability_GetVideoHeightRange(capability, &heightRange); 2434 if (checkParam == AV_ERR_OK) { 2435 backParam = SUCCESS; 2436 } 2437 napi_create_int32(env, backParam, &result); 2438 return result; 2439} 2440 2441static napi_value AVCapabilityIsVideoSizeSupported(napi_env env, napi_callback_info info) 2442{ 2443 napi_value result = nullptr; 2444 int backParam = FAIL; 2445 OH_AVCapability *capability = nullptr; 2446 int32_t width = PARAM_1280, height = PARAM_720; 2447 bool checkParam = false; 2448 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder); 2449 checkParam = OH_AVCapability_IsVideoSizeSupported(capability, width, height); 2450 if (checkParam != false) { 2451 backParam = SUCCESS; 2452 } 2453 napi_create_int32(env, backParam, &result); 2454 return result; 2455} 2456 2457static napi_value AVCapabilityGetVideoFrameRateRange(napi_env env, napi_callback_info info) 2458{ 2459 napi_value result = nullptr; 2460 int backParam = FAIL; 2461 OH_AVCapability *capability = nullptr; 2462 OH_AVRange frameRateRange; 2463 OH_AVErrCode checkParam; 2464 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder); 2465 checkParam = OH_AVCapability_GetVideoFrameRateRange(capability, &frameRateRange); 2466 if (checkParam == AV_ERR_OK) { 2467 backParam = SUCCESS; 2468 } 2469 napi_create_int32(env, backParam, &result); 2470 return result; 2471} 2472 2473static napi_value AVCapabilityGetVideoFrameRateRangeForSize(napi_env env, napi_callback_info info) 2474{ 2475 napi_value result = nullptr; 2476 int backParam = FAIL; 2477 OH_AVCapability *capability = nullptr; 2478 int32_t width = WIDTH, height = HEIGHT; 2479 OH_AVRange frameRateRange; 2480 OH_AVErrCode checkParam; 2481 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder); 2482 checkParam = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, width, height, &frameRateRange); 2483 if (checkParam == AV_ERR_OK) { 2484 backParam = SUCCESS; 2485 } 2486 napi_create_int32(env, backParam, &result); 2487 return result; 2488} 2489 2490static napi_value AVCapabilityAreVideoSizeAndFrameRateSupported(napi_env env, napi_callback_info info) 2491{ 2492 napi_value result = nullptr; 2493 int backParam = FAIL; 2494 OH_AVCapability *capability = nullptr; 2495 int32_t width = HEIGHT, height = PARAM_720, frameRate = PARAM_30; 2496 bool checkParam = false; 2497 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isDecoder); 2498 checkParam = OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, width, height, frameRate); 2499 if (checkParam != false) { 2500 backParam = SUCCESS; 2501 } 2502 napi_create_int32(env, backParam, &result); 2503 return result; 2504} 2505 2506static napi_value AVCapabilityGetVideoSupportedPixelFormats(napi_env env, napi_callback_info info) 2507{ 2508 napi_value result = nullptr; 2509 int backParam = FAIL; 2510 OH_AVCapability *capability = nullptr; 2511 const int32_t *pixFormats = nullptr; 2512 uint32_t pixFormatNum; 2513 OH_AVErrCode checkParam; 2514 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder); 2515 checkParam = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixFormats, &pixFormatNum); 2516 if (checkParam == AV_ERR_OK) { 2517 backParam = SUCCESS; 2518 } 2519 napi_create_int32(env, backParam, &result); 2520 return result; 2521} 2522 2523static napi_value AVCapabilityGetSupportedProfiles(napi_env env, napi_callback_info info) 2524{ 2525 napi_value result = nullptr; 2526 int backParam = FAIL; 2527 OH_AVCapability *capability = nullptr; 2528 const int32_t *profiles = nullptr; 2529 uint32_t profileNum; 2530 OH_AVErrCode checkParam; 2531 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder); 2532 checkParam = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum); 2533 if (checkParam == AV_ERR_OK) { 2534 backParam = SUCCESS; 2535 } 2536 napi_create_int32(env, backParam, &result); 2537 return result; 2538} 2539 2540static napi_value AVCapabilityGetSupportedLevelsForProfile(napi_env env, napi_callback_info info) 2541{ 2542 napi_value result = nullptr; 2543 int backParam = FAIL; 2544 OH_AVCapability *capability = nullptr; 2545 const int32_t *levels = nullptr; 2546 uint32_t levelNum; 2547 OH_AVErrCode checkParam; 2548 capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_AVC, isEncoder); 2549 checkParam = OH_AVCapability_GetSupportedLevelsForProfile(capability, PARAM_0, &levels, &levelNum); 2550 if (checkParam == AV_ERR_OK) { 2551 backParam = SUCCESS; 2552 } 2553 napi_create_int32(env, backParam, &result); 2554 return result; 2555} 2556 2557EXTERN_C_START 2558static napi_value Init(napi_env env, napi_value exports) 2559{ 2560 napi_property_descriptor desc[] = { 2561 {"oHAvCapabilityGetEncoderQualityRangeAnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeAnormal, nullptr, 2562 nullptr, nullptr, napi_default, nullptr}, 2563 {"oHAvCapabilityGetEncoderQualityRangeBnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeBnormal, nullptr, 2564 nullptr, nullptr, napi_default, nullptr}, 2565 {"oHAvCapabilityGetEncoderQualityRangeCnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeCnormal, nullptr, 2566 nullptr, nullptr, napi_default, nullptr}, 2567 {"oHAvCapabilityGetEncoderQualityRangeDnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeDnormal, nullptr, 2568 nullptr, nullptr, napi_default, nullptr}, 2569 {"oHAvCapabilityGetEncoderQualityRangeEnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeEnormal, nullptr, 2570 nullptr, nullptr, napi_default, nullptr}, 2571 {"oHAvCapabilityGetEncoderQualityRangeFnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeFnormal, nullptr, 2572 nullptr, nullptr, napi_default, nullptr}, 2573 {"oHAvCapabilityGetEncoderQualityRangeGnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeGnormal, nullptr, 2574 nullptr, nullptr, napi_default, nullptr}, 2575 {"oHAvCapabilityGetEncoderQualityRangeHnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeHnormal, nullptr, 2576 nullptr, nullptr, napi_default, nullptr}, 2577 {"oHAvCapabilityGetEncoderQualityRangeInormal", nullptr, OHAvCapabilityGetEncoderQualityRangeInormal, nullptr, 2578 nullptr, nullptr, napi_default, nullptr}, 2579 2580 {"oHAvCapabilityGetEncoderQualityRangeJnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeJnormal, nullptr, 2581 nullptr, nullptr, napi_default, nullptr}, 2582 {"oHAvCapabilityGetEncoderQualityRangeKnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeKnormal, nullptr, 2583 nullptr, nullptr, napi_default, nullptr}, 2584 {"oHAvCapabilityGetEncoderQualityRangeLnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeLnormal, nullptr, 2585 nullptr, nullptr, napi_default, nullptr}, 2586 {"oHAvCapabilityGetEncoderQualityRangeMnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeMnormal, nullptr, 2587 nullptr, nullptr, napi_default, nullptr}, 2588 {"oHAvCapabilityGetEncoderQualityRangeNnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeNnormal, nullptr, 2589 nullptr, nullptr, napi_default, nullptr}, 2590 {"oHAvCapabilityGetEncoderQualityRangeOnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeOnormal, nullptr, 2591 nullptr, nullptr, napi_default, nullptr}, 2592 {"oHAvCapabilityGetEncoderQualityRangePnormal", nullptr, OHAvCapabilityGetEncoderQualityRangePnormal, nullptr, 2593 nullptr, nullptr, napi_default, nullptr}, 2594 {"oHAvCapabilityGetEncoderQualityRangeQnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeQnormal, nullptr, 2595 nullptr, nullptr, napi_default, nullptr}, 2596 {"oHAvCapabilityGetEncoderQualityRangeRnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeRnormal, nullptr, 2597 nullptr, nullptr, napi_default, nullptr}, 2598 {"oHAvCapabilityGetEncoderQualityRangeSnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeSnormal, nullptr, 2599 nullptr, nullptr, napi_default, nullptr}, 2600 2601 {"oHAvCapabilityGetEncoderQualityRangeTnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeTnormal, nullptr, 2602 nullptr, nullptr, napi_default, nullptr}, 2603 {"oHAvCapabilityGetEncoderQualityRangeUnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeUnormal, nullptr, 2604 nullptr, nullptr, napi_default, nullptr}, 2605 {"oHAvCapabilityGetEncoderQualityRangeVnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeVnormal, nullptr, 2606 nullptr, nullptr, napi_default, nullptr}, 2607 {"oHAvCapabilityGetEncoderQualityRangeWnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeWnormal, nullptr, 2608 nullptr, nullptr, napi_default, nullptr}, 2609 {"oHAvCapabilityGetEncoderQualityRangeXnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeXnormal, nullptr, 2610 nullptr, nullptr, napi_default, nullptr}, 2611 {"oHAvCapabilityGetEncoderQualityRangeYnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeYnormal, nullptr, 2612 nullptr, nullptr, napi_default, nullptr}, 2613 {"oHAvCapabilityGetEncoderQualityRangeZnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeZnormal, nullptr, 2614 nullptr, nullptr, napi_default, nullptr}, 2615 {"oHAvCapabilityGetEncoderQualityRangeAAnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeAAnormal, nullptr, 2616 nullptr, nullptr, napi_default, nullptr}, 2617 {"oHAvCapabilityGetEncoderQualityRangeABnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeABnormal, nullptr, 2618 nullptr, nullptr, napi_default, nullptr}, 2619 {"oHAvCapabilityGetEncoderQualityRangeACnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeACnormal, nullptr, 2620 nullptr, nullptr, napi_default, nullptr}, 2621 2622 {"oHAvCapabilityGetEncoderQualityRangeADnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeADnormal, nullptr, 2623 nullptr, nullptr, napi_default, nullptr}, 2624 {"oHAvCapabilityGetEncoderQualityRangeAEnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeAEnormal, nullptr, 2625 nullptr, nullptr, napi_default, nullptr}, 2626 {"oHAvCapabilityGetEncoderQualityRangeAFnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeAFnormal, nullptr, 2627 nullptr, nullptr, napi_default, nullptr}, 2628 {"oHAvCapabilityGetEncoderQualityRangeAGnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeAGnormal, nullptr, 2629 nullptr, nullptr, napi_default, nullptr}, 2630 {"oHAvCapabilityGetEncoderQualityRangeAHnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeAHnormal, nullptr, 2631 nullptr, nullptr, napi_default, nullptr}, 2632 {"oHAvCapabilityGetEncoderQualityRangeAInormal", nullptr, OHAvCapabilityGetEncoderQualityRangeAInormal, nullptr, 2633 nullptr, nullptr, napi_default, nullptr}, 2634 {"oHAvCapabilityGetEncoderQualityRangeAJnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeAJnormal, nullptr, 2635 nullptr, nullptr, napi_default, nullptr}, 2636 {"oHAvCapabilityGetEncoderQualityRangeAKnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeAKnormal, nullptr, 2637 nullptr, nullptr, napi_default, nullptr}, 2638 {"oHAvCapabilityGetEncoderQualityRangeALnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeALnormal, nullptr, 2639 nullptr, nullptr, napi_default, nullptr}, 2640 {"oHAvCapabilityGetEncoderQualityRangeAMnormal", nullptr, OHAvCapabilityGetEncoderQualityRangeAMnormal, nullptr, 2641 nullptr, nullptr, napi_default, nullptr}, 2642 2643 {"oHAvCapabilityGetEncoderComplexityRangeAnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeAnormal, 2644 nullptr, nullptr, nullptr, napi_default, nullptr}, 2645 {"oHAvCapabilityGetEncoderComplexityRangeBnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeBnormal, 2646 nullptr, nullptr, nullptr, napi_default, nullptr}, 2647 {"oHAvCapabilityGetEncoderComplexityRangeCnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeCnormal, 2648 nullptr, nullptr, nullptr, napi_default, nullptr}, 2649 {"oHAvCapabilityGetEncoderComplexityRangeDnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeDnormal, 2650 nullptr, nullptr, nullptr, napi_default, nullptr}, 2651 {"oHAvCapabilityGetEncoderComplexityRangeEnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeEnormal, 2652 nullptr, nullptr, nullptr, napi_default, nullptr}, 2653 {"oHAvCapabilityGetEncoderComplexityRangeFnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeFnormal, 2654 nullptr, nullptr, nullptr, napi_default, nullptr}, 2655 {"oHAvCapabilityGetEncoderComplexityRangeGnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeGnormal, 2656 nullptr, nullptr, nullptr, napi_default, nullptr}, 2657 {"oHAvCapabilityGetEncoderComplexityRangeHnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeHnormal, 2658 nullptr, nullptr, nullptr, napi_default, nullptr}, 2659 {"oHAvCapabilityGetEncoderComplexityRangeInormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeInormal, 2660 nullptr, nullptr, nullptr, napi_default, nullptr}, 2661 2662 {"oHAvCapabilityGetEncoderComplexityRangeJnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeJnormal, 2663 nullptr, nullptr, nullptr, napi_default, nullptr}, 2664 {"oHAvCapabilityGetEncoderComplexityRangeKnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeKnormal, 2665 nullptr, nullptr, nullptr, napi_default, nullptr}, 2666 {"oHAvCapabilityGetEncoderComplexityRangeLnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeLnormal, 2667 nullptr, nullptr, nullptr, napi_default, nullptr}, 2668 {"oHAvCapabilityGetEncoderComplexityRangeMnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeMnormal, 2669 nullptr, nullptr, nullptr, napi_default, nullptr}, 2670 {"oHAvCapabilityGetEncoderComplexityRangeNnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeNnormal, 2671 nullptr, nullptr, nullptr, napi_default, nullptr}, 2672 {"oHAvCapabilityGetEncoderComplexityRangeOnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeOnormal, 2673 nullptr, nullptr, nullptr, napi_default, nullptr}, 2674 {"oHAvCapabilityGetEncoderComplexityRangePnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangePnormal, 2675 nullptr, nullptr, nullptr, napi_default, nullptr}, 2676 {"oHAvCapabilityGetEncoderComplexityRangeQnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeQnormal, 2677 nullptr, nullptr, nullptr, napi_default, nullptr}, 2678 {"oHAvCapabilityGetEncoderComplexityRangeRnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeRnormal, 2679 nullptr, nullptr, nullptr, napi_default, nullptr}, 2680 {"oHAvCapabilityGetEncoderComplexityRangeSnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeSnormal, 2681 nullptr, nullptr, nullptr, napi_default, nullptr}, 2682 2683 {"oHAvCapabilityGetEncoderComplexityRangeTnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeTnormal, 2684 nullptr, nullptr, nullptr, napi_default, nullptr}, 2685 {"oHAvCapabilityGetEncoderComplexityRangeUnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeUnormal, 2686 nullptr, nullptr, nullptr, napi_default, nullptr}, 2687 {"oHAvCapabilityGetEncoderComplexityRangeVnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeVnormal, 2688 nullptr, nullptr, nullptr, napi_default, nullptr}, 2689 {"oHAvCapabilityGetEncoderComplexityRangeWnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeWnormal, 2690 nullptr, nullptr, nullptr, napi_default, nullptr}, 2691 {"oHAvCapabilityGetEncoderComplexityRangeXnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeXnormal, 2692 nullptr, nullptr, nullptr, napi_default, nullptr}, 2693 {"oHAvCapabilityGetEncoderComplexityRangeYnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeYnormal, 2694 nullptr, nullptr, nullptr, napi_default, nullptr}, 2695 {"oHAvCapabilityGetEncoderComplexityRangeZnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeZnormal, 2696 nullptr, nullptr, nullptr, napi_default, nullptr}, 2697 {"oHAvCapabilityGetEncoderComplexityRangeAAnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeAAnormal, 2698 nullptr, nullptr, nullptr, napi_default, nullptr}, 2699 {"oHAvCapabilityGetEncoderComplexityRangeABnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeABnormal, 2700 nullptr, nullptr, nullptr, napi_default, nullptr}, 2701 {"oHAvCapabilityGetEncoderComplexityRangeACnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeACnormal, 2702 nullptr, nullptr, nullptr, napi_default, nullptr}, 2703 2704 {"oHAvCapabilityGetEncoderComplexityRangeADnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeADnormal, 2705 nullptr, nullptr, nullptr, napi_default, nullptr}, 2706 {"oHAvCapabilityGetEncoderComplexityRangeAEnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeAEnormal, 2707 nullptr, nullptr, nullptr, napi_default, nullptr}, 2708 {"oHAvCapabilityGetEncoderComplexityRangeAFnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeAFnormal, 2709 nullptr, nullptr, nullptr, napi_default, nullptr}, 2710 {"oHAvCapabilityGetEncoderComplexityRangeAGnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeAGnormal, 2711 nullptr, nullptr, nullptr, napi_default, nullptr}, 2712 {"oHAvCapabilityGetEncoderComplexityRangeAHnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeAHnormal, 2713 nullptr, nullptr, nullptr, napi_default, nullptr}, 2714 {"oHAvCapabilityGetEncoderComplexityRangeAInormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeAInormal, 2715 nullptr, nullptr, nullptr, napi_default, nullptr}, 2716 {"oHAvCapabilityGetEncoderComplexityRangeAJnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeAJnormal, 2717 nullptr, nullptr, nullptr, napi_default, nullptr}, 2718 {"oHAvCapabilityGetEncoderComplexityRangeAKnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeAKnormal, 2719 nullptr, nullptr, nullptr, napi_default, nullptr}, 2720 {"oHAvCapabilityGetEncoderComplexityRangeALnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeALnormal, 2721 nullptr, nullptr, nullptr, napi_default, nullptr}, 2722 {"oHAvCapabilityGetEncoderComplexityRangeAMnormal", nullptr, OHAvCapabilityGetEncoderComplexityRangeAMnormal, 2723 nullptr, nullptr, nullptr, napi_default, nullptr}, 2724 2725 {"oHAvCapabilityGetAudioSupportedSampleRatesAbnormal", nullptr, 2726 OHAvCapabilityGetAudioSupportedSampleRatesAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 2727 {"oHAvCapabilityGetAudioSupportedSampleRatesAnormal", nullptr, 2728 OHAvCapabilityGetAudioSupportedSampleRatesAnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 2729 {"oHAvCapabilityGetAudioSupportedSampleRatesBnormal", nullptr, 2730 OHAvCapabilityGetAudioSupportedSampleRatesBnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 2731 {"oHAvCapabilityGetAudioSupportedSampleRatesCnormal", nullptr, 2732 OHAvCapabilityGetAudioSupportedSampleRatesCnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 2733 {"oHAvCapabilityGetAudioSupportedSampleRatesDnormal", nullptr, 2734 OHAvCapabilityGetAudioSupportedSampleRatesDnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 2735 {"oHAvCapabilityGetAudioSupportedSampleRatesEnormal", nullptr, 2736 OHAvCapabilityGetAudioSupportedSampleRatesEnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 2737 {"oHAvCapabilityGetAudioSupportedSampleRatesFnormal", nullptr, 2738 OHAvCapabilityGetAudioSupportedSampleRatesFnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 2739 {"oHAvCapabilityGetAudioSupportedSampleRatesGnormal", nullptr, 2740 OHAvCapabilityGetAudioSupportedSampleRatesGnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 2741 {"oHAvCapabilityGetAudioSupportedSampleRatesHnormal", nullptr, 2742 OHAvCapabilityGetAudioSupportedSampleRatesHnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 2743 {"oHAvCapabilityGetAudioSupportedSampleRatesInormal", nullptr, 2744 OHAvCapabilityGetAudioSupportedSampleRatesInormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 2745 {"oHAvCapabilityGetAudioSupportedSampleRatesJnormal", nullptr, 2746 OHAvCapabilityGetAudioSupportedSampleRatesJnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 2747 {"oHAvCapabilityGetAudioSupportedSampleRatesKnormal", nullptr, 2748 OHAvCapabilityGetAudioSupportedSampleRatesKnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 2749 {"oHAvCapabilityGetAudioSupportedSampleRatesLnormal", nullptr, 2750 OHAvCapabilityGetAudioSupportedSampleRatesLnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 2751 {"oHAvCapabilityGetAudioSupportedSampleRatesMnormal", nullptr, 2752 OHAvCapabilityGetAudioSupportedSampleRatesMnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 2753 {"oHAvCapabilityGetAudioSupportedSampleRatesNnormal", nullptr, 2754 OHAvCapabilityGetAudioSupportedSampleRatesNnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 2755 {"oHAvCapabilityGetAudioSupportedSampleRatesOnormal", nullptr, 2756 OHAvCapabilityGetAudioSupportedSampleRatesOnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 2757 {"oHAvCapabilityGetAudioSupportedSampleRatesPnormal", nullptr, 2758 OHAvCapabilityGetAudioSupportedSampleRatesPnormal, nullptr, nullptr, nullptr, napi_default, nullptr}, 2759 2760 {"oHAvCapabilityGetAudioChannelCountRangeAnormal", nullptr, OHAvCapabilityGetAudioChannelCountRangeAnormal, 2761 nullptr, nullptr, nullptr, napi_default, nullptr}, 2762 {"oHAvCapabilityGetAudioChannelCountRangeBnormal", nullptr, OHAvCapabilityGetAudioChannelCountRangeBnormal, 2763 nullptr, nullptr, nullptr, napi_default, nullptr}, 2764 {"oHAvCapabilityGetAudioChannelCountRangeCnormal", nullptr, OHAvCapabilityGetAudioChannelCountRangeCnormal, 2765 nullptr, nullptr, nullptr, napi_default, nullptr}, 2766 {"oHAvCapabilityGetAudioChannelCountRangeDnormal", nullptr, OHAvCapabilityGetAudioChannelCountRangeDnormal, 2767 nullptr, nullptr, nullptr, napi_default, nullptr}, 2768 {"oHAvCapabilityGetAudioChannelCountRangeEnormal", nullptr, OHAvCapabilityGetAudioChannelCountRangeEnormal, 2769 nullptr, nullptr, nullptr, napi_default, nullptr}, 2770 {"oHAvCapabilityGetAudioChannelCountRangeFnormal", nullptr, OHAvCapabilityGetAudioChannelCountRangeFnormal, 2771 nullptr, nullptr, nullptr, napi_default, nullptr}, 2772 {"oHAvCapabilityGetAudioChannelCountRangeGnormal", nullptr, OHAvCapabilityGetAudioChannelCountRangeGnormal, 2773 nullptr, nullptr, nullptr, napi_default, nullptr}, 2774 {"oHAvCapabilityGetAudioChannelCountRangeHnormal", nullptr, OHAvCapabilityGetAudioChannelCountRangeHnormal, 2775 nullptr, nullptr, nullptr, napi_default, nullptr}, 2776 {"oHAvCapabilityGetAudioChannelCountRangeInormal", nullptr, OHAvCapabilityGetAudioChannelCountRangeInormal, 2777 nullptr, nullptr, nullptr, napi_default, nullptr}, 2778 2779 {"oHAvCapabilityGetAudioChannelCountRangeJnormal", nullptr, OHAvCapabilityGetAudioChannelCountRangeJnormal, 2780 nullptr, nullptr, nullptr, napi_default, nullptr}, 2781 {"oHAvCapabilityGetAudioChannelCountRangeKnormal", nullptr, OHAvCapabilityGetAudioChannelCountRangeKnormal, 2782 nullptr, nullptr, nullptr, napi_default, nullptr}, 2783 {"oHAvCapabilityGetAudioChannelCountRangeLnormal", nullptr, OHAvCapabilityGetAudioChannelCountRangeLnormal, 2784 nullptr, nullptr, nullptr, napi_default, nullptr}, 2785 {"oHAvCapabilityGetAudioChannelCountRangeMnormal", nullptr, OHAvCapabilityGetAudioChannelCountRangeMnormal, 2786 nullptr, nullptr, nullptr, napi_default, nullptr}, 2787 {"oHAvCapabilityGetAudioChannelCountRangeNnormal", nullptr, OHAvCapabilityGetAudioChannelCountRangeNnormal, 2788 nullptr, nullptr, nullptr, napi_default, nullptr}, 2789 {"oHAvCapabilityGetAudioChannelCountRangeOnormal", nullptr, OHAvCapabilityGetAudioChannelCountRangeOnormal, 2790 nullptr, nullptr, nullptr, napi_default, nullptr}, 2791 {"oHAvCapabilityGetAudioChannelCountRangePnormal", nullptr, OHAvCapabilityGetAudioChannelCountRangePnormal, 2792 nullptr, nullptr, nullptr, napi_default, nullptr}, 2793 {"oHAvCapabilityGetAudioChannelCountRangeQnormal", nullptr, OHAvCapabilityGetAudioChannelCountRangeQnormal, 2794 nullptr, nullptr, nullptr, napi_default, nullptr}, 2795 {"oHAvCapabilityGetAudioChannelCountRangeRnormal", nullptr, OHAvCapabilityGetAudioChannelCountRangeRnormal, 2796 nullptr, nullptr, nullptr, napi_default, nullptr}, 2797 {"oHAvCapabilityGetAudioChannelCountRangeSnormal", nullptr, OHAvCapabilityGetAudioChannelCountRangeSnormal, 2798 nullptr, nullptr, nullptr, napi_default, nullptr}, 2799 2800 {"oHAvCapabilityGetVideoWidthAlignmentAnormal", nullptr, OHAvCapabilityGetVideoWidthAlignmentAnormal, nullptr, 2801 nullptr, nullptr, napi_default, nullptr}, 2802 {"oHAvCapabilityGetVideoWidthAlignmentBnormal", nullptr, OHAvCapabilityGetVideoWidthAlignmentBnormal, nullptr, 2803 nullptr, nullptr, napi_default, nullptr}, 2804 {"oHAvCapabilityGetVideoWidthAlignmentCnormal", nullptr, OHAvCapabilityGetVideoWidthAlignmentCnormal, nullptr, 2805 nullptr, nullptr, napi_default, nullptr}, 2806 {"oHAvCapabilityGetVideoWidthAlignmentDnormal", nullptr, OHAvCapabilityGetVideoWidthAlignmentDnormal, nullptr, 2807 nullptr, nullptr, napi_default, nullptr}, 2808 {"oHAvCapabilityGetVideoWidthAlignmentEnormal", nullptr, OHAvCapabilityGetVideoWidthAlignmentEnormal, nullptr, 2809 nullptr, nullptr, napi_default, nullptr}, 2810 {"oHAvCapabilityGetVideoWidthAlignmentFnormal", nullptr, OHAvCapabilityGetVideoWidthAlignmentFnormal, nullptr, 2811 nullptr, nullptr, napi_default, nullptr}, 2812 {"oHAvCapabilityGetVideoWidthAlignmentGnormal", nullptr, OHAvCapabilityGetVideoWidthAlignmentGnormal, nullptr, 2813 nullptr, nullptr, napi_default, nullptr}, 2814 {"oHAvCapabilityGetVideoWidthAlignmentHnormal", nullptr, OHAvCapabilityGetVideoWidthAlignmentHnormal, nullptr, 2815 nullptr, nullptr, napi_default, nullptr}, 2816 {"oHAvCapabilityGetVideoWidthAlignmentInormal", nullptr, OHAvCapabilityGetVideoWidthAlignmentInormal, nullptr, 2817 nullptr, nullptr, napi_default, nullptr}, 2818 {"oHAvCapabilityGetVideoWidthAlignmentJnormal", nullptr, OHAvCapabilityGetVideoWidthAlignmentJnormal, nullptr, 2819 nullptr, nullptr, napi_default, nullptr}, 2820 {"oHAvCapabilityGetVideoWidthAlignmentKnormal", nullptr, OHAvCapabilityGetVideoWidthAlignmentKnormal, nullptr, 2821 nullptr, nullptr, napi_default, nullptr}, 2822 {"oHAvCapabilityGetVideoWidthAlignmentLnormal", nullptr, OHAvCapabilityGetVideoWidthAlignmentLnormal, nullptr, 2823 nullptr, nullptr, napi_default, nullptr}, 2824 {"oHAvCapabilityGetVideoWidthAlignmentMnormal", nullptr, OHAvCapabilityGetVideoWidthAlignmentMnormal, nullptr, 2825 nullptr, nullptr, napi_default, nullptr}, 2826 2827 {"oHAvCapabilityGetVideoHeightAlignmentAnormal", nullptr, oHAvCapabilityGetVideoHeightAlignmentAnormal, nullptr, 2828 nullptr, nullptr, napi_default, nullptr}, 2829 {"oHAvCapabilityGetVideoHeightAlignmentBnormal", nullptr, oHAvCapabilityGetVideoHeightAlignmentBnormal, nullptr, 2830 nullptr, nullptr, napi_default, nullptr}, 2831 {"oHAvCapabilityGetVideoHeightAlignmentCnormal", nullptr, oHAvCapabilityGetVideoHeightAlignmentCnormal, nullptr, 2832 nullptr, nullptr, napi_default, nullptr}, 2833 {"oHAvCapabilityGetVideoHeightAlignmentDnormal", nullptr, oHAvCapabilityGetVideoHeightAlignmentDnormal, nullptr, 2834 nullptr, nullptr, napi_default, nullptr}, 2835 {"oHAvCapabilityGetVideoHeightAlignmentEnormal", nullptr, oHAvCapabilityGetVideoHeightAlignmentEnormal, nullptr, 2836 nullptr, nullptr, napi_default, nullptr}, 2837 {"oHAvCapabilityGetVideoHeightAlignmentFnormal", nullptr, oHAvCapabilityGetVideoHeightAlignmentFnormal, nullptr, 2838 nullptr, nullptr, napi_default, nullptr}, 2839 {"oHAvCapabilityGetVideoHeightAlignmentGnormal", nullptr, oHAvCapabilityGetVideoHeightAlignmentGnormal, nullptr, 2840 nullptr, nullptr, napi_default, nullptr}, 2841 {"oHAvCapabilityGetVideoHeightAlignmentHnormal", nullptr, oHAvCapabilityGetVideoHeightAlignmentHnormal, nullptr, 2842 nullptr, nullptr, napi_default, nullptr}, 2843 {"oHAvCapabilityGetVideoHeightAlignmentInormal", nullptr, oHAvCapabilityGetVideoHeightAlignmentInormal, nullptr, 2844 nullptr, nullptr, napi_default, nullptr}, 2845 {"oHAvCapabilityGetVideoHeightAlignmentJnormal", nullptr, oHAvCapabilityGetVideoHeightAlignmentJnormal, nullptr, 2846 nullptr, nullptr, napi_default, nullptr}, 2847 {"oHAvCapabilityGetVideoHeightAlignmentKnormal", nullptr, oHAvCapabilityGetVideoHeightAlignmentKnormal, nullptr, 2848 nullptr, nullptr, napi_default, nullptr}, 2849 {"oHAvCapabilityGetVideoHeightAlignmentLnormal", nullptr, oHAvCapabilityGetVideoHeightAlignmentLnormal, nullptr, 2850 nullptr, nullptr, napi_default, nullptr}, 2851 {"oHAvCapabilityGetVideoHeightAlignmentMnormal", nullptr, oHAvCapabilityGetVideoHeightAlignmentMnormal, nullptr, 2852 nullptr, nullptr, napi_default, nullptr}, 2853 {"OH_AVCapability_GetEncoderQualityRange", nullptr, AVCapabilityGetEncoderQualityRange, nullptr, nullptr, 2854 nullptr, napi_default, nullptr}, 2855 {"OH_AVCapability_GetEncoderComplexityRange", nullptr, AVCapabilityGetEncoderComplexityRange, nullptr, nullptr, 2856 nullptr, napi_default, nullptr}, 2857 {"OH_AVCapability_GetAudioSupportedSampleRates", nullptr, AVCapabilityGetAudioSupportedSampleRates, nullptr, 2858 nullptr, nullptr, napi_default, nullptr}, 2859 {"OH_AVCapability_GetAudioChannelCountRange", nullptr, AVCapabilityGetAudioChannelCountRange, nullptr, nullptr, 2860 nullptr, napi_default, nullptr}, 2861 {"OH_AVCapability_GetVideoWidthAlignment", nullptr, AVCapabilityGetVideoWidthAlignment, nullptr, nullptr, 2862 nullptr, napi_default, nullptr}, 2863 {"OH_AVCapability_GetVideoHeightAlignment", nullptr, AVCapabilityGetVideoHeightAlignment, nullptr, nullptr, 2864 nullptr, napi_default, nullptr}, 2865 2866 {"OH_AVCodec_GetCapability", nullptr, AVCodecGetCapability, nullptr, nullptr, nullptr, napi_default, nullptr}, 2867 {"OH_AVCodec_GetCapabilityByCategory", nullptr, AVCodecGetCapabilityByCategory, nullptr, nullptr, nullptr, 2868 napi_default, nullptr}, 2869 {"OH_AVCapability_GetVideoWidthRange", nullptr, AVCapabilityGetVideoWidthRange, nullptr, nullptr, nullptr, 2870 napi_default, nullptr}, 2871 {"OH_AVCapability_GetVideoHeightRange", nullptr, AVCapabilityGetVideoHeightRange, nullptr, nullptr, nullptr, 2872 napi_default, nullptr}, 2873 {"OH_AVCapability_IsVideoSizeSupported", nullptr, AVCapabilityIsVideoSizeSupported, nullptr, nullptr, nullptr, 2874 napi_default, nullptr}, 2875 {"OH_AVCapability_GetVideoFrameRateRange", nullptr, AVCapabilityGetVideoFrameRateRange, nullptr, nullptr, 2876 nullptr, napi_default, nullptr}, 2877 {"OH_AVCapability_GetVideoFrameRateRangeForSize", nullptr, AVCapabilityGetVideoFrameRateRangeForSize, nullptr, 2878 nullptr, nullptr, napi_default, nullptr}, 2879 {"OH_AVCapability_AreVideoSizeAndFrameRateSupported", nullptr, AVCapabilityAreVideoSizeAndFrameRateSupported, 2880 nullptr, nullptr, nullptr, napi_default, nullptr}, 2881 {"OH_AVCapability_GetVideoSupportedPixelFormats", nullptr, AVCapabilityGetVideoSupportedPixelFormats, nullptr, 2882 nullptr, nullptr, napi_default, nullptr}, 2883 {"OH_AVCapability_GetSupportedProfiles", nullptr, AVCapabilityGetSupportedProfiles, nullptr, nullptr, nullptr, 2884 napi_default, nullptr}, 2885 {"OH_AVCapability_GetSupportedLevelsForProfile", nullptr, AVCapabilityGetSupportedLevelsForProfile, nullptr, 2886 nullptr, nullptr, napi_default, nullptr}, 2887 }; 2888 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc); 2889 return exports; 2890} 2891EXTERN_C_END 2892 2893static napi_module demoModule = { 2894 .nm_version = 1, 2895 .nm_flags = 0, 2896 .nm_filename = nullptr, 2897 .nm_register_func = Init, 2898 .nm_modname = "libmediacodecbasexdlndk", 2899 .nm_priv = ((void *)0), 2900 .reserved = { 0 }, 2901}; 2902 2903extern "C" __attribute__((constructor)) void RegisterModule(void) 2904{ 2905 napi_module_register(&demoModule); 2906} 2907