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 #include "screen_capture.h"
30 #include "avscreen_capture_napi.h"
31 
32 namespace {
33     constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_PLAYER, "MediaEnumNapi"};
34 }
35 
36 namespace OHOS {
37 namespace Media {
38 struct JsEnumInt {
39     std::string_view enumName;
40     int32_t enumInt;
41 };
42 
43 struct JsEnumString {
44     std::string_view enumName;
45     std::string_view enumString;
46 };
47 
48 static const std::vector<struct JsEnumInt> g_mediaErrorCode = {
49     { "MSERR_OK", MediaServiceExtErrCode::MSERR_EXT_OK },
50     { "MSERR_NO_MEMORY", MediaServiceExtErrCode::MSERR_EXT_NO_MEMORY },
51     { "MSERR_OPERATION_NOT_PERMIT", MediaServiceExtErrCode::MSERR_EXT_OPERATE_NOT_PERMIT },
52     { "MSERR_INVALID_VAL", MediaServiceExtErrCode::MSERR_EXT_INVALID_VAL },
53     { "MSERR_IO", MediaServiceExtErrCode::MSERR_EXT_IO },
54     { "MSERR_TIMEOUT", MediaServiceExtErrCode::MSERR_EXT_TIMEOUT },
55     { "MSERR_UNKNOWN", MediaServiceExtErrCode::MSERR_EXT_UNKNOWN },
56     { "MSERR_SERVICE_DIED", MediaServiceExtErrCode::MSERR_EXT_SERVICE_DIED },
57     { "MSERR_INVALID_STATE", MediaServiceExtErrCode::MSERR_EXT_INVALID_STATE },
58     { "MSERR_UNSUPPORTED", MediaServiceExtErrCode::MSERR_EXT_UNSUPPORT },
59 };
60 
61 static const std::vector<struct JsEnumInt> g_AVErrorCode = {
62     { "AVERR_OK", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_OK },
63     { "AVERR_NO_PERMISSION", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_NO_PERMISSION },
64     { "AVERR_INVALID_PARAMETER", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_INVALID_PARAMETER },
65     { "AVERR_UNSUPPORT_CAPABILITY", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_UNSUPPORT_CAPABILITY },
66     { "AVERR_NO_MEMORY", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_NO_MEMORY },
67     { "AVERR_OPERATE_NOT_PERMIT", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_OPERATE_NOT_PERMIT },
68     { "AVERR_IO", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_IO },
69     { "AVERR_TIMEOUT", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_TIMEOUT },
70     { "AVERR_SERVICE_DIED", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_SERVICE_DIED },
71     { "AVERR_UNSUPPORT_FORMAT", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_UNSUPPORT_FORMAT },
72     { "AVERR_AUDIO_INTERRUPTED", MediaServiceExtErrCodeAPI9::MSERR_EXT_API9_AUDIO_INTERRUPTED},
73 };
74 
75 static const std::vector<struct JsEnumInt> g_avDataSourceError = {
76     { "SOURCE_ERROR_IO", MediaDataSourceError::SOURCE_ERROR_IO },
77     { "SOURCE_ERROR_EOF", MediaDataSourceError::SOURCE_ERROR_EOF },
78 };
79 
80 static const std::vector<struct JsEnumInt> g_bufferingInfoType = {
81     { "BUFFERING_START", BufferingInfoType::BUFFERING_START },
82     { "BUFFERING_END", BufferingInfoType::BUFFERING_END },
83     { "BUFFERING_PERCENT", BufferingInfoType::BUFFERING_PERCENT },
84     { "CACHED_DURATION", BufferingInfoType::CACHED_DURATION },
85 };
86 
87 static const std::vector<struct JsEnumInt> g_recorderAudioEncoder = {
88     { "DEFAULT", AudioCodecFormat::AUDIO_DEFAULT },
89     { "AMR_NB", 1 }, // Provides implementation only
90     { "AMR_WB", 2 }, // Provides implementation only
91     { "AAC_LC", AudioCodecFormat::AAC_LC },
92     { "HE_AAC", 4 }, // Provides implementation only
93 };
94 
95 static const std::vector<struct JsEnumInt> g_recorderAudioOutputFormat = {
96     { "DEFAULT", OutputFormatType::FORMAT_DEFAULT },
97     { "MPEG_4", OutputFormatType::FORMAT_MPEG_4 },
98     { "AMR_NB", 3 }, // Provides implementation only
99     { "AMR_WB", 4 }, // Provides implementation only
100     { "AAC_ADTS", OutputFormatType::FORMAT_M4A },
101 };
102 
103 static const std::vector<struct JsEnumInt> g_playbackSpeed = {
104     { "SPEED_FORWARD_0_75_X", PlaybackRateMode::SPEED_FORWARD_0_75_X },
105     { "SPEED_FORWARD_1_00_X", PlaybackRateMode::SPEED_FORWARD_1_00_X },
106     { "SPEED_FORWARD_1_25_X", PlaybackRateMode::SPEED_FORWARD_1_25_X },
107     { "SPEED_FORWARD_1_75_X", PlaybackRateMode::SPEED_FORWARD_1_75_X },
108     { "SPEED_FORWARD_2_00_X", PlaybackRateMode::SPEED_FORWARD_2_00_X },
109     { "SPEED_FORWARD_0_50_X", PlaybackRateMode::SPEED_FORWARD_0_50_X },
110     { "SPEED_FORWARD_1_50_X", PlaybackRateMode::SPEED_FORWARD_1_50_X },
111     { "SPEED_FORWARD_3_00_X", PlaybackRateMode::SPEED_FORWARD_3_00_X },
112     { "SPEED_FORWARD_0_25_X", PlaybackRateMode::SPEED_FORWARD_0_25_X },
113     { "SPEED_FORWARD_0_125_X", PlaybackRateMode::SPEED_FORWARD_0_125_X },
114 };
115 
116 static const std::vector<struct JsEnumInt> g_mediaType = {
117     { "MEDIA_TYPE_AUD", MediaType::MEDIA_TYPE_AUD },
118     { "MEDIA_TYPE_VID", MediaType::MEDIA_TYPE_VID },
119     { "MEDIA_TYPE_SUBTITLE", MediaType::MEDIA_TYPE_SUBTITLE },
120 };
121 
122 static const std::vector<struct JsEnumInt> g_videoRecorderQualityLevel = {
123     { "RECORDER_QUALITY_LOW", VideoRecorderQualityLevel::RECORDER_QUALITY_LOW },
124     { "RECORDER_QUALITY_HIGH", VideoRecorderQualityLevel::RECORDER_QUALITY_HIGH },
125     { "RECORDER_QUALITY_QCIF", VideoRecorderQualityLevel::RECORDER_QUALITY_QCIF },
126     { "RECORDER_QUALITY_CIF", VideoRecorderQualityLevel::RECORDER_QUALITY_CIF },
127     { "RECORDER_QUALITY_480P", VideoRecorderQualityLevel::RECORDER_QUALITY_480P },
128     { "RECORDER_QUALITY_720P", VideoRecorderQualityLevel::RECORDER_QUALITY_720P },
129     { "RECORDER_QUALITY_1080P", VideoRecorderQualityLevel::RECORDER_QUALITY_1080P },
130     { "RECORDER_QUALITY_QVGA", VideoRecorderQualityLevel::RECORDER_QUALITY_QVGA },
131     { "RECORDER_QUALITY_2160P", VideoRecorderQualityLevel::RECORDER_QUALITY_2160P },
132 };
133 
134 static const std::vector<struct JsEnumInt> g_audioSourceType = {
135     { "AUDIO_SOURCE_TYPE_DEFAULT", AudioSourceType::AUDIO_SOURCE_DEFAULT },
136     { "AUDIO_SOURCE_TYPE_MIC", AudioSourceType::AUDIO_MIC },
137     { "AUDIO_SOURCE_TYPE_VOICE_RECOGNITION", AudioSourceType::AUDIO_SOURCE_VOICE_RECOGNITION },
138     { "AUDIO_SOURCE_TYPE_VOICE_COMMUNICATION", AudioSourceType::AUDIO_SOURCE_VOICE_COMMUNICATION },
139     { "AUDIO_SOURCE_TYPE_VOICE_MESSAGE", AudioSourceType::AUDIO_SOURCE_VOICE_MESSAGE },
140     { "AUDIO_SOURCE_TYPE_CAMCORDER", AudioSourceType::AUDIO_SOURCE_CAMCORDER },
141 };
142 
143 static const std::vector<struct JsEnumInt> g_videoSourceType = {
144     { "VIDEO_SOURCE_TYPE_SURFACE_YUV", VideoSourceType::VIDEO_SOURCE_SURFACE_YUV },
145     { "VIDEO_SOURCE_TYPE_SURFACE_ES", VideoSourceType::VIDEO_SOURCE_SURFACE_ES },
146 };
147 
148 static const std::vector<struct JsEnumInt> g_metaSourceType = {
149     { "VIDEO_MAKER_INFO", MetaSourceType::VIDEO_META_MAKER_INFO },
150 };
151 
152 static const std::vector<struct JsEnumInt> g_fileGenerationMode = {
153     { "APP_CREATE", FileGenerationMode::APP_CREATE },
154     { "AUTO_CREATE_CAMERA_SCENE", FileGenerationMode::AUTO_CREATE_CAMERA_SCENE },
155 };
156 
157 static const std::vector<struct JsEnumInt> g_frameFlags = {
158     { "EOS_FRAME", AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_EOS },
159     { "SYNC_FRAME", AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_SYNC_FRAME },
160     { "PARTIAL_FRAME", AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_PARTIAL_FRAME },
161     { "CODEC_DATA", AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_CODEC_DATA },
162 };
163 
164 static const std::vector<struct JsEnumInt> g_hdrType = {
165     { "AV_HDR_TYPE_NONE", HdrType::AV_HDR_TYPE_NONE },
166     { "AV_HDR_TYPE_VIVID", HdrType::AV_HDR_TYPE_VIVID },
167 };
168 
169 static const std::vector<struct JsEnumInt> g_seekMode = {
170     { "SEEK_NEXT_SYNC", PlayerSeekMode::SEEK_NEXT_SYNC },
171     { "SEEK_PREV_SYNC", PlayerSeekMode::SEEK_PREVIOUS_SYNC },
172     { "SEEK_CLOSEST", 2 }, // 2 is consistent with the SeekMode defination in ohos.multimedia.media.d.ts.
173     { "SEEK_CONTINUOUS", 3 }, // 3 is consistent with the SeekMode defination in ohos.multimedia.media.d.ts.
174 };
175 
176 static const std::vector<struct JsEnumInt> g_switchMode = {
177     { "SMOOTH", PlayerSwitchMode::SWITCH_SMOOTH },
178     { "SEGMENT", PlayerSwitchMode::SWITCH_SEGMENT },
179     { "CLOSEST", PlayerSwitchMode::SWITCH_CLOSEST },
180 };
181 
182 static const std::vector<struct JsEnumInt> g_AVCodecType = {
183     { "AVCODEC_TYPE_VIDEO_ENCODER", AVCodecType::AVCODEC_TYPE_VIDEO_ENCODER },
184     { "AVCODEC_TYPE_VIDEO_DECODER", AVCodecType::AVCODEC_TYPE_VIDEO_DECODER },
185     { "AVCODEC_TYPE_AUDIO_ENCODER", AVCodecType::AVCODEC_TYPE_AUDIO_ENCODER },
186     { "AVCODEC_TYPE_AUDIO_DECODER", AVCodecType::AVCODEC_TYPE_AUDIO_DECODER },
187 };
188 
189 static const std::vector<struct JsEnumInt> g_AACProfile = {
190     { "AAC_PROFILE_LC", AACProfile::AAC_PROFILE_LC },
191     { "AAC_PROFILE_ELD", AACProfile::AAC_PROFILE_ELD },
192     { "AAC_PROFILE_ERLC", AACProfile::AAC_PROFILE_ERLC },
193     { "AAC_PROFILE_HE", AACProfile::AAC_PROFILE_HE },
194     { "AAC_PROFILE_HE_V2", AACProfile::AAC_PROFILE_HE_V2 },
195     { "AAC_PROFILE_LD", AACProfile::AAC_PROFILE_LD },
196     { "AAC_PROFILE_MAIN", AACProfile::AAC_PROFILE_MAIN },
197 };
198 
199 static const std::vector<struct JsEnumInt> g_avImageQueryOptions = {
200     { "AV_IMAGE_QUERY_NEXT_SYNC", AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC },
201     { "AV_IMAGE_QUERY_PREVIOUS_SYNC", AVMetadataQueryOption::AV_META_QUERY_PREVIOUS_SYNC },
202     { "AV_IMAGE_QUERY_CLOSEST_SYNC", AVMetadataQueryOption::AV_META_QUERY_CLOSEST_SYNC },
203     { "AV_IMAGE_QUERY_CLOSEST", AVMetadataQueryOption::AV_META_QUERY_CLOSEST },
204 };
205 
206 static const std::vector<struct JsEnumInt> g_pixelFormat = {
207     { "RGB_565", 2 }, // PixelFormat::RGB_565
208     { "RGBA_8888", 3 }, // PixelFormat::RGBA_8888
209     { "RGB_888", 5 }, // PixelFormat::RGB_888
210 };
211 
212 static const std::vector<struct JsEnumInt> g_videoEncodeBitrateMode = {
213     { "CBR", VideoEncodeBitrateMode::CBR },
214     { "VBR", VideoEncodeBitrateMode::VBR },
215     { "CQ", VideoEncodeBitrateMode::CQ },
216 };
217 
218 static const std::vector<struct JsEnumInt> g_videoPixelFormat = {
219     { "YUVI420", VideoPixelFormat::YUVI420 },
220     { "NV12", VideoPixelFormat::NV12 },
221     { "NV21", VideoPixelFormat::NV21 },
222     { "SURFACE_FORMAT", VideoPixelFormat::SURFACE_FORMAT },
223     { "RGBA", VideoPixelFormat::RGBA },
224 };
225 
226 static const std::vector<struct JsEnumInt> g_AVCProfile = {
227     { "AVC_PROFILE_BASELINE", AVCProfile::AVC_PROFILE_BASELINE },
228     { "AVC_PROFILE_CONSTRAINED_BASELINE", AVCProfile::AVC_PROFILE_CONSTRAINED_BASELINE },
229     { "AVC_PROFILE_CONSTRAINED_HIGH", AVCProfile::AVC_PROFILE_CONSTRAINED_HIGH },
230     { "AVC_PROFILE_EXTENDED", AVCProfile::AVC_PROFILE_EXTENDED },
231     { "AVC_PROFILE_HIGH", AVCProfile::AVC_PROFILE_HIGH },
232     { "AVC_PROFILE_HIGH_10", AVCProfile::AVC_PROFILE_HIGH_10 },
233     { "AVC_PROFILE_HIGH_422", AVCProfile::AVC_PROFILE_HIGH_422 },
234     { "AVC_PROFILE_HIGH_444", AVCProfile::AVC_PROFILE_HIGH_444 },
235     { "AVC_PROFILE_MAIN", AVCProfile::AVC_PROFILE_MAIN },
236 };
237 
238 static const std::vector<struct JsEnumInt> g_HEVCProfile = {
239     { "HEVC_PROFILE_MAIN", HEVCProfile::HEVC_PROFILE_MAIN },
240     { "HEVC_PROFILE_MAIN_10", HEVCProfile::HEVC_PROFILE_MAIN_10 },
241     { "HEVC_PROFILE_MAIN_STILL", HEVCProfile::HEVC_PROFILE_MAIN_STILL },
242 };
243 
244 static const std::vector<struct JsEnumInt> g_MPEG2Profile = {
245     { "MPEG2_PROFILE_422", MPEG2Profile::MPEG2_PROFILE_422 },
246     { "MPEG2_PROFILE_HIGH", MPEG2Profile::MPEG2_PROFILE_HIGH },
247     { "MPEG2_PROFILE_MAIN", MPEG2Profile::MPEG2_PROFILE_MAIN },
248     { "MPEG2_PROFILE_SNR", MPEG2Profile::MPEG2_PROFILE_SNR },
249     { "MPEG2_PROFILE_SIMPLE", MPEG2Profile::MPEG2_PROFILE_SIMPLE },
250     { "MPEG2_PROFILE_SPATIAL", MPEG2Profile::MPEG2_PROFILE_SPATIAL },
251 };
252 
253 static const std::vector<struct JsEnumInt> g_MPEG4Profile = {
254     { "MPEG4_PROFILE_ADVANCED_CODING", MPEG4Profile::MPEG4_PROFILE_ADVANCED_CODING },
255     { "MPEG4_PROFILE_ADVANCED_CORE", MPEG4Profile::MPEG4_PROFILE_ADVANCED_CORE },
256     { "MPEG4_PROFILE_ADVANCED_REAL_TIME", MPEG4Profile::MPEG4_PROFILE_ADVANCED_REAL_TIME },
257     { "MPEG4_PROFILE_ADVANCED_SCALABLE", MPEG4Profile::MPEG4_PROFILE_ADVANCED_SCALABLE },
258     { "MPEG4_PROFILE_ADVANCED_SIMPLE", MPEG4Profile::MPEG4_PROFILE_ADVANCED_SIMPLE },
259     { "MPEG4_PROFILE_BASIC_ANIMATED", MPEG4Profile::MPEG4_PROFILE_BASIC_ANIMATED },
260     { "MPEG4_PROFILE_CORE", MPEG4Profile::MPEG4_PROFILE_CORE },
261     { "MPEG4_PROFILE_CORE_SCALABLE", MPEG4Profile::MPEG4_PROFILE_CORE_SCALABLE },
262     { "MPEG4_PROFILE_HYBRID", MPEG4Profile::MPEG4_PROFILE_HYBRID },
263     { "MPEG4_PROFILE_MAIN", MPEG4Profile::MPEG4_PROFILE_MAIN },
264     { "MPEG4_PROFILE_NBIT", MPEG4Profile::MPEG4_PROFILE_NBIT },
265     { "MPEG4_PROFILE_SCALABLE_TEXTURE", MPEG4Profile::MPEG4_PROFILE_SCALABLE_TEXTURE },
266     { "MPEG4_PROFILE_SIMPLE", MPEG4Profile::MPEG4_PROFILE_SIMPLE },
267     { "MPEG4_PROFILE_SIMPLE_FBA", MPEG4Profile::MPEG4_PROFILE_SIMPLE_FBA },
268     { "MPEG4_PROFILE_SIMPLE_FACE", MPEG4Profile::MPEG4_PROFILE_SIMPLE_FACE },
269     { "MPEG4_PROFILE_SIMPLE_SCALABLE", MPEG4Profile::MPEG4_PROFILE_SIMPLE_SCALABLE },
270 };
271 
272 static const std::vector<struct JsEnumInt> g_H263Profile = {
273     { "H263_PROFILE_BACKWARD_COMPATIBLE", H263Profile::H263_PROFILE_BACKWARD_COMPATIBLE },
274     { "H263_PROFILE_BASELINE", H263Profile::H263_PROFILE_BASELINE },
275     { "H263_PROFILE_H320_CODING", H263Profile::H263_PROFILE_H320_CODING },
276     { "H263_PROFILE_HIGH_COMPRESSION", H263Profile::H263_PROFILE_HIGH_COMPRESSION },
277     { "H263_PROFILE_HIGH_LATENCY", H263Profile::H263_PROFILE_HIGH_LATENCY },
278     { "H263_PROFILE_ISW_V2", H263Profile::H263_PROFILE_ISW_V2 },
279     { "H263_PROFILE_ISW_V3", H263Profile::H263_PROFILE_ISW_V3 },
280     { "H263_PROFILE_INTERLACE", H263Profile::H263_PROFILE_INTERLACE },
281     { "H263_PROFILE_INTERNET", H263Profile::H263_PROFILE_INTERNET },
282 };
283 
284 static const std::vector<struct JsEnumInt> g_VP8Profile = {
285     { "VP8_PROFILE_MAIN", VP8Profile::VP8_PROFILE_MAIN },
286 };
287 
288 static const std::vector<struct JsEnumInt> g_VideoScaleType = {
289     { "VIDEO_SCALE_TYPE_FIT", static_cast<int32_t>(Plugins::VideoScaleType::VIDEO_SCALE_TYPE_FIT) },
290     { "VIDEO_SCALE_TYPE_FIT_CROP", static_cast<int32_t>(Plugins::VideoScaleType::VIDEO_SCALE_TYPE_FIT_CROP) },
291 };
292 
293 static const std::vector<struct JsEnumInt> g_stateChangeReason = {
294     { "USER", StateChangeReason::USER },
295     { "BACKGROUND", StateChangeReason::BACKGROUND },
296 };
297 
298 static const std::vector<struct JsEnumString> g_containerFormatType = {
299     { "CFT_MPEG_4", ContainerFormatType::CFT_MPEG_4 },
300     { "CFT_MPEG_4A", ContainerFormatType::CFT_MPEG_4A },
301     { "CFT_MP3", "mp3" },
302     { "CFT_WAV", "wav" },
303 };
304 
305 static const std::vector<struct JsEnumString> g_avMimeTypes = {
306     { "APPLICATION_M3U8", "application/m3u8" },
307 };
308 
309 static const std::vector<struct JsEnumString> g_playbackInfoKey = {
310     { "SERVER_IP_ADDRESS", "server_ip_address" },
311     { "AVG_DOWNLOAD_RATE", "average_download_rate" },
312     { "DOWNLOAD_RATE", "download_rate" },
313     { "IS_DOWNLOADING", "is_downloading" },
314     { "BUFFER_DURATION", "buffer_duration" },
315 };
316 
317 static const std::vector<struct JsEnumString> g_codecMimeType = {
318     { "VIDEO_H263", OHOS::Media::Plugins::MimeType::VIDEO_H263 },
319     { "VIDEO_AVC", OHOS::Media::Plugins::MimeType::VIDEO_AVC },
320     { "VIDEO_MPEG2", OHOS::Media::Plugins::MimeType::VIDEO_MPEG2 },
321     { "VIDEO_HEVC", OHOS::Media::Plugins::MimeType::VIDEO_HEVC },
322     { "VIDEO_MPEG4", OHOS::Media::Plugins::MimeType::VIDEO_MPEG4 },
323     { "VIDEO_VP8", OHOS::Media::Plugins::MimeType::VIDEO_VP8 },
324     { "VIDEO_VP9", OHOS::Media::Plugins::MimeType::VIDEO_VP9 },
325     { "AUDIO_AMR_NB", OHOS::Media::Plugins::MimeType::AUDIO_AMR_NB },
326     { "AUDIO_AMR_WB", OHOS::Media::Plugins::MimeType::AUDIO_AMR_WB },
327     { "AUDIO_MPEG", OHOS::Media::Plugins::MimeType::AUDIO_MPEG },
328     { "AUDIO_AAC", OHOS::Media::Plugins::MimeType::AUDIO_AAC },
329     { "AUDIO_VORBIS", OHOS::Media::Plugins::MimeType::AUDIO_VORBIS },
330     { "AUDIO_OPUS", OHOS::Media::Plugins::MimeType::AUDIO_OPUS },
331     { "AUDIO_FLAC", OHOS::Media::Plugins::MimeType::AUDIO_FLAC },
332     { "AUDIO_RAW", OHOS::Media::Plugins::MimeType::AUDIO_RAW },
333     { "AUDIO_MP3", "audio/mpeg" },
334     { "AUDIO_G711MU", "audio/g711mu" },
335 };
336 
337 static const std::vector<struct JsEnumString> g_mediaDescriptionKey = {
338     { "MD_KEY_TRACK_INDEX", "track_index" },
339     { "MD_KEY_TRACK_TYPE", "track_type" },
340     { "MD_KEY_CODEC_MIME", "codec_mime" },
341     { "MD_KEY_DURATION", "duration" },
342     { "MD_KEY_BITRATE", "bitrate" },
343     { "MD_KEY_MAX_INPUT_SIZE", "max_input_size" },
344     { "MD_KEY_MAX_ENCODER_FPS", "max_encoder_fps" },
345     { "MD_KEY_WIDTH", "width" },
346     { "MD_KEY_HEIGHT", "height" },
347     { "MD_KEY_PIXEL_FORMAT", "pixel_format" },
348     { "MD_KEY_AUDIO_SAMPLE_FORMAT", "audio_sample_format" },
349     { "MD_KEY_FRAME_RATE", "frame_rate" },
350     { "MD_KEY_CAPTURE_RATE", "capture_rate" },
351     { "MD_KEY_I_FRAME_INTERVAL", "i_frame_interval" },
352     { "MD_KEY_REQUEST_I_FRAME", "req_i_frame" },
353     { "MD_KEY_REPEAT_FRAME_AFTER", "repeat_frame_after" },
354     { "MD_KEY_SUSPEND_INPUT_SURFACE", "suspend_input_surface" },
355     { "MD_KEY_VIDEO_ENCODE_BITRATE_MODE", "video_encode_bitrate_mode" },
356     { "MD_KEY_PROFILE", "codec_profile" },
357     { "MD_KEY_QUALITY", "codec_quality" },
358     { "MD_KEY_RECT_TOP", "rect_top" },
359     { "MD_KEY_RECT_BOTTOM", "rect_bottom" },
360     { "MD_KEY_RECT_LEFT", "rect_left" },
361     { "MD_KEY_RECT_RIGHT", "rect_right" },
362     { "MD_KEY_COLOR_STANDARD", "color_standard" },
363     { "MD_KEY_AUD_CHANNEL_COUNT", "channel_count" },
364     { "MD_KEY_AUD_SAMPLE_RATE", "sample_rate" },
365     { "MD_KEY_CUSTOM", "vendor.custom" },
366     { "MD_KEY_LANGUAGE", "language" },
367     { "MD_KEY_AUD_SAMPLE_DEPTH", "sample_depth" },
368     { "MD_KEY_TRACK_NAME", "track_name" },
369     { "MD_KEY_HDR_TYPE", "hdr_type" }
370 };
371 
372 static const std::vector<struct JsEnumInt> g_screenCaptureRecordPreset = {
373     { "SCREEN_RECORD_PRESET_H264_AAC_MP4", AVScreenCaptureRecorderPreset::SCREEN_RECORD_PRESET_H264_AAC_MP4 },
374     { "SCREEN_RECORD_PRESET_H265_AAC_MP4", AVScreenCaptureRecorderPreset::SCREEN_RECORD_PRESET_H265_AAC_MP4 }
375 };
376 
377 static const std::vector<struct JsEnumInt> g_screenCaptureStateCode = {
378     { "SCREENCAPTURE_STATE_STARTED", AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED },
379     { "SCREENCAPTURE_STATE_CANCELED", AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_CANCELED },
380     { "SCREENCAPTURE_STATE_STOPPED_BY_USER", AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STOPPED_BY_USER },
381     { "SCREENCAPTURE_STATE_INTERRUPTED_BY_OTHER", AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_INTERRUPTED_BY_OTHER },
382     { "SCREENCAPTURE_STATE_STOPPED_BY_CALL", AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STOPPED_BY_CALL },
383     { "SCREENCAPTURE_STATE_MIC_UNAVAILABLE", AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_MIC_UNAVAILABLE },
384     { "SCREENCAPTURE_STATE_MIC_MUTED_BY_USER", AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_MIC_MUTED_BY_USER },
385     { "SCREENCAPTURE_STATE_MIC_UNMUTED_BY_USER", AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_MIC_UNMUTED_BY_USER },
386     { "SCREENCAPTURE_STATE_ENTER_PRIVATE_SCENE", AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_ENTER_PRIVATE_SCENE },
387     { "SCREENCAPTURE_STATE_EXIT_PRIVATE_SCENE", AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_EXIT_PRIVATE_SCENE },
388     { "SCREENCAPTURE_STATE_STOPPED_BY_USER_SWITCHES",
389         AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STOPPED_BY_USER_SWITCHES },
390 };
391 
392 static const std::map<std::string_view, const std::vector<struct JsEnumInt>&> g_intEnumClassMap = {
393     { "AVErrorCode", g_AVErrorCode},
394     { "MediaErrorCode", g_mediaErrorCode },
395     { "AVDataSourceError", g_avDataSourceError },
396     { "BufferingInfoType", g_bufferingInfoType },
397     { "AudioEncoder", g_recorderAudioEncoder },
398     { "AudioOutputFormat", g_recorderAudioOutputFormat },
399     { "PlaybackSpeed", g_playbackSpeed },
400     { "AVImageQueryOptions", g_avImageQueryOptions },
401     { "PixelFormat", g_pixelFormat },
402     { "MediaType", g_mediaType },
403     { "VideoRecorderQualityLevel", g_videoRecorderQualityLevel },
404     { "AudioSourceType", g_audioSourceType },
405     { "VideoSourceType", g_videoSourceType },
406     { "FrameFlags", g_frameFlags },
407     { "HdrType", g_hdrType},
408     { "SeekMode", g_seekMode },
409     { "SwitchMode", g_switchMode },
410     { "AVCodecType", g_AVCodecType },
411     { "AACProfile", g_AACProfile },
412     { "VideoEncodeBitrateMode", g_videoEncodeBitrateMode },
413     { "VideoPixelFormat", g_videoPixelFormat },
414     { "AVCProfile", g_AVCProfile },
415     { "HEVCProfile", g_HEVCProfile },
416     { "MPEG2Profile", g_MPEG2Profile },
417     { "MPEG4Profile", g_MPEG4Profile },
418     { "H263Profile", g_H263Profile},
419     { "VP8Profile", g_VP8Profile },
420     { "VideoScaleType", g_VideoScaleType},
421     { "StateChangeReason", g_stateChangeReason},
422     { "AVScreenCaptureRecordPreset", g_screenCaptureRecordPreset},
423     { "AVScreenCaptureStateCode", g_screenCaptureStateCode},
424     { "FileGenerationMode", g_fileGenerationMode},
425     { "MetaSourceType", g_metaSourceType},
426 };
427 
428 static const std::map<std::string_view, const std::vector<struct JsEnumString>&> g_stringEnumClassMap = {
429     { "MediaDescriptionKey", g_mediaDescriptionKey },
430     { "ContainerFormatType", g_containerFormatType },
431     { "CodecMimeType", g_codecMimeType },
432     { "AVMimeTypes", g_avMimeTypes },
433     { "PlaybackInfoKey", g_playbackInfoKey },
434 };
435 
JsEnumIntInit(napi_env env, napi_value exports)436 napi_value MediaEnumNapi::JsEnumIntInit(napi_env env, napi_value exports)
437 {
438     for (auto it = g_intEnumClassMap.begin(); it != g_intEnumClassMap.end(); it++) {
439         auto &enumClassName = it->first;
440         auto &enumItemVec = it->second;
441         int32_t vecSize = enumItemVec.size();
442         std::vector<napi_value> value;
443         value.resize(vecSize);
444         for (int32_t index = 0; index < vecSize; ++index) {
445             napi_create_int32(env, enumItemVec[index].enumInt, &value[index]);
446         }
447 
448         std::vector<napi_property_descriptor> property;
449         property.resize(vecSize);
450         for (int32_t index = 0; index < vecSize; ++index) {
451             property[index] = napi_property_descriptor DECLARE_NAPI_STATIC_PROPERTY(
452                 enumItemVec[index].enumName.data(), value[index]);
453         }
454 
455         auto napiConstructor = [](napi_env env, napi_callback_info info) {
456             napi_value jsThis = nullptr;
457             napi_get_cb_info(env, info, nullptr, nullptr, &jsThis, nullptr);
458             return jsThis;
459         };
460 
461         napi_value result = nullptr;
462         napi_status napiStatus = napi_define_class(env, enumClassName.data(), NAPI_AUTO_LENGTH, napiConstructor,
463             nullptr, property.size(), property.data(), &result);
464         CHECK_AND_RETURN_RET_LOG(napiStatus == napi_ok, nullptr, "Failed to define enum");
465 
466         napiStatus = napi_set_named_property(env, exports, enumClassName.data(), result);
467         CHECK_AND_RETURN_RET_LOG(napiStatus == napi_ok, nullptr, "Failed to set result");
468     }
469     return exports;
470 }
471 
JsEnumStringInit(napi_env env, napi_value exports)472 napi_value MediaEnumNapi::JsEnumStringInit(napi_env env, napi_value exports)
473 {
474     for (auto it = g_stringEnumClassMap.begin(); it != g_stringEnumClassMap.end(); it++) {
475         auto &enumType = it->first;
476         auto &enumValue = it->second;
477         int32_t vecSize = enumValue.size();
478         std::vector<napi_value> value;
479         value.resize(vecSize);
480         for (int32_t index = 0; index < vecSize; ++index) {
481             napi_create_string_utf8(env, enumValue[index].enumString.data(), NAPI_AUTO_LENGTH, &value[index]);
482         }
483 
484         std::vector<napi_property_descriptor> property;
485         property.resize(vecSize);
486         for (int32_t index = 0; index < vecSize; ++index) {
487             property[index] = napi_property_descriptor DECLARE_NAPI_STATIC_PROPERTY(
488                 enumValue[index].enumName.data(), value[index]);
489         }
490 
491         auto constructor = [](napi_env env, napi_callback_info info) {
492             napi_value jsThis = nullptr;
493             napi_get_cb_info(env, info, nullptr, nullptr, &jsThis, nullptr);
494             return jsThis;
495         };
496 
497         napi_value result = nullptr;
498         napi_status status = napi_define_class(env, enumType.data(), NAPI_AUTO_LENGTH, constructor,
499             nullptr, property.size(), property.data(), &result);
500         CHECK_AND_RETURN_RET_LOG(status == napi_ok, nullptr, "Failed to define enum");
501 
502         status = napi_set_named_property(env, exports, enumType.data(), result);
503         CHECK_AND_RETURN_RET_LOG(status == napi_ok, nullptr, "Failed to set result");
504     }
505     return exports;
506 }
507 
Init(napi_env env, napi_value exports)508 napi_value MediaEnumNapi::Init(napi_env env, napi_value exports)
509 {
510     JsEnumIntInit(env, exports);
511     JsEnumStringInit(env, exports);
512     return exports;
513 }
514 } // namespace Media
515 } // namespace OHOS