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