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
141 struct VVCProfileMapping {
142 CodecVvcProfile omxProfile;
143 VVCProfile innerProfile;
144 };
145 vector<VVCProfileMapping> g_vvcProfileTable = {
146 { CODEC_VVC_PROFILE_MAIN10, VVC_PROFILE_MAIN_10 },
147 { CODEC_VVC_PROFILE_MAIN10_STILL, VVC_PROFILE_MAIN_10_STILL },
148 { CODEC_VVC_PROFILE_MAIN10_444, VVC_PROFILE_MAIN_10_444 },
149 { CODEC_VVC_PROFILE_MAIN10_444_STILL, VVC_PROFILE_MAIN_10_444_STILL },
150 { CODEC_VVC_PROFILE_MULTI_MAIN10, VVC_PROFILE_MULTI_MAIN_10 },
151 { CODEC_VVC_PROFILE_MULTI_MAIN10_444, VVC_PROFILE_MULTI_MAIN_10_444 },
152 { CODEC_VVC_PROFILE_MAIN12, VVC_PROFILE_MAIN_12 },
153 { CODEC_VVC_PROFILE_MAIN12_INTRA, VVC_PROFILE_MAIN_12_INTRA },
154 { CODEC_VVC_PROFILE_MAIN12_STILL, VVC_PROFILE_MAIN_12_STILL },
155 { CODEC_VVC_PROFILE_MAIN12_444, VVC_PROFILE_MAIN_12_444 },
156 { CODEC_VVC_PROFILE_MAIN12_444_INTRA, VVC_PROFILE_MAIN_12_444_INTRA },
157 { CODEC_VVC_PROFILE_MAIN12_444_STILL, VVC_PROFILE_MAIN_12_444_STILL },
158 { CODEC_VVC_PROFILE_MAIN16_444, VVC_PROFILE_MAIN_16_444 },
159 { CODEC_VVC_PROFILE_MAIN16_444_INTRA, VVC_PROFILE_MAIN_16_444_INTRA },
160 { CODEC_VVC_PROFILE_MAIN16_444_STILL, VVC_PROFILE_MAIN_16_444_STILL },
161 };
162
163 struct VVCLevelMapping {
164 CodecVvcLevel omxLevel;
165 VVCLevel innerLevel;
166 };
167 vector<VVCLevelMapping> g_vvcLevelTable = {
168 { CODEC_VVC_MAIN_TIER_LEVEL1, VVC_LEVEL_1 },
169 { CODEC_VVC_HIGH_TIER_LEVEL1, VVC_LEVEL_1 },
170 { CODEC_VVC_MAIN_TIER_LEVEL2, VVC_LEVEL_2 },
171 { CODEC_VVC_HIGH_TIER_LEVEL2, VVC_LEVEL_2 },
172 { CODEC_VVC_MAIN_TIER_LEVEL21, VVC_LEVEL_21 },
173 { CODEC_VVC_HIGH_TIER_LEVEL21, VVC_LEVEL_21 },
174 { CODEC_VVC_MAIN_TIER_LEVEL3, VVC_LEVEL_3 },
175 { CODEC_VVC_HIGH_TIER_LEVEL3, VVC_LEVEL_3 },
176 { CODEC_VVC_MAIN_TIER_LEVEL31, VVC_LEVEL_31 },
177 { CODEC_VVC_HIGH_TIER_LEVEL31, VVC_LEVEL_31 },
178 { CODEC_VVC_MAIN_TIER_LEVEL4, VVC_LEVEL_4 },
179 { CODEC_VVC_HIGH_TIER_LEVEL4, VVC_LEVEL_4 },
180 { CODEC_VVC_MAIN_TIER_LEVEL41, VVC_LEVEL_41 },
181 { CODEC_VVC_HIGH_TIER_LEVEL41, VVC_LEVEL_41 },
182 { CODEC_VVC_MAIN_TIER_LEVEL5, VVC_LEVEL_5 },
183 { CODEC_VVC_HIGH_TIER_LEVEL5, VVC_LEVEL_5 },
184 { CODEC_VVC_MAIN_TIER_LEVEL51, VVC_LEVEL_51 },
185 { CODEC_VVC_HIGH_TIER_LEVEL51, VVC_LEVEL_51 },
186 { CODEC_VVC_MAIN_TIER_LEVEL52, VVC_LEVEL_52 },
187 { CODEC_VVC_HIGH_TIER_LEVEL52, VVC_LEVEL_52 },
188 { CODEC_VVC_MAIN_TIER_LEVEL6, VVC_LEVEL_6 },
189 { CODEC_VVC_HIGH_TIER_LEVEL6, VVC_LEVEL_6 },
190 { CODEC_VVC_MAIN_TIER_LEVEL61, VVC_LEVEL_61 },
191 { CODEC_VVC_HIGH_TIER_LEVEL61, VVC_LEVEL_61 },
192 { CODEC_VVC_MAIN_TIER_LEVEL62, VVC_LEVEL_62 },
193 { CODEC_VVC_HIGH_TIER_LEVEL62, VVC_LEVEL_62 },
194 { CODEC_VVC_MAIN_TIER_LEVEL63, VVC_LEVEL_63 },
195 { CODEC_VVC_HIGH_TIER_LEVEL63, VVC_LEVEL_63 },
196 { CODEC_VVC_MAIN_TIER_LEVEL155, VVC_LEVEL_155 },
197 { CODEC_VVC_HIGH_TIER_LEVEL155, VVC_LEVEL_155 },
198 };
199
200 struct VVCMaxLevelMapping {
201 VVCLevel maxLevel;
202 vector<int32_t> allLevels;
203 };
204
205 vector<VVCMaxLevelMapping> g_vvcMaxLevelTable = {
206 { VVC_LEVEL_1, {VVC_LEVEL_1} },
207 { VVC_LEVEL_2, {VVC_LEVEL_1, VVC_LEVEL_2} },
208 { VVC_LEVEL_21, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21} },
209 { VVC_LEVEL_3, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3} },
210 { VVC_LEVEL_31, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31} },
211 { VVC_LEVEL_4, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4} },
212 { VVC_LEVEL_41, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4, VVC_LEVEL_41} },
213 { VVC_LEVEL_5, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4, VVC_LEVEL_41,
214 VVC_LEVEL_5} },
215 { VVC_LEVEL_51, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4, VVC_LEVEL_41,
216 VVC_LEVEL_5, VVC_LEVEL_51} },
217 { VVC_LEVEL_52, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4, VVC_LEVEL_41,
218 VVC_LEVEL_5, VVC_LEVEL_51, VVC_LEVEL_52} },
219 { VVC_LEVEL_6, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4, VVC_LEVEL_41,
220 VVC_LEVEL_5, VVC_LEVEL_51, VVC_LEVEL_52, VVC_LEVEL_6} },
221 { VVC_LEVEL_61, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4, VVC_LEVEL_41,
222 VVC_LEVEL_5, VVC_LEVEL_51, VVC_LEVEL_52, VVC_LEVEL_6, VVC_LEVEL_61} },
223 { VVC_LEVEL_62, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4, VVC_LEVEL_41,
224 VVC_LEVEL_5, VVC_LEVEL_51, VVC_LEVEL_52, VVC_LEVEL_6, VVC_LEVEL_61, VVC_LEVEL_62} },
225 { VVC_LEVEL_63, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4, VVC_LEVEL_41,
226 VVC_LEVEL_5, VVC_LEVEL_51, VVC_LEVEL_52, VVC_LEVEL_6, VVC_LEVEL_61, VVC_LEVEL_62,
227 VVC_LEVEL_63} },
228 { VVC_LEVEL_155, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4, VVC_LEVEL_41,
229 VVC_LEVEL_5, VVC_LEVEL_51, VVC_LEVEL_52, VVC_LEVEL_6, VVC_LEVEL_61, VVC_LEVEL_62,
230 VVC_LEVEL_63, VVC_LEVEL_155} },
231 };
232
HdiCodecTypeToInnerCodecType(CodecHDI::CodecType type)233 optional<AVCodecType> TypeConverter::HdiCodecTypeToInnerCodecType(CodecHDI::CodecType type)
234 {
235 static const map<CodecType, AVCodecType> table = {
236 {VIDEO_DECODER, AVCODEC_TYPE_VIDEO_DECODER},
237 {VIDEO_ENCODER, AVCODEC_TYPE_VIDEO_ENCODER}
238 };
239 auto it = table.find(type);
240 if (it == table.end()) {
241 LOGW("unknown codecType %d", type);
242 return std::nullopt;
243 }
244 return it->second;
245 }
246
HdiRoleToOmxCodingType(AvCodecRole role)247 std::optional<OMX_VIDEO_CODINGTYPE> TypeConverter::HdiRoleToOmxCodingType(AvCodecRole role)
248 {
249 auto it = find_if(g_protocolTable.begin(), g_protocolTable.end(), [role](const Protocol& p) {
250 return p.hdiRole == role;
251 });
252 if (it != g_protocolTable.end()) {
253 return it->omxCodingType;
254 }
255 LOGW("unknown AvCodecRole %d", role);
256 return nullopt;
257 }
258
HdiRoleToMime(AvCodecRole role)259 string TypeConverter::HdiRoleToMime(AvCodecRole role)
260 {
261 auto it = find_if(g_protocolTable.begin(), g_protocolTable.end(), [role](const Protocol& p) {
262 return p.hdiRole == role;
263 });
264 if (it != g_protocolTable.end()) {
265 return it->mime;
266 }
267 LOGW("unknown AvCodecRole %d", role);
268 return {};
269 }
270
GraphicFmtToFmt(GraphicPixelFormat format)271 std::optional<PixelFmt> TypeConverter::GraphicFmtToFmt(GraphicPixelFormat format)
272 {
273 auto it = find_if(g_pixelFmtTable.begin(), g_pixelFmtTable.end(), [format](const PixelFmt& p) {
274 return p.graphicFmt == format;
275 });
276 if (it != g_pixelFmtTable.end()) {
277 return *it;
278 }
279 LOGW("unknown GraphicPixelFormat %d", format);
280 return nullopt;
281 }
282
InnerFmtToFmt(VideoPixelFormat format)283 std::optional<PixelFmt> TypeConverter::InnerFmtToFmt(VideoPixelFormat format)
284 {
285 auto it = find_if(g_pixelFmtTable.begin(), g_pixelFmtTable.end(), [format](const PixelFmt& p) {
286 return p.innerFmt == format;
287 });
288 if (it != g_pixelFmtTable.end()) {
289 return *it;
290 }
291 LOGW("unknown VideoPixelFormat %d", format);
292 return nullopt;
293 }
294
InnerFmtToDisplayFmt(VideoPixelFormat format)295 std::optional<GraphicPixelFormat> TypeConverter::InnerFmtToDisplayFmt(VideoPixelFormat format)
296 {
297 auto it = find_if(g_pixelFmtTable.begin(), g_pixelFmtTable.end(), [format](const PixelFmt& p) {
298 return p.innerFmt == format;
299 });
300 if (it != g_pixelFmtTable.end()) {
301 return it->graphicFmt;
302 }
303 LOGW("unknown VideoPixelFormat %d", format);
304 return nullopt;
305 }
306
DisplayFmtToInnerFmt(GraphicPixelFormat format)307 std::optional<VideoPixelFormat> TypeConverter::DisplayFmtToInnerFmt(GraphicPixelFormat format)
308 {
309 auto it = find_if(g_pixelFmtTable.begin(), g_pixelFmtTable.end(), [format](const PixelFmt& p) {
310 return p.graphicFmt == format;
311 });
312 if (it != g_pixelFmtTable.end()) {
313 return it->innerFmt;
314 }
315 LOGW("unknown GraphicPixelFormat %d", format);
316 return nullopt;
317 }
318
InnerRotateToDisplayRotate(VideoRotation rotate)319 std::optional<GraphicTransformType> TypeConverter::InnerRotateToDisplayRotate(VideoRotation rotate)
320 {
321 static const map<VideoRotation, GraphicTransformType> table = {
322 { VIDEO_ROTATION_0, GRAPHIC_ROTATE_NONE },
323 { VIDEO_ROTATION_90, GRAPHIC_ROTATE_270 },
324 { VIDEO_ROTATION_180, GRAPHIC_ROTATE_180 },
325 { VIDEO_ROTATION_270, GRAPHIC_ROTATE_90 },
326 };
327 auto it = table.find(rotate);
328 if (it == table.end()) {
329 LOGW("unknown VideoRotation %u", rotate);
330 return std::nullopt;
331 }
332 return it->second;
333 }
334
OmxAvcProfileToInnerProfile(OMX_VIDEO_AVCPROFILETYPE profile)335 std::optional<AVCProfile> TypeConverter::OmxAvcProfileToInnerProfile(OMX_VIDEO_AVCPROFILETYPE profile)
336 {
337 auto it = find_if(g_avcProfileTable.begin(), g_avcProfileTable.end(), [profile](const AVCProfileMapping& p) {
338 return p.omxProfile == profile;
339 });
340 if (it != g_avcProfileTable.end()) {
341 return it->innerProfile;
342 }
343 LOGW("unknown OMX_VIDEO_AVCPROFILETYPE %d", profile);
344 return nullopt;
345 }
346
OmxAvcLevelToInnerLevel(OMX_VIDEO_AVCLEVELTYPE level)347 std::optional<AVCLevel> TypeConverter::OmxAvcLevelToInnerLevel(OMX_VIDEO_AVCLEVELTYPE level)
348 {
349 auto it = find_if(g_avcLevelTable.begin(), g_avcLevelTable.end(), [level](const AVCLevelMapping& p) {
350 return p.omxLevel == level;
351 });
352 if (it != g_avcLevelTable.end()) {
353 return it->innerLevel;
354 }
355 LOGW("unknown OMX_VIDEO_AVCLEVELTYPE %d", level);
356 return nullopt;
357 }
358
OmxHevcProfileToInnerProfile(CodecHevcProfile profile)359 std::optional<HEVCProfile> TypeConverter::OmxHevcProfileToInnerProfile(CodecHevcProfile profile)
360 {
361 auto it = find_if(g_hevcProfileTable.begin(), g_hevcProfileTable.end(), [profile](const HEVCProfileMapping& p) {
362 return p.omxProfile == profile;
363 });
364 if (it != g_hevcProfileTable.end()) {
365 return it->innerProfile;
366 }
367 LOGW("unknown CodecHevcProfile %d", profile);
368 return nullopt;
369 }
370
OmxHevcLevelToInnerLevel(CodecHevcLevel level)371 std::optional<HEVCLevel> TypeConverter::OmxHevcLevelToInnerLevel(CodecHevcLevel level)
372 {
373 auto it = find_if(g_hevcLevelTable.begin(), g_hevcLevelTable.end(), [level](const HEVCLevelMapping& p) {
374 return p.omxLevel == level;
375 });
376 if (it != g_hevcLevelTable.end()) {
377 return it->innerLevel;
378 }
379 LOGW("unknown CodecHevcLevel %d", level);
380 return nullopt;
381 }
382
OmxVvcProfileToInnerProfile(CodecVvcProfile profile)383 std::optional<VVCProfile> TypeConverter::OmxVvcProfileToInnerProfile(CodecVvcProfile profile)
384 {
385 auto it = find_if(g_vvcProfileTable.begin(), g_vvcProfileTable.end(), [profile](const VVCProfileMapping& p) {
386 return p.omxProfile == profile;
387 });
388 if (it != g_vvcProfileTable.end()) {
389 return it->innerProfile;
390 }
391 LOGW("unknown CodecVvcProfile %d", profile);
392 return nullopt;
393 }
394
OmxVvcLevelToInnerLevel(CodecVvcLevel level)395 std::optional<VVCLevel> TypeConverter::OmxVvcLevelToInnerLevel(CodecVvcLevel level)
396 {
397 auto it = find_if(g_vvcLevelTable.begin(), g_vvcLevelTable.end(), [level](const VVCLevelMapping& p) {
398 return p.omxLevel == level;
399 });
400 if (it != g_vvcLevelTable.end()) {
401 return it->innerLevel;
402 }
403 LOGW("unknown CodecVvcLevel %d", level);
404 return nullopt;
405 }
406
InnerAvcProfileToOmxProfile(AVCProfile profile)407 std::optional<OMX_VIDEO_AVCPROFILETYPE> TypeConverter::InnerAvcProfileToOmxProfile(AVCProfile profile)
408 {
409 auto it = find_if(g_avcProfileTable.begin(), g_avcProfileTable.end(), [profile](const AVCProfileMapping& p) {
410 return p.innerProfile == profile;
411 });
412 if (it != g_avcProfileTable.end()) {
413 return it->omxProfile;
414 }
415 LOGW("unknown AVCProfile %d", profile);
416 return nullopt;
417 }
418
InnerHevcProfileToOmxProfile(HEVCProfile profile)419 std::optional<CodecHevcProfile> TypeConverter::InnerHevcProfileToOmxProfile(HEVCProfile profile)
420 {
421 auto it = find_if(g_hevcProfileTable.begin(), g_hevcProfileTable.end(), [profile](const HEVCProfileMapping& p) {
422 return p.innerProfile == profile;
423 });
424 if (it != g_hevcProfileTable.end()) {
425 return it->omxProfile;
426 }
427 LOGW("unknown CodecHevcProfile %d", profile);
428 return nullopt;
429 }
430
InnerVvcProfileToOmxProfile(VVCProfile profile)431 std::optional<CodecVvcProfile> TypeConverter::InnerVvcProfileToOmxProfile(VVCProfile profile)
432 {
433 auto it = find_if(g_vvcProfileTable.begin(), g_vvcProfileTable.end(), [profile](const VVCProfileMapping& p) {
434 return p.innerProfile == profile;
435 });
436 if (it != g_vvcProfileTable.end()) {
437 return it->omxProfile;
438 }
439 LOGW("unknown CodecVvcProfile %d", profile);
440 return nullopt;
441 }
442
InnerVvcMaxLevelToAllLevels(VVCLevel maxLevel)443 std::optional<std::vector<int32_t>> TypeConverter::InnerVvcMaxLevelToAllLevels(VVCLevel maxLevel)
444 {
445 auto it = find_if(g_vvcMaxLevelTable.begin(), g_vvcMaxLevelTable.end(), [maxLevel](const VVCMaxLevelMapping& p) {
446 return p.maxLevel == maxLevel;
447 });
448 if (it != g_vvcMaxLevelTable.end()) {
449 return it->allLevels;
450 }
451 LOGW("unknown VvcMaxLevel %d", maxLevel);
452 return nullopt;
453 }
454
HdiBitrateModeToInnerMode(BitRateMode mode)455 std::optional<VideoEncodeBitrateMode> TypeConverter::HdiBitrateModeToInnerMode(BitRateMode mode)
456 {
457 static const map<BitRateMode, VideoEncodeBitrateMode> table = {
458 {BIT_RATE_MODE_VBR, VBR},
459 {BIT_RATE_MODE_CBR, CBR},
460 {BIT_RATE_MODE_CQ, CQ},
461 };
462 auto it = table.find(mode);
463 if (it == table.end()) {
464 LOGW("unknown BitRateMode %d", mode);
465 return std::nullopt;
466 }
467 return it->second;
468 }
469 }