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