1 /*
2 * Copyright (C) 2021 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 "media_enum_napi.h"
17 #include <map>
18 #include <vector>
19 #include "media_log.h"
20 #include "media_errors.h"
21 #include "player.h"
22 #include "meta/video_types.h"
23 #include "recorder.h"
24 #include "avmetadatahelper.h"
25 #include "avcodec_common.h"
26 #include "recorder_profiles.h"
27 #include "av_common.h"
28 #include "mime_type.h"
29
30 namespace {
31 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "MediaEnumNapi"};
32 }
33
34 namespace OHOS {
35 namespace Media {
36 struct JsEnumInt {
37 std::string_view enumName;
38 int32_t enumInt;
39 };
40
41 struct JsEnumString {
42 std::string_view enumName;
43 std::string_view enumString;
44 };
45
46 static const std::vector<struct JsEnumInt> g_mediaErrorCode = {
47 { "MSERR_OK", MediaServiceExtErrCode::MSERR_EXT_OK },
48 { "MSERR_NO_MEMORY", MediaServiceExtErrCode::MSERR_EXT_NO_MEMORY },
49 { "MSERR_OPERATION_NOT_PERMIT", MediaServiceExtErrCode::MSERR_EXT_OPERATE_NOT_PERMIT },
50 { "MSERR_INVALID_VAL", MediaServiceExtErrCode::MSERR_EXT_INVALID_VAL },
51 { "MSERR_IO", MediaServiceExtErrCode::MSERR_EXT_IO },
52 { "MSERR_TIMEOUT", MediaServiceExtErrCode::MSERR_EXT_TIMEOUT },
53 { "MSERR_UNKNOWN", MediaServiceExtErrCode::MSERR_EXT_UNKNOWN },
54 { "MSERR_SERVICE_DIED", MediaServiceExtErrCode::MSERR_EXT_SERVICE_DIED },
55 { "MSERR_INVALID_STATE", MediaServiceExtErrCode::MSERR_EXT_INVALID_STATE },
56 { "MSERR_UNSUPPORTED", MediaServiceExtErrCode::MSERR_EXT_UNSUPPORT },
57 };
58
59 static const std::vector<struct JsEnumInt> g_AVErrorCode = {
60 { "AVERR_OK", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_OK },
61 { "AVERR_NO_PERMISSION", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_NO_PERMISSION },
62 { "AVERR_INVALID_PARAMETER", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_INVALID_PARAMETER },
63 { "AVERR_UNSUPPORT_CAPABILITY", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_UNSUPPORT_CAPABILITY },
64 { "AVERR_NO_MEMORY", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_NO_MEMORY },
65 { "AVERR_OPERATE_NOT_PERMIT", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_OPERATE_NOT_PERMIT },
66 { "AVERR_IO", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_IO },
67 { "AVERR_TIMEOUT", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_TIMEOUT },
68 { "AVERR_SERVICE_DIED", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_SERVICE_DIED },
69 { "AVERR_UNSUPPORT_FORMAT", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_UNSUPPORT_FORMAT },
70 };
71
72 static const std::vector<struct JsEnumInt> g_avDataSourceError = {
73 { "SOURCE_ERROR_IO", MediaDataSourceError::SOURCE_ERROR_IO },
74 { "SOURCE_ERROR_EOF", MediaDataSourceError::SOURCE_ERROR_EOF },
75 };
76
77 static const std::vector<struct JsEnumInt> g_bufferingInfoType = {
78 { "BUFFERING_START", BufferingInfoType::BUFFERING_START },
79 { "BUFFERING_END", BufferingInfoType::BUFFERING_END },
80 { "BUFFERING_PERCENT", BufferingInfoType::BUFFERING_PERCENT },
81 { "CACHED_DURATION", BufferingInfoType::CACHED_DURATION },
82 };
83
84 static const std::vector<struct JsEnumInt> g_recorderAudioEncoder = {
85 { "DEFAULT", AudioCodecFormat::AUDIO_DEFAULT },
86 { "AMR_NB", 1 }, // Provides implementation only
87 { "AMR_WB", 2 }, // Provides implementation only
88 { "AAC_LC", AudioCodecFormat::AAC_LC },
89 { "HE_AAC", 4 }, // Provides implementation only
90 };
91
92 static const std::vector<struct JsEnumInt> g_recorderAudioOutputFormat = {
93 { "DEFAULT", OutputFormatType::FORMAT_DEFAULT },
94 { "MPEG_4", OutputFormatType::FORMAT_MPEG_4 },
95 { "AMR_NB", 3 }, // Provides implementation only
96 { "AMR_WB", 4 }, // Provides implementation only
97 { "AAC_ADTS", OutputFormatType::FORMAT_M4A },
98 };
99
100 static const std::vector<struct JsEnumInt> g_playbackSpeed = {
101 { "SPEED_FORWARD_0_75_X", PlaybackRateMode::SPEED_FORWARD_0_75_X },
102 { "SPEED_FORWARD_1_00_X", PlaybackRateMode::SPEED_FORWARD_1_00_X },
103 { "SPEED_FORWARD_1_25_X", PlaybackRateMode::SPEED_FORWARD_1_25_X },
104 { "SPEED_FORWARD_1_75_X", PlaybackRateMode::SPEED_FORWARD_1_75_X },
105 { "SPEED_FORWARD_2_00_X", PlaybackRateMode::SPEED_FORWARD_2_00_X },
106 };
107
108 static const std::vector<struct JsEnumInt> g_mediaType = {
109 { "MEDIA_TYPE_AUD", MediaType::MEDIA_TYPE_AUD },
110 { "MEDIA_TYPE_VID", MediaType::MEDIA_TYPE_VID },
111 { "MEDIA_TYPE_SUBTITLE", MediaType::MEDIA_TYPE_SUBTITLE },
112 };
113
114 static const std::vector<struct JsEnumInt> g_videoRecorderQualityLevel = {
115 { "RECORDER_QUALITY_LOW", VideoRecorderQualityLevel::RECORDER_QUALITY_LOW },
116 { "RECORDER_QUALITY_HIGH", VideoRecorderQualityLevel::RECORDER_QUALITY_HIGH },
117 { "RECORDER_QUALITY_QCIF", VideoRecorderQualityLevel::RECORDER_QUALITY_QCIF },
118 { "RECORDER_QUALITY_CIF", VideoRecorderQualityLevel::RECORDER_QUALITY_CIF },
119 { "RECORDER_QUALITY_480P", VideoRecorderQualityLevel::RECORDER_QUALITY_480P },
120 { "RECORDER_QUALITY_720P", VideoRecorderQualityLevel::RECORDER_QUALITY_720P },
121 { "RECORDER_QUALITY_1080P", VideoRecorderQualityLevel::RECORDER_QUALITY_1080P },
122 { "RECORDER_QUALITY_QVGA", VideoRecorderQualityLevel::RECORDER_QUALITY_QVGA },
123 { "RECORDER_QUALITY_2160P", VideoRecorderQualityLevel::RECORDER_QUALITY_2160P },
124 };
125
126 static const std::vector<struct JsEnumInt> g_audioSourceType = {
127 { "AUDIO_SOURCE_TYPE_DEFAULT", AudioSourceType::AUDIO_SOURCE_DEFAULT },
128 { "AUDIO_SOURCE_TYPE_MIC", AudioSourceType::AUDIO_MIC },
129 };
130
131 static const std::vector<struct JsEnumInt> g_videoSourceType = {
132 { "VIDEO_SOURCE_TYPE_SURFACE_YUV", VideoSourceType::VIDEO_SOURCE_SURFACE_YUV },
133 { "VIDEO_SOURCE_TYPE_SURFACE_ES", VideoSourceType::VIDEO_SOURCE_SURFACE_ES },
134 };
135
136 static const std::vector<struct JsEnumInt> g_frameFlags = {
137 { "EOS_FRAME", AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_EOS },
138 { "SYNC_FRAME", AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_SYNC_FRAME },
139 { "PARTIAL_FRAME", AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_PARTIAL_FRAME },
140 { "CODEC_DATA", AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_CODEC_DATA },
141 };
142
143 static const std::vector<struct JsEnumInt> g_seekMode = {
144 { "SEEK_NEXT_SYNC", PlayerSeekMode::SEEK_NEXT_SYNC },
145 { "SEEK_PREV_SYNC", PlayerSeekMode::SEEK_PREVIOUS_SYNC },
146 { "SEEK_CLOSEST_SYNC", PlayerSeekMode::SEEK_CLOSEST_SYNC },
147 { "SEEK_CLOSEST", PlayerSeekMode::SEEK_CLOSEST },
148 };
149
150 static const std::vector<struct JsEnumInt> g_AVCodecType = {
151 { "AVCODEC_TYPE_VIDEO_ENCODER", AVCodecType::AVCODEC_TYPE_VIDEO_ENCODER },
152 { "AVCODEC_TYPE_VIDEO_DECODER", AVCodecType::AVCODEC_TYPE_VIDEO_DECODER },
153 { "AVCODEC_TYPE_AUDIO_ENCODER", AVCodecType::AVCODEC_TYPE_AUDIO_ENCODER },
154 { "AVCODEC_TYPE_AUDIO_DECODER", AVCodecType::AVCODEC_TYPE_AUDIO_DECODER },
155 };
156
157 static const std::vector<struct JsEnumInt> g_AACProfile = {
158 { "AAC_PROFILE_LC", AACProfile::AAC_PROFILE_LC },
159 { "AAC_PROFILE_ELD", AACProfile::AAC_PROFILE_ELD },
160 { "AAC_PROFILE_ERLC", AACProfile::AAC_PROFILE_ERLC },
161 { "AAC_PROFILE_HE", AACProfile::AAC_PROFILE_HE },
162 { "AAC_PROFILE_HE_V2", AACProfile::AAC_PROFILE_HE_V2 },
163 { "AAC_PROFILE_LD", AACProfile::AAC_PROFILE_LD },
164 { "AAC_PROFILE_MAIN", AACProfile::AAC_PROFILE_MAIN },
165 };
166
167 static const std::vector<struct JsEnumInt> g_avImageQueryOptions = {
168 { "AV_IMAGE_QUERY_NEXT_SYNC", AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC },
169 { "AV_IMAGE_QUERY_PREVIOUS_SYNC", AVMetadataQueryOption::AV_META_QUERY_PREVIOUS_SYNC },
170 { "AV_IMAGE_QUERY_CLOSEST_SYNC", AVMetadataQueryOption::AV_META_QUERY_CLOSEST_SYNC },
171 { "AV_IMAGE_QUERY_CLOSEST", AVMetadataQueryOption::AV_META_QUERY_CLOSEST },
172 };
173
174 static const std::vector<struct JsEnumInt> g_pixelFormat = {
175 { "RGB_565", 2 }, // PixelFormat::RGB_565
176 { "RGBA_8888", 3 }, // PixelFormat::RGBA_8888
177 { "RGB_888", 5 }, // PixelFormat::RGB_888
178 };
179
180 static const std::vector<struct JsEnumInt> g_videoEncodeBitrateMode = {
181 { "CBR", VideoEncodeBitrateMode::CBR },
182 { "VBR", VideoEncodeBitrateMode::VBR },
183 { "CQ", VideoEncodeBitrateMode::CQ },
184 };
185
186 static const std::vector<struct JsEnumInt> g_videoPixelFormat = {
187 { "YUVI420", VideoPixelFormat::YUVI420 },
188 { "NV12", VideoPixelFormat::NV12 },
189 { "NV21", VideoPixelFormat::NV21 },
190 { "SURFACE_FORMAT", VideoPixelFormat::SURFACE_FORMAT },
191 { "RGBA", VideoPixelFormat::RGBA },
192 };
193
194 static const std::vector<struct JsEnumInt> g_AVCProfile = {
195 { "AVC_PROFILE_BASELINE", AVCProfile::AVC_PROFILE_BASELINE },
196 { "AVC_PROFILE_CONSTRAINED_BASELINE", AVCProfile::AVC_PROFILE_CONSTRAINED_BASELINE },
197 { "AVC_PROFILE_CONSTRAINED_HIGH", AVCProfile::AVC_PROFILE_CONSTRAINED_HIGH },
198 { "AVC_PROFILE_EXTENDED", AVCProfile::AVC_PROFILE_EXTENDED },
199 { "AVC_PROFILE_HIGH", AVCProfile::AVC_PROFILE_HIGH },
200 { "AVC_PROFILE_HIGH_10", AVCProfile::AVC_PROFILE_HIGH_10 },
201 { "AVC_PROFILE_HIGH_422", AVCProfile::AVC_PROFILE_HIGH_422 },
202 { "AVC_PROFILE_HIGH_444", AVCProfile::AVC_PROFILE_HIGH_444 },
203 { "AVC_PROFILE_MAIN", AVCProfile::AVC_PROFILE_MAIN },
204 };
205
206 static const std::vector<struct JsEnumInt> g_HEVCProfile = {
207 { "HEVC_PROFILE_MAIN", HEVCProfile::HEVC_PROFILE_MAIN },
208 { "HEVC_PROFILE_MAIN_10", HEVCProfile::HEVC_PROFILE_MAIN_10 },
209 { "HEVC_PROFILE_MAIN_STILL", HEVCProfile::HEVC_PROFILE_MAIN_STILL },
210 };
211
212 static const std::vector<struct JsEnumInt> g_MPEG2Profile = {
213 { "MPEG2_PROFILE_422", MPEG2Profile::MPEG2_PROFILE_422 },
214 { "MPEG2_PROFILE_HIGH", MPEG2Profile::MPEG2_PROFILE_HIGH },
215 { "MPEG2_PROFILE_MAIN", MPEG2Profile::MPEG2_PROFILE_MAIN },
216 { "MPEG2_PROFILE_SNR", MPEG2Profile::MPEG2_PROFILE_SNR },
217 { "MPEG2_PROFILE_SIMPLE", MPEG2Profile::MPEG2_PROFILE_SIMPLE },
218 { "MPEG2_PROFILE_SPATIAL", MPEG2Profile::MPEG2_PROFILE_SPATIAL },
219 };
220
221 static const std::vector<struct JsEnumInt> g_MPEG4Profile = {
222 { "MPEG4_PROFILE_ADVANCED_CODING", MPEG4Profile::MPEG4_PROFILE_ADVANCED_CODING },
223 { "MPEG4_PROFILE_ADVANCED_CORE", MPEG4Profile::MPEG4_PROFILE_ADVANCED_CORE },
224 { "MPEG4_PROFILE_ADVANCED_REAL_TIME", MPEG4Profile::MPEG4_PROFILE_ADVANCED_REAL_TIME },
225 { "MPEG4_PROFILE_ADVANCED_SCALABLE", MPEG4Profile::MPEG4_PROFILE_ADVANCED_SCALABLE },
226 { "MPEG4_PROFILE_ADVANCED_SIMPLE", MPEG4Profile::MPEG4_PROFILE_ADVANCED_SIMPLE },
227 { "MPEG4_PROFILE_BASIC_ANIMATED", MPEG4Profile::MPEG4_PROFILE_BASIC_ANIMATED },
228 { "MPEG4_PROFILE_CORE", MPEG4Profile::MPEG4_PROFILE_CORE },
229 { "MPEG4_PROFILE_CORE_SCALABLE", MPEG4Profile::MPEG4_PROFILE_CORE_SCALABLE },
230 { "MPEG4_PROFILE_HYBRID", MPEG4Profile::MPEG4_PROFILE_HYBRID },
231 { "MPEG4_PROFILE_MAIN", MPEG4Profile::MPEG4_PROFILE_MAIN },
232 { "MPEG4_PROFILE_NBIT", MPEG4Profile::MPEG4_PROFILE_NBIT },
233 { "MPEG4_PROFILE_SCALABLE_TEXTURE", MPEG4Profile::MPEG4_PROFILE_SCALABLE_TEXTURE },
234 { "MPEG4_PROFILE_SIMPLE", MPEG4Profile::MPEG4_PROFILE_SIMPLE },
235 { "MPEG4_PROFILE_SIMPLE_FBA", MPEG4Profile::MPEG4_PROFILE_SIMPLE_FBA },
236 { "MPEG4_PROFILE_SIMPLE_FACE", MPEG4Profile::MPEG4_PROFILE_SIMPLE_FACE },
237 { "MPEG4_PROFILE_SIMPLE_SCALABLE", MPEG4Profile::MPEG4_PROFILE_SIMPLE_SCALABLE },
238 };
239
240 static const std::vector<struct JsEnumInt> g_H263Profile = {
241 { "H263_PROFILE_BACKWARD_COMPATIBLE", H263Profile::H263_PROFILE_BACKWARD_COMPATIBLE },
242 { "H263_PROFILE_BASELINE", H263Profile::H263_PROFILE_BASELINE },
243 { "H263_PROFILE_H320_CODING", H263Profile::H263_PROFILE_H320_CODING },
244 { "H263_PROFILE_HIGH_COMPRESSION", H263Profile::H263_PROFILE_HIGH_COMPRESSION },
245 { "H263_PROFILE_HIGH_LATENCY", H263Profile::H263_PROFILE_HIGH_LATENCY },
246 { "H263_PROFILE_ISW_V2", H263Profile::H263_PROFILE_ISW_V2 },
247 { "H263_PROFILE_ISW_V3", H263Profile::H263_PROFILE_ISW_V3 },
248 { "H263_PROFILE_INTERLACE", H263Profile::H263_PROFILE_INTERLACE },
249 { "H263_PROFILE_INTERNET", H263Profile::H263_PROFILE_INTERNET },
250 };
251
252 static const std::vector<struct JsEnumInt> g_VP8Profile = {
253 { "VP8_PROFILE_MAIN", VP8Profile::VP8_PROFILE_MAIN },
254 };
255
256 static const std::vector<struct JsEnumInt> g_VideoScaleType = {
257 { "VIDEO_SCALE_TYPE_FIT", static_cast<int32_t>(Plugins::VideoScaleType::VIDEO_SCALE_TYPE_FIT) },
258 { "VIDEO_SCALE_TYPE_FIT_CROP", static_cast<int32_t>(Plugins::VideoScaleType::VIDEO_SCALE_TYPE_FIT_CROP) },
259 };
260
261 static const std::vector<struct JsEnumInt> g_stateChangeReason = {
262 { "USER", StateChangeReason::USER },
263 { "BACKGROUND", StateChangeReason::BACKGROUND },
264 };
265
266 static const std::vector<struct JsEnumString> g_containerFormatType = {
267 { "CFT_MPEG_4", ContainerFormatType::CFT_MPEG_4 },
268 { "CFT_MPEG_4A", ContainerFormatType::CFT_MPEG_4A },
269 };
270
271 static const std::vector<struct JsEnumString> g_codecMimeType = {
272 { "VIDEO_H263", OHOS::Media::Plugins::MimeType::VIDEO_H263 },
273 { "VIDEO_AVC", OHOS::Media::Plugins::MimeType::VIDEO_AVC },
274 { "VIDEO_MPEG2", OHOS::Media::Plugins::MimeType::VIDEO_MPEG2 },
275 { "VIDEO_HEVC", OHOS::Media::Plugins::MimeType::VIDEO_HEVC },
276 { "VIDEO_MPEG4", OHOS::Media::Plugins::MimeType::VIDEO_MPEG4 },
277 { "VIDEO_VP8", OHOS::Media::Plugins::MimeType::VIDEO_VP8 },
278 { "VIDEO_VP9", OHOS::Media::Plugins::MimeType::VIDEO_VP9 },
279 { "AUDIO_AMR_NB", OHOS::Media::Plugins::MimeType::AUDIO_AMR_NB },
280 { "AUDIO_AMR_WB", OHOS::Media::Plugins::MimeType::AUDIO_AMR_WB },
281 { "AUDIO_MPEG", OHOS::Media::Plugins::MimeType::AUDIO_MPEG },
282 { "AUDIO_AAC", OHOS::Media::Plugins::MimeType::AUDIO_AAC },
283 { "AUDIO_VORBIS", OHOS::Media::Plugins::MimeType::AUDIO_VORBIS },
284 { "AUDIO_OPUS", OHOS::Media::Plugins::MimeType::AUDIO_OPUS },
285 { "AUDIO_FLAC", OHOS::Media::Plugins::MimeType::AUDIO_FLAC },
286 { "AUDIO_RAW", OHOS::Media::Plugins::MimeType::AUDIO_RAW },
287 };
288
289 static const std::vector<struct JsEnumString> g_mediaDescriptionKey = {
290 { "MD_KEY_TRACK_INDEX", "track_index" },
291 { "MD_KEY_TRACK_TYPE", "track_type" },
292 { "MD_KEY_CODEC_MIME", "codec_mime" },
293 { "MD_KEY_DURATION", "duration" },
294 { "MD_KEY_BITRATE", "bitrate" },
295 { "MD_KEY_MAX_INPUT_SIZE", "max_input_size" },
296 { "MD_KEY_MAX_ENCODER_FPS", "max_encoder_fps" },
297 { "MD_KEY_WIDTH", "width" },
298 { "MD_KEY_HEIGHT", "height" },
299 { "MD_KEY_PIXEL_FORMAT", "pixel_format" },
300 { "MD_KEY_AUDIO_SAMPLE_FORMAT", "audio_sample_format" },
301 { "MD_KEY_FRAME_RATE", "frame_rate" },
302 { "MD_KEY_CAPTURE_RATE", "capture_rate" },
303 { "MD_KEY_I_FRAME_INTERVAL", "i_frame_interval" },
304 { "MD_KEY_REQUEST_I_FRAME", "req_i_frame" },
305 { "MD_KEY_REPEAT_FRAME_AFTER", "repeat_frame_after" },
306 { "MD_KEY_SUSPEND_INPUT_SURFACE", "suspend_input_surface" },
307 { "MD_KEY_VIDEO_ENCODE_BITRATE_MODE", "video_encode_bitrate_mode" },
308 { "MD_KEY_PROFILE", "codec_profile" },
309 { "MD_KEY_QUALITY", "codec_quality" },
310 { "MD_KEY_RECT_TOP", "rect_top" },
311 { "MD_KEY_RECT_BOTTOM", "rect_bottom" },
312 { "MD_KEY_RECT_LEFT", "rect_left" },
313 { "MD_KEY_RECT_RIGHT", "rect_right" },
314 { "MD_KEY_COLOR_STANDARD", "color_standard" },
315 { "MD_KEY_AUD_CHANNEL_COUNT", "channel_count" },
316 { "MD_KEY_AUD_SAMPLE_RATE", "sample_rate" },
317 { "MD_KEY_CUSTOM", "vendor.custom" },
318 { "MD_KEY_LANGUAGE", "language" },
319 };
320
321 static const std::map<std::string_view, const std::vector<struct JsEnumInt>&> g_intEnumClassMap = {
322 { "AVErrorCode", g_AVErrorCode},
323 { "MediaErrorCode", g_mediaErrorCode },
324 { "AVDataSourceError", g_avDataSourceError },
325 { "BufferingInfoType", g_bufferingInfoType },
326 { "AudioEncoder", g_recorderAudioEncoder },
327 { "AudioOutputFormat", g_recorderAudioOutputFormat },
328 { "PlaybackSpeed", g_playbackSpeed },
329 { "AVImageQueryOptions", g_avImageQueryOptions },
330 { "PixelFormat", g_pixelFormat },
331 { "MediaType", g_mediaType },
332 { "VideoRecorderQualityLevel", g_videoRecorderQualityLevel },
333 { "AudioSourceType", g_audioSourceType },
334 { "VideoSourceType", g_videoSourceType },
335 { "FrameFlags", g_frameFlags },
336 { "SeekMode", g_seekMode },
337 { "AVCodecType", g_AVCodecType },
338 { "AACProfile", g_AACProfile },
339 { "VideoEncodeBitrateMode", g_videoEncodeBitrateMode },
340 { "VideoPixelFormat", g_videoPixelFormat },
341 { "AVCProfile", g_AVCProfile },
342 { "HEVCProfile", g_HEVCProfile },
343 { "MPEG2Profile", g_MPEG2Profile },
344 { "MPEG4Profile", g_MPEG4Profile },
345 { "H263Profile", g_H263Profile},
346 { "VP8Profile", g_VP8Profile },
347 { "VideoScaleType", g_VideoScaleType},
348 { "StateChangeReason", g_stateChangeReason},
349 };
350
351 static const std::map<std::string_view, const std::vector<struct JsEnumString>&> g_stringEnumClassMap = {
352 { "MediaDescriptionKey", g_mediaDescriptionKey },
353 { "ContainerFormatType", g_containerFormatType },
354 { "CodecMimeType", g_codecMimeType },
355 };
356
JsEnumIntInit(napi_env env,napi_value exports)357 napi_value MediaEnumNapi::JsEnumIntInit(napi_env env, napi_value exports)
358 {
359 for (auto it = g_intEnumClassMap.begin(); it != g_intEnumClassMap.end(); it++) {
360 auto &enumClassName = it->first;
361 auto &enumItemVec = it->second;
362 int32_t vecSize = enumItemVec.size();
363 std::vector<napi_value> value;
364 value.resize(vecSize);
365 for (int32_t index = 0; index < vecSize; ++index) {
366 napi_create_int32(env, enumItemVec[index].enumInt, &value[index]);
367 }
368
369 std::vector<napi_property_descriptor> property;
370 property.resize(vecSize);
371 for (int32_t index = 0; index < vecSize; ++index) {
372 property[index] = napi_property_descriptor DECLARE_NAPI_STATIC_PROPERTY(
373 enumItemVec[index].enumName.data(), value[index]);
374 }
375
376 auto napiConstructor = [](napi_env env, napi_callback_info info) {
377 napi_value jsThis = nullptr;
378 napi_get_cb_info(env, info, nullptr, nullptr, &jsThis, nullptr);
379 return jsThis;
380 };
381
382 napi_value result = nullptr;
383 napi_status napiStatus = napi_define_class(env, enumClassName.data(), NAPI_AUTO_LENGTH, napiConstructor,
384 nullptr, property.size(), property.data(), &result);
385 CHECK_AND_RETURN_RET_LOG(napiStatus == napi_ok, nullptr, "Failed to define enum");
386
387 napiStatus = napi_set_named_property(env, exports, enumClassName.data(), result);
388 CHECK_AND_RETURN_RET_LOG(napiStatus == napi_ok, nullptr, "Failed to set result");
389 }
390 return exports;
391 }
392
JsEnumStringInit(napi_env env,napi_value exports)393 napi_value MediaEnumNapi::JsEnumStringInit(napi_env env, napi_value exports)
394 {
395 for (auto it = g_stringEnumClassMap.begin(); it != g_stringEnumClassMap.end(); it++) {
396 auto &enumType = it->first;
397 auto &enumValue = it->second;
398 int32_t vecSize = enumValue.size();
399 std::vector<napi_value> value;
400 value.resize(vecSize);
401 for (int32_t index = 0; index < vecSize; ++index) {
402 napi_create_string_utf8(env, enumValue[index].enumString.data(), NAPI_AUTO_LENGTH, &value[index]);
403 }
404
405 std::vector<napi_property_descriptor> property;
406 property.resize(vecSize);
407 for (int32_t index = 0; index < vecSize; ++index) {
408 property[index] = napi_property_descriptor DECLARE_NAPI_STATIC_PROPERTY(
409 enumValue[index].enumName.data(), value[index]);
410 }
411
412 auto constructor = [](napi_env env, napi_callback_info info) {
413 napi_value jsThis = nullptr;
414 napi_get_cb_info(env, info, nullptr, nullptr, &jsThis, nullptr);
415 return jsThis;
416 };
417
418 napi_value result = nullptr;
419 napi_status status = napi_define_class(env, enumType.data(), NAPI_AUTO_LENGTH, constructor,
420 nullptr, property.size(), property.data(), &result);
421 CHECK_AND_RETURN_RET_LOG(status == napi_ok, nullptr, "Failed to define enum");
422
423 status = napi_set_named_property(env, exports, enumType.data(), result);
424 CHECK_AND_RETURN_RET_LOG(status == napi_ok, nullptr, "Failed to set result");
425 }
426 return exports;
427 }
428
Init(napi_env env,napi_value exports)429 napi_value MediaEnumNapi::Init(napi_env env, napi_value exports)
430 {
431 JsEnumIntInit(env, exports);
432 JsEnumStringInit(env, exports);
433 return exports;
434 }
435 } // namespace Media
436 } // namespace OHOS