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