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