1 /*
2 * Copyright (c) 2021-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 "recorder_utils.h"
17 #include "media_errors.h"
18 #include "plugin/common/plugin_audio_tags.h"
19 #include "plugin/common/plugin_video_tags.h"
20
21 namespace OHOS {
22 namespace Media {
23 namespace {
24 const std::pair<ErrorCode, int32_t> g_errorCodePair[] = {
25 {ErrorCode::SUCCESS, MSERR_OK},
26 {ErrorCode::ERROR_UNKNOWN, MSERR_UNKNOWN},
27 {ErrorCode::ERROR_AGAIN, MSERR_UNKNOWN},
28 {ErrorCode::ERROR_UNIMPLEMENTED, MSERR_UNSUPPORT},
29 {ErrorCode::ERROR_INVALID_PARAMETER_VALUE, MSERR_INVALID_VAL},
30 {ErrorCode::ERROR_INVALID_PARAMETER_TYPE, MSERR_INVALID_VAL},
31 {ErrorCode::ERROR_INVALID_OPERATION, MSERR_INVALID_OPERATION},
32 {ErrorCode::ERROR_UNSUPPORTED_FORMAT, MSERR_UNSUPPORT_CONTAINER_TYPE},
33 {ErrorCode::ERROR_NOT_EXISTED, MSERR_OPEN_FILE_FAILED},
34 {ErrorCode::ERROR_TIMED_OUT, MSERR_EXT_TIMEOUT},
35 {ErrorCode::ERROR_NO_MEMORY, MSERR_EXT_NO_MEMORY},
36 {ErrorCode::ERROR_INVALID_STATE, MSERR_INVALID_STATE},
37 };
38 const std::map<OutputFormatType, std::string> g_outputFormatToFormat = {
39 {OutputFormatType::FORMAT_DEFAULT, std::string("audio_%Y%m%d%H%M%S.m4a")},
40 {OutputFormatType::FORMAT_MPEG_4, std::string("video_%Y%m%d%H%M%S.mp4")},
41 {OutputFormatType::FORMAT_M4A, std::string("audio_%Y%m%d%H%M%S.m4a")},
42 };
43 } // namespace
44 namespace Record {
TransErrorCode(ErrorCode errorCode)45 int TransErrorCode(ErrorCode errorCode)
46 {
47 for (const auto& errPair : g_errorCodePair) {
48 if (errPair.first == errorCode) {
49 return errPair.second;
50 }
51 }
52 return MSERR_UNKNOWN;
53 }
TransAudioInputType(OHOS::Media::AudioSourceType sourceType)54 Plugin::SrcInputType TransAudioInputType(OHOS::Media::AudioSourceType sourceType)
55 {
56 const static std::pair<OHOS::Media::AudioSourceType, Plugin::SrcInputType> mapArray[] = {
57 {OHOS::Media::AudioSourceType::AUDIO_MIC, Plugin::SrcInputType::AUD_MIC},
58 {OHOS::Media::AudioSourceType::AUDIO_SOURCE_DEFAULT, Plugin::SrcInputType::AUD_MIC},
59 };
60 for (const auto& item : mapArray) {
61 if (item.first == sourceType) {
62 return item.second;
63 }
64 }
65 return Plugin::SrcInputType::UNKNOWN;
66 }
TransVideoInputType(OHOS::Media::VideoSourceType sourceType)67 Plugin::SrcInputType TransVideoInputType(OHOS::Media::VideoSourceType sourceType)
68 {
69 const static std::pair<OHOS::Media::VideoSourceType, Plugin::SrcInputType> mapArray[] = {
70 {OHOS::Media::VideoSourceType::VIDEO_SOURCE_SURFACE_YUV, Plugin::SrcInputType::VID_SURFACE_YUV},
71 {OHOS::Media::VideoSourceType::VIDEO_SOURCE_SURFACE_ES, Plugin::SrcInputType::VID_SURFACE_ES},
72 };
73 for (const auto& item : mapArray) {
74 if (item.first == sourceType) {
75 return item.second;
76 }
77 }
78 return Plugin::SrcInputType::UNKNOWN;
79 }
TransAudioEncoderFmt(OHOS::Media::AudioCodecFormat aFormat,Plugin::Meta & encoderMeta)80 bool TransAudioEncoderFmt(OHOS::Media::AudioCodecFormat aFormat, Plugin::Meta& encoderMeta)
81 {
82 switch (aFormat) {
83 case OHOS::Media::AudioCodecFormat::AUDIO_DEFAULT:
84 case OHOS::Media::AudioCodecFormat::AAC_LC:
85 encoderMeta.SetString(Plugin::MetaID::MIME, MEDIA_MIME_AUDIO_AAC);
86 encoderMeta.SetData(Plugin::MetaID::AUDIO_AAC_PROFILE, Plugin::AudioAacProfile::LC);
87 return true;
88 default:
89 break;
90 }
91 return false;
92 }
93
TransVideoEncoderFmt(OHOS::Media::VideoCodecFormat vFormat,Plugin::Meta & encoderMeta)94 bool TransVideoEncoderFmt(OHOS::Media::VideoCodecFormat vFormat, Plugin::Meta& encoderMeta)
95 {
96 bool ret = true;
97 switch (vFormat) {
98 case OHOS::Media::VideoCodecFormat::H264:
99 encoderMeta.SetString(Plugin::MetaID::MIME, MEDIA_MIME_VIDEO_H264);
100 encoderMeta.SetData(Plugin::MetaID::VIDEO_H264_PROFILE, Plugin::VideoH264Profile::BASELINE);
101 encoderMeta.SetUint32(Plugin::MetaID::VIDEO_H264_LEVEL, 32); // 32: LEVEL 3.2
102 break;
103 case OHOS::Media::VideoCodecFormat::MPEG4:
104 encoderMeta.SetString(Plugin::MetaID::MIME, MEDIA_MIME_VIDEO_MPEG4);
105 break;
106 default:
107 ret = false;
108 break;
109 }
110 return ret;
111 }
112
GenerateFilePath(const std::string & dirPath,OutputFormatType outputFormatType,std::string & filePath)113 bool GenerateFilePath(const std::string& dirPath, OutputFormatType outputFormatType, std::string& filePath)
114 {
115 filePath = dirPath;
116 if (filePath[filePath.size() - 1] != '/') {
117 filePath += "/";
118 }
119 if (g_outputFormatToFormat.count(outputFormatType) != 0) {
120 char fileName[32] = { 0 }; /// magic number 32
121 auto tm = time(nullptr);
122 strftime(fileName, sizeof(fileName), g_outputFormatToFormat.at(outputFormatType).c_str(), localtime(&tm));
123 filePath += fileName;
124 return true;
125 } else {
126 return false;
127 }
128 }
129 namespace {
130 #define CAST_TO_ASSIGN(type, param, any) \
131 (any) = static_cast<const type&>(param)
CastAudRecorderParam(const RecorderParam & param,Plugin::ValueType & val)132 bool CastAudRecorderParam(const RecorderParam& param, Plugin::ValueType& val)
133 {
134 auto ret = true;
135 switch (param.type) {
136 case RecorderPublicParamType::AUD_SAMPLERATE:
137 CAST_TO_ASSIGN(AudSampleRate, param, val);
138 break;
139 case RecorderPublicParamType::AUD_CHANNEL:
140 CAST_TO_ASSIGN(AudChannel, param, val);
141 break;
142 case RecorderPublicParamType::AUD_BITRATE:
143 CAST_TO_ASSIGN(AudBitRate, param, val);
144 break;
145 case RecorderPublicParamType::AUD_ENC_FMT:
146 CAST_TO_ASSIGN(AudEnc, param, val);
147 break;
148 default:
149 ret = false;
150 break;
151 }
152 return ret;
153 }
CastVidRecorderParam(const RecorderParam & param,Plugin::ValueType & val)154 bool CastVidRecorderParam(const RecorderParam& param, Plugin::ValueType& val)
155 {
156 auto ret = true;
157 switch (param.type) {
158 case RecorderPublicParamType::VID_CAPTURERATE:
159 CAST_TO_ASSIGN(CaptureRate, param, val);
160 break;
161 case RecorderPublicParamType::VID_RECTANGLE:
162 CAST_TO_ASSIGN(VidRectangle, param, val);
163 break;
164 case RecorderPublicParamType::VID_BITRATE:
165 CAST_TO_ASSIGN(VidBitRate, param, val);
166 break;
167 case RecorderPublicParamType::VID_FRAMERATE:
168 CAST_TO_ASSIGN(VidFrameRate, param, val);
169 break;
170 case RecorderPublicParamType::VID_ENC_FMT:
171 CAST_TO_ASSIGN(VidEnc, param, val);
172 break;
173 default:
174 ret = false;
175 break;
176 }
177 return ret;
178 }
179
CastDummyRecorderParam(const RecorderParam & param,Plugin::ValueType & val)180 bool CastDummyRecorderParam(const RecorderParam& param, Plugin::ValueType& val)
181 {
182 auto ret = true;
183 switch (param.type) {
184 case RecorderPublicParamType::OUT_PATH:
185 CAST_TO_ASSIGN(OutFilePath, param, val);
186 break;
187 case RecorderPublicParamType::OUT_FD:
188 CAST_TO_ASSIGN(OutFd, param, val);
189 break;
190 case RecorderPublicParamType::VID_ORIENTATION_HINT:
191 CAST_TO_ASSIGN(RotationAngle, param, val);
192 break;
193 case RecorderPublicParamType::GEO_LOCATION:
194 CAST_TO_ASSIGN(GeoLocation, param, val);
195 break;
196 case RecorderPublicParamType::MAX_DURATION:
197 CAST_TO_ASSIGN(MaxDuration, param, val);
198 break;
199 case RecorderPublicParamType::MAX_SIZE:
200 CAST_TO_ASSIGN(MaxFileSize, param, val);
201 break;
202 default:
203 ret = false;
204 break;
205 }
206 return ret;
207 }
208 #undef CAST_TO_ASSIGN
209 }
CastRecorderParam(int32_t sourceId,const RecorderParam & param,HstRecParam & out)210 bool CastRecorderParam(int32_t sourceId, const RecorderParam& param, HstRecParam& out)
211 {
212 out.srcId = sourceId;
213 out.stdParamType = static_cast<RecorderPublicParamType>(param.type);
214 if (param.IsAudioParam()) {
215 return CastAudRecorderParam(param, out.val);
216 } else if (param.IsVideoParam()) {
217 return CastVidRecorderParam(param, out.val);
218 } else {
219 return CastDummyRecorderParam(param, out.val);
220 }
221 }
222 } // namespace Record
223 } // namespace Media
224 } // namespace OHOS