1 /*
2 * Copyright (c) 2023 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 "type_converter.h"
17 #include "hcodec_log.h"
18
19 namespace OHOS::MediaAVCodec {
20 using namespace std;
21 using namespace CodecHDI;
22
23 struct Protocol {
24 OMX_VIDEO_CODINGTYPE omxCodingType;
25 CodecHDI::AvCodecRole hdiRole;
26 string mime;
27 };
28 vector<Protocol> g_protocolTable = {
29 {
30 OMX_VIDEO_CodingAVC,
31 CodecHDI::AvCodecRole::MEDIA_ROLETYPE_VIDEO_AVC,
32 string(CodecMimeType::VIDEO_AVC),
33 },
34 {
35 static_cast<OMX_VIDEO_CODINGTYPE>(CODEC_OMX_VIDEO_CodingHEVC),
36 CodecHDI::AvCodecRole::MEDIA_ROLETYPE_VIDEO_HEVC,
37 string(CodecMimeType::VIDEO_HEVC),
38 },
39 {
40 static_cast<OMX_VIDEO_CODINGTYPE>(CODEC_OMX_VIDEO_CodingVVC),
41 OHOS::HDI::Codec::V3_0::AvCodecRole::MEDIA_ROLETYPE_VIDEO_VVC,
42 string("video/vvc"),
43 },
44 };
45
46 vector<PixelFmt> g_pixelFmtTable = {
47 {GRAPHIC_PIXEL_FMT_YCBCR_420_P, VideoPixelFormat::YUVI420, "I420"},
48 {GRAPHIC_PIXEL_FMT_YCBCR_420_SP, VideoPixelFormat::NV12, "NV12"},
49 {GRAPHIC_PIXEL_FMT_YCRCB_420_SP, VideoPixelFormat::NV21, "NV21"},
50 {GRAPHIC_PIXEL_FMT_RGBA_8888, VideoPixelFormat::RGBA, "RGBA"},
51 {GRAPHIC_PIXEL_FMT_YCBCR_P010, VideoPixelFormat::NV12, "NV12_10bit"},
52 {GRAPHIC_PIXEL_FMT_YCRCB_P010, VideoPixelFormat::NV21, "NV21_10bit"},
53 };
54
55 struct AVCProfileMapping {
56 OMX_VIDEO_AVCPROFILETYPE omxProfile;
57 AVCProfile innerProfile;
58 };
59 vector<AVCProfileMapping> g_avcProfileTable = {
60 { OMX_VIDEO_AVCProfileBaseline, AVC_PROFILE_BASELINE },
61 { OMX_VIDEO_AVCProfileMain, AVC_PROFILE_MAIN },
62 { OMX_VIDEO_AVCProfileExtended, AVC_PROFILE_EXTENDED },
63 { OMX_VIDEO_AVCProfileHigh, AVC_PROFILE_HIGH },
64 { OMX_VIDEO_AVCProfileHigh10, AVC_PROFILE_HIGH_10 },
65 { OMX_VIDEO_AVCProfileHigh422, AVC_PROFILE_HIGH_422 },
66 { OMX_VIDEO_AVCProfileHigh444, AVC_PROFILE_HIGH_444 },
67 };
68
69 struct AVCLevelMapping {
70 OMX_VIDEO_AVCLEVELTYPE omxLevel;
71 AVCLevel innerLevel;
72 };
73 vector<AVCLevelMapping> g_avcLevelTable = {
74 { OMX_VIDEO_AVCLevel1, AVC_LEVEL_1 },
75 { OMX_VIDEO_AVCLevel1b, AVC_LEVEL_1b },
76 { OMX_VIDEO_AVCLevel11, AVC_LEVEL_11 },
77 { OMX_VIDEO_AVCLevel12, AVC_LEVEL_12 },
78 { OMX_VIDEO_AVCLevel13, AVC_LEVEL_13 },
79 { OMX_VIDEO_AVCLevel2, AVC_LEVEL_2 },
80 { OMX_VIDEO_AVCLevel21, AVC_LEVEL_21 },
81 { OMX_VIDEO_AVCLevel22, AVC_LEVEL_22 },
82 { OMX_VIDEO_AVCLevel3, AVC_LEVEL_3 },
83 { OMX_VIDEO_AVCLevel31, AVC_LEVEL_31 },
84 { OMX_VIDEO_AVCLevel32, AVC_LEVEL_32 },
85 { OMX_VIDEO_AVCLevel4, AVC_LEVEL_4 },
86 { OMX_VIDEO_AVCLevel41, AVC_LEVEL_41 },
87 { OMX_VIDEO_AVCLevel42, AVC_LEVEL_42 },
88 { OMX_VIDEO_AVCLevel5, AVC_LEVEL_5 },
89 { OMX_VIDEO_AVCLevel51, AVC_LEVEL_51 },
90 { static_cast<OMX_VIDEO_AVCLEVELTYPE>(OMX_VIDEO_AVC_LEVEL52), AVC_LEVEL_52 },
91 { static_cast<OMX_VIDEO_AVCLEVELTYPE>(OMX_VIDEO_AVC_LEVEL6), AVC_LEVEL_6 },
92 { static_cast<OMX_VIDEO_AVCLEVELTYPE>(OMX_VIDEO_AVC_LEVEL61), AVC_LEVEL_61 },
93 { static_cast<OMX_VIDEO_AVCLEVELTYPE>(OMX_VIDEO_AVC_LEVEL62), AVC_LEVEL_62 },
94 };
95
96 struct HEVCProfileMapping {
97 CodecHevcProfile omxProfile;
98 HEVCProfile innerProfile;
99 };
100 vector<HEVCProfileMapping> g_hevcProfileTable = {
101 { CODEC_HEVC_PROFILE_MAIN, HEVC_PROFILE_MAIN },
102 { CODEC_HEVC_PROFILE_MAIN10, HEVC_PROFILE_MAIN_10 },
103 { CODEC_HEVC_PROFILE_MAIN_STILL, HEVC_PROFILE_MAIN_STILL },
104 { CODEC_HEVC_PROFILE_MAIN10_HDR10, HEVC_PROFILE_MAIN_10_HDR10 },
105 { CODEC_HEVC_PROFILE_MAIN10_HDR10_PLUS, HEVC_PROFILE_MAIN_10_HDR10_PLUS },
106 };
107
108 struct HEVCLevelMapping {
109 CodecHevcLevel omxLevel;
110 HEVCLevel innerLevel;
111 };
112 vector<HEVCLevelMapping> g_hevcLevelTable = {
113 { CODEC_HEVC_MAIN_TIER_LEVEL1, HEVC_LEVEL_1 },
114 { CODEC_HEVC_HIGH_TIER_LEVEL1, HEVC_LEVEL_1 },
115 { CODEC_HEVC_MAIN_TIER_LEVEL2, HEVC_LEVEL_2 },
116 { CODEC_HEVC_HIGH_TIER_LEVEL2, HEVC_LEVEL_2 },
117 { CODEC_HEVC_MAIN_TIER_LEVEL21, HEVC_LEVEL_21 },
118 { CODEC_HEVC_HIGH_TIER_LEVEL21, HEVC_LEVEL_21 },
119 { CODEC_HEVC_MAIN_TIER_LEVEL3, HEVC_LEVEL_3 },
120 { CODEC_HEVC_HIGH_TIER_LEVEL3, HEVC_LEVEL_3 },
121 { CODEC_HEVC_MAIN_TIER_LEVEL31, HEVC_LEVEL_31 },
122 { CODEC_HEVC_HIGH_TIER_LEVEL31, HEVC_LEVEL_31 },
123 { CODEC_HEVC_MAIN_TIER_LEVEL4, HEVC_LEVEL_4 },
124 { CODEC_HEVC_HIGH_TIER_LEVEL4, HEVC_LEVEL_4 },
125 { CODEC_HEVC_MAIN_TIER_LEVEL41, HEVC_LEVEL_41 },
126 { CODEC_HEVC_HIGH_TIER_LEVEL41, HEVC_LEVEL_41 },
127 { CODEC_HEVC_MAIN_TIER_LEVEL5, HEVC_LEVEL_5 },
128 { CODEC_HEVC_HIGH_TIER_LEVEL5, HEVC_LEVEL_5 },
129 { CODEC_HEVC_MAIN_TIER_LEVEL51, HEVC_LEVEL_51 },
130 { CODEC_HEVC_HIGH_TIER_LEVEL51, HEVC_LEVEL_51 },
131 { CODEC_HEVC_MAIN_TIER_LEVEL52, HEVC_LEVEL_52 },
132 { CODEC_HEVC_HIGH_TIER_LEVEL52, HEVC_LEVEL_52 },
133 { CODEC_HEVC_MAIN_TIER_LEVEL6, HEVC_LEVEL_6 },
134 { CODEC_HEVC_HIGH_TIER_LEVEL6, HEVC_LEVEL_6 },
135 { CODEC_HEVC_MAIN_TIER_LEVEL61, HEVC_LEVEL_61 },
136 { CODEC_HEVC_HIGH_TIER_LEVEL61, HEVC_LEVEL_61 },
137 { CODEC_HEVC_MAIN_TIER_LEVEL62, HEVC_LEVEL_62 },
138 { CODEC_HEVC_HIGH_TIER_LEVEL62, HEVC_LEVEL_62 },
139 };
140
HdiCodecTypeToInnerCodecType(CodecHDI::CodecType type)141 optional<AVCodecType> TypeConverter::HdiCodecTypeToInnerCodecType(CodecHDI::CodecType type)
142 {
143 static const map<CodecType, AVCodecType> table = {
144 {VIDEO_DECODER, AVCODEC_TYPE_VIDEO_DECODER},
145 {VIDEO_ENCODER, AVCODEC_TYPE_VIDEO_ENCODER}
146 };
147 auto it = table.find(type);
148 if (it == table.end()) {
149 LOGW("unknown codecType %d", type);
150 return std::nullopt;
151 }
152 return it->second;
153 }
154
HdiRoleToOmxCodingType(AvCodecRole role)155 std::optional<OMX_VIDEO_CODINGTYPE> TypeConverter::HdiRoleToOmxCodingType(AvCodecRole role)
156 {
157 auto it = find_if(g_protocolTable.begin(), g_protocolTable.end(), [role](const Protocol& p) {
158 return p.hdiRole == role;
159 });
160 if (it != g_protocolTable.end()) {
161 return it->omxCodingType;
162 }
163 LOGW("unknown AvCodecRole %d", role);
164 return nullopt;
165 }
166
HdiRoleToMime(AvCodecRole role)167 string TypeConverter::HdiRoleToMime(AvCodecRole role)
168 {
169 auto it = find_if(g_protocolTable.begin(), g_protocolTable.end(), [role](const Protocol& p) {
170 return p.hdiRole == role;
171 });
172 if (it != g_protocolTable.end()) {
173 return it->mime;
174 }
175 LOGW("unknown AvCodecRole %d", role);
176 return {};
177 }
178
GraphicFmtToFmt(GraphicPixelFormat format)179 std::optional<PixelFmt> TypeConverter::GraphicFmtToFmt(GraphicPixelFormat format)
180 {
181 auto it = find_if(g_pixelFmtTable.begin(), g_pixelFmtTable.end(), [format](const PixelFmt& p) {
182 return p.graphicFmt == format;
183 });
184 if (it != g_pixelFmtTable.end()) {
185 return *it;
186 }
187 LOGW("unknown GraphicPixelFormat %d", format);
188 return nullopt;
189 }
190
InnerFmtToFmt(VideoPixelFormat format)191 std::optional<PixelFmt> TypeConverter::InnerFmtToFmt(VideoPixelFormat format)
192 {
193 auto it = find_if(g_pixelFmtTable.begin(), g_pixelFmtTable.end(), [format](const PixelFmt& p) {
194 return p.innerFmt == format;
195 });
196 if (it != g_pixelFmtTable.end()) {
197 return *it;
198 }
199 LOGW("unknown VideoPixelFormat %d", format);
200 return nullopt;
201 }
202
InnerFmtToDisplayFmt(VideoPixelFormat format)203 std::optional<GraphicPixelFormat> TypeConverter::InnerFmtToDisplayFmt(VideoPixelFormat format)
204 {
205 auto it = find_if(g_pixelFmtTable.begin(), g_pixelFmtTable.end(), [format](const PixelFmt& p) {
206 return p.innerFmt == format;
207 });
208 if (it != g_pixelFmtTable.end()) {
209 return it->graphicFmt;
210 }
211 LOGW("unknown VideoPixelFormat %d", format);
212 return nullopt;
213 }
214
DisplayFmtToInnerFmt(GraphicPixelFormat format)215 std::optional<VideoPixelFormat> TypeConverter::DisplayFmtToInnerFmt(GraphicPixelFormat format)
216 {
217 auto it = find_if(g_pixelFmtTable.begin(), g_pixelFmtTable.end(), [format](const PixelFmt& p) {
218 return p.graphicFmt == format;
219 });
220 if (it != g_pixelFmtTable.end()) {
221 return it->innerFmt;
222 }
223 LOGW("unknown GraphicPixelFormat %d", format);
224 return nullopt;
225 }
226
InnerRotateToDisplayRotate(VideoRotation rotate)227 std::optional<GraphicTransformType> TypeConverter::InnerRotateToDisplayRotate(VideoRotation rotate)
228 {
229 static const map<VideoRotation, GraphicTransformType> table = {
230 { VIDEO_ROTATION_0, GRAPHIC_ROTATE_NONE },
231 { VIDEO_ROTATION_90, GRAPHIC_ROTATE_270 },
232 { VIDEO_ROTATION_180, GRAPHIC_ROTATE_180 },
233 { VIDEO_ROTATION_270, GRAPHIC_ROTATE_90 },
234 };
235 auto it = table.find(rotate);
236 if (it == table.end()) {
237 LOGW("unknown VideoRotation %u", rotate);
238 return std::nullopt;
239 }
240 return it->second;
241 }
242
OmxAvcProfileToInnerProfile(OMX_VIDEO_AVCPROFILETYPE profile)243 std::optional<AVCProfile> TypeConverter::OmxAvcProfileToInnerProfile(OMX_VIDEO_AVCPROFILETYPE profile)
244 {
245 auto it = find_if(g_avcProfileTable.begin(), g_avcProfileTable.end(), [profile](const AVCProfileMapping& p) {
246 return p.omxProfile == profile;
247 });
248 if (it != g_avcProfileTable.end()) {
249 return it->innerProfile;
250 }
251 LOGW("unknown OMX_VIDEO_AVCPROFILETYPE %d", profile);
252 return nullopt;
253 }
254
OmxAvcLevelToInnerLevel(OMX_VIDEO_AVCLEVELTYPE level)255 std::optional<AVCLevel> TypeConverter::OmxAvcLevelToInnerLevel(OMX_VIDEO_AVCLEVELTYPE level)
256 {
257 auto it = find_if(g_avcLevelTable.begin(), g_avcLevelTable.end(), [level](const AVCLevelMapping& p) {
258 return p.omxLevel == level;
259 });
260 if (it != g_avcLevelTable.end()) {
261 return it->innerLevel;
262 }
263 LOGW("unknown OMX_VIDEO_AVCLEVELTYPE %d", level);
264 return nullopt;
265 }
266
OmxHevcProfileToInnerProfile(CodecHevcProfile profile)267 std::optional<HEVCProfile> TypeConverter::OmxHevcProfileToInnerProfile(CodecHevcProfile profile)
268 {
269 auto it = find_if(g_hevcProfileTable.begin(), g_hevcProfileTable.end(), [profile](const HEVCProfileMapping& p) {
270 return p.omxProfile == profile;
271 });
272 if (it != g_hevcProfileTable.end()) {
273 return it->innerProfile;
274 }
275 LOGW("unknown CodecHevcProfile %d", profile);
276 return nullopt;
277 }
278
OmxHevcLevelToInnerLevel(CodecHevcLevel level)279 std::optional<HEVCLevel> TypeConverter::OmxHevcLevelToInnerLevel(CodecHevcLevel level)
280 {
281 auto it = find_if(g_hevcLevelTable.begin(), g_hevcLevelTable.end(), [level](const HEVCLevelMapping& p) {
282 return p.omxLevel == level;
283 });
284 if (it != g_hevcLevelTable.end()) {
285 return it->innerLevel;
286 }
287 LOGW("unknown CodecHevcLevel %d", level);
288 return nullopt;
289 }
290
InnerAvcProfileToOmxProfile(AVCProfile profile)291 std::optional<OMX_VIDEO_AVCPROFILETYPE> TypeConverter::InnerAvcProfileToOmxProfile(AVCProfile profile)
292 {
293 auto it = find_if(g_avcProfileTable.begin(), g_avcProfileTable.end(), [profile](const AVCProfileMapping& p) {
294 return p.innerProfile == profile;
295 });
296 if (it != g_avcProfileTable.end()) {
297 return it->omxProfile;
298 }
299 LOGW("unknown AVCProfile %d", profile);
300 return nullopt;
301 }
302
InnerHevcProfileToOmxProfile(HEVCProfile profile)303 std::optional<CodecHevcProfile> TypeConverter::InnerHevcProfileToOmxProfile(HEVCProfile profile)
304 {
305 auto it = find_if(g_hevcProfileTable.begin(), g_hevcProfileTable.end(), [profile](const HEVCProfileMapping& p) {
306 return p.innerProfile == profile;
307 });
308 if (it != g_hevcProfileTable.end()) {
309 return it->omxProfile;
310 }
311 LOGW("unknown CodecHevcProfile %d", profile);
312 return nullopt;
313 }
314
HdiBitrateModeToInnerMode(BitRateMode mode)315 std::optional<VideoEncodeBitrateMode> TypeConverter::HdiBitrateModeToInnerMode(BitRateMode mode)
316 {
317 static const map<BitRateMode, VideoEncodeBitrateMode> table = {
318 {BIT_RATE_MODE_VBR, VBR},
319 {BIT_RATE_MODE_CBR, CBR},
320 {BIT_RATE_MODE_CQ, CQ},
321 };
322 auto it = table.find(mode);
323 if (it == table.end()) {
324 LOGW("unknown BitRateMode %d", mode);
325 return std::nullopt;
326 }
327 return it->second;
328 }
329 }