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::V4_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 {GRAPHIC_PIXEL_FMT_RGBA_1010102, VideoPixelFormat::RGBA1010102, "RGBA1010102"},
54 };
55
56 struct AVCProfileMapping {
57 OMX_VIDEO_AVCPROFILETYPE omxProfile;
58 AVCProfile innerProfile;
59 };
60 vector<AVCProfileMapping> g_avcProfileTable = {
61 { OMX_VIDEO_AVCProfileBaseline, AVC_PROFILE_BASELINE },
62 { OMX_VIDEO_AVCProfileMain, AVC_PROFILE_MAIN },
63 { OMX_VIDEO_AVCProfileExtended, AVC_PROFILE_EXTENDED },
64 { OMX_VIDEO_AVCProfileHigh, AVC_PROFILE_HIGH },
65 { OMX_VIDEO_AVCProfileHigh10, AVC_PROFILE_HIGH_10 },
66 { OMX_VIDEO_AVCProfileHigh422, AVC_PROFILE_HIGH_422 },
67 { OMX_VIDEO_AVCProfileHigh444, AVC_PROFILE_HIGH_444 },
68 };
69
70 struct AVCLevelMapping {
71 OMX_VIDEO_AVCLEVELTYPE omxLevel;
72 AVCLevel innerLevel;
73 };
74 vector<AVCLevelMapping> g_avcLevelTable = {
75 { OMX_VIDEO_AVCLevel1, AVC_LEVEL_1 },
76 { OMX_VIDEO_AVCLevel1b, AVC_LEVEL_1b },
77 { OMX_VIDEO_AVCLevel11, AVC_LEVEL_11 },
78 { OMX_VIDEO_AVCLevel12, AVC_LEVEL_12 },
79 { OMX_VIDEO_AVCLevel13, AVC_LEVEL_13 },
80 { OMX_VIDEO_AVCLevel2, AVC_LEVEL_2 },
81 { OMX_VIDEO_AVCLevel21, AVC_LEVEL_21 },
82 { OMX_VIDEO_AVCLevel22, AVC_LEVEL_22 },
83 { OMX_VIDEO_AVCLevel3, AVC_LEVEL_3 },
84 { OMX_VIDEO_AVCLevel31, AVC_LEVEL_31 },
85 { OMX_VIDEO_AVCLevel32, AVC_LEVEL_32 },
86 { OMX_VIDEO_AVCLevel4, AVC_LEVEL_4 },
87 { OMX_VIDEO_AVCLevel41, AVC_LEVEL_41 },
88 { OMX_VIDEO_AVCLevel42, AVC_LEVEL_42 },
89 { OMX_VIDEO_AVCLevel5, AVC_LEVEL_5 },
90 { OMX_VIDEO_AVCLevel51, AVC_LEVEL_51 },
91 { static_cast<OMX_VIDEO_AVCLEVELTYPE>(OMX_VIDEO_AVC_LEVEL52), AVC_LEVEL_52 },
92 { static_cast<OMX_VIDEO_AVCLEVELTYPE>(OMX_VIDEO_AVC_LEVEL6), AVC_LEVEL_6 },
93 { static_cast<OMX_VIDEO_AVCLEVELTYPE>(OMX_VIDEO_AVC_LEVEL61), AVC_LEVEL_61 },
94 { static_cast<OMX_VIDEO_AVCLEVELTYPE>(OMX_VIDEO_AVC_LEVEL62), AVC_LEVEL_62 },
95 };
96
97 struct HEVCProfileMapping {
98 CodecHevcProfile omxProfile;
99 HEVCProfile innerProfile;
100 };
101 vector<HEVCProfileMapping> g_hevcProfileTable = {
102 { CODEC_HEVC_PROFILE_MAIN, HEVC_PROFILE_MAIN },
103 { CODEC_HEVC_PROFILE_MAIN10, HEVC_PROFILE_MAIN_10 },
104 { CODEC_HEVC_PROFILE_MAIN_STILL, HEVC_PROFILE_MAIN_STILL },
105 { CODEC_HEVC_PROFILE_MAIN10_HDR10, HEVC_PROFILE_MAIN_10_HDR10 },
106 { CODEC_HEVC_PROFILE_MAIN10_HDR10_PLUS, HEVC_PROFILE_MAIN_10_HDR10_PLUS },
107 };
108
109 struct HEVCLevelMapping {
110 CodecHevcLevel omxLevel;
111 HEVCLevel innerLevel;
112 };
113 vector<HEVCLevelMapping> g_hevcLevelTable = {
114 { CODEC_HEVC_MAIN_TIER_LEVEL1, HEVC_LEVEL_1 },
115 { CODEC_HEVC_HIGH_TIER_LEVEL1, HEVC_LEVEL_1 },
116 { CODEC_HEVC_MAIN_TIER_LEVEL2, HEVC_LEVEL_2 },
117 { CODEC_HEVC_HIGH_TIER_LEVEL2, HEVC_LEVEL_2 },
118 { CODEC_HEVC_MAIN_TIER_LEVEL21, HEVC_LEVEL_21 },
119 { CODEC_HEVC_HIGH_TIER_LEVEL21, HEVC_LEVEL_21 },
120 { CODEC_HEVC_MAIN_TIER_LEVEL3, HEVC_LEVEL_3 },
121 { CODEC_HEVC_HIGH_TIER_LEVEL3, HEVC_LEVEL_3 },
122 { CODEC_HEVC_MAIN_TIER_LEVEL31, HEVC_LEVEL_31 },
123 { CODEC_HEVC_HIGH_TIER_LEVEL31, HEVC_LEVEL_31 },
124 { CODEC_HEVC_MAIN_TIER_LEVEL4, HEVC_LEVEL_4 },
125 { CODEC_HEVC_HIGH_TIER_LEVEL4, HEVC_LEVEL_4 },
126 { CODEC_HEVC_MAIN_TIER_LEVEL41, HEVC_LEVEL_41 },
127 { CODEC_HEVC_HIGH_TIER_LEVEL41, HEVC_LEVEL_41 },
128 { CODEC_HEVC_MAIN_TIER_LEVEL5, HEVC_LEVEL_5 },
129 { CODEC_HEVC_HIGH_TIER_LEVEL5, HEVC_LEVEL_5 },
130 { CODEC_HEVC_MAIN_TIER_LEVEL51, HEVC_LEVEL_51 },
131 { CODEC_HEVC_HIGH_TIER_LEVEL51, HEVC_LEVEL_51 },
132 { CODEC_HEVC_MAIN_TIER_LEVEL52, HEVC_LEVEL_52 },
133 { CODEC_HEVC_HIGH_TIER_LEVEL52, HEVC_LEVEL_52 },
134 { CODEC_HEVC_MAIN_TIER_LEVEL6, HEVC_LEVEL_6 },
135 { CODEC_HEVC_HIGH_TIER_LEVEL6, HEVC_LEVEL_6 },
136 { CODEC_HEVC_MAIN_TIER_LEVEL61, HEVC_LEVEL_61 },
137 { CODEC_HEVC_HIGH_TIER_LEVEL61, HEVC_LEVEL_61 },
138 { CODEC_HEVC_MAIN_TIER_LEVEL62, HEVC_LEVEL_62 },
139 { CODEC_HEVC_HIGH_TIER_LEVEL62, HEVC_LEVEL_62 },
140 };
141
142 struct VVCProfileMapping {
143 CodecVvcProfile omxProfile;
144 VVCProfile innerProfile;
145 };
146 vector<VVCProfileMapping> g_vvcProfileTable = {
147 { CODEC_VVC_PROFILE_MAIN10, VVC_PROFILE_MAIN_10 },
148 { CODEC_VVC_PROFILE_MAIN10_STILL, VVC_PROFILE_MAIN_10_STILL },
149 { CODEC_VVC_PROFILE_MAIN10_444, VVC_PROFILE_MAIN_10_444 },
150 { CODEC_VVC_PROFILE_MAIN10_444_STILL, VVC_PROFILE_MAIN_10_444_STILL },
151 { CODEC_VVC_PROFILE_MULTI_MAIN10, VVC_PROFILE_MULTI_MAIN_10 },
152 { CODEC_VVC_PROFILE_MULTI_MAIN10_444, VVC_PROFILE_MULTI_MAIN_10_444 },
153 { CODEC_VVC_PROFILE_MAIN12, VVC_PROFILE_MAIN_12 },
154 { CODEC_VVC_PROFILE_MAIN12_INTRA, VVC_PROFILE_MAIN_12_INTRA },
155 { CODEC_VVC_PROFILE_MAIN12_STILL, VVC_PROFILE_MAIN_12_STILL },
156 { CODEC_VVC_PROFILE_MAIN12_444, VVC_PROFILE_MAIN_12_444 },
157 { CODEC_VVC_PROFILE_MAIN12_444_INTRA, VVC_PROFILE_MAIN_12_444_INTRA },
158 { CODEC_VVC_PROFILE_MAIN12_444_STILL, VVC_PROFILE_MAIN_12_444_STILL },
159 { CODEC_VVC_PROFILE_MAIN16_444, VVC_PROFILE_MAIN_16_444 },
160 { CODEC_VVC_PROFILE_MAIN16_444_INTRA, VVC_PROFILE_MAIN_16_444_INTRA },
161 { CODEC_VVC_PROFILE_MAIN16_444_STILL, VVC_PROFILE_MAIN_16_444_STILL },
162 };
163
164 struct VVCLevelMapping {
165 CodecVvcLevel omxLevel;
166 VVCLevel innerLevel;
167 };
168 vector<VVCLevelMapping> g_vvcLevelTable = {
169 { CODEC_VVC_MAIN_TIER_LEVEL1, VVC_LEVEL_1 },
170 { CODEC_VVC_HIGH_TIER_LEVEL1, VVC_LEVEL_1 },
171 { CODEC_VVC_MAIN_TIER_LEVEL2, VVC_LEVEL_2 },
172 { CODEC_VVC_HIGH_TIER_LEVEL2, VVC_LEVEL_2 },
173 { CODEC_VVC_MAIN_TIER_LEVEL21, VVC_LEVEL_21 },
174 { CODEC_VVC_HIGH_TIER_LEVEL21, VVC_LEVEL_21 },
175 { CODEC_VVC_MAIN_TIER_LEVEL3, VVC_LEVEL_3 },
176 { CODEC_VVC_HIGH_TIER_LEVEL3, VVC_LEVEL_3 },
177 { CODEC_VVC_MAIN_TIER_LEVEL31, VVC_LEVEL_31 },
178 { CODEC_VVC_HIGH_TIER_LEVEL31, VVC_LEVEL_31 },
179 { CODEC_VVC_MAIN_TIER_LEVEL4, VVC_LEVEL_4 },
180 { CODEC_VVC_HIGH_TIER_LEVEL4, VVC_LEVEL_4 },
181 { CODEC_VVC_MAIN_TIER_LEVEL41, VVC_LEVEL_41 },
182 { CODEC_VVC_HIGH_TIER_LEVEL41, VVC_LEVEL_41 },
183 { CODEC_VVC_MAIN_TIER_LEVEL5, VVC_LEVEL_5 },
184 { CODEC_VVC_HIGH_TIER_LEVEL5, VVC_LEVEL_5 },
185 { CODEC_VVC_MAIN_TIER_LEVEL51, VVC_LEVEL_51 },
186 { CODEC_VVC_HIGH_TIER_LEVEL51, VVC_LEVEL_51 },
187 { CODEC_VVC_MAIN_TIER_LEVEL52, VVC_LEVEL_52 },
188 { CODEC_VVC_HIGH_TIER_LEVEL52, VVC_LEVEL_52 },
189 { CODEC_VVC_MAIN_TIER_LEVEL6, VVC_LEVEL_6 },
190 { CODEC_VVC_HIGH_TIER_LEVEL6, VVC_LEVEL_6 },
191 { CODEC_VVC_MAIN_TIER_LEVEL61, VVC_LEVEL_61 },
192 { CODEC_VVC_HIGH_TIER_LEVEL61, VVC_LEVEL_61 },
193 { CODEC_VVC_MAIN_TIER_LEVEL62, VVC_LEVEL_62 },
194 { CODEC_VVC_HIGH_TIER_LEVEL62, VVC_LEVEL_62 },
195 { CODEC_VVC_MAIN_TIER_LEVEL63, VVC_LEVEL_63 },
196 { CODEC_VVC_HIGH_TIER_LEVEL63, VVC_LEVEL_63 },
197 { CODEC_VVC_MAIN_TIER_LEVEL155, VVC_LEVEL_155 },
198 { CODEC_VVC_HIGH_TIER_LEVEL155, VVC_LEVEL_155 },
199 };
200
201 struct VVCMaxLevelMapping {
202 VVCLevel maxLevel;
203 vector<int32_t> allLevels;
204 };
205
206 vector<VVCMaxLevelMapping> g_vvcMaxLevelTable = {
207 { VVC_LEVEL_1, {VVC_LEVEL_1} },
208 { VVC_LEVEL_2, {VVC_LEVEL_1, VVC_LEVEL_2} },
209 { VVC_LEVEL_21, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21} },
210 { VVC_LEVEL_3, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3} },
211 { VVC_LEVEL_31, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31} },
212 { VVC_LEVEL_4, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4} },
213 { VVC_LEVEL_41, {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, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4, VVC_LEVEL_41,
215 VVC_LEVEL_5} },
216 { VVC_LEVEL_51, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4, VVC_LEVEL_41,
217 VVC_LEVEL_5, VVC_LEVEL_51} },
218 { VVC_LEVEL_52, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4, VVC_LEVEL_41,
219 VVC_LEVEL_5, VVC_LEVEL_51, VVC_LEVEL_52} },
220 { VVC_LEVEL_6, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4, VVC_LEVEL_41,
221 VVC_LEVEL_5, VVC_LEVEL_51, VVC_LEVEL_52, VVC_LEVEL_6} },
222 { VVC_LEVEL_61, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4, VVC_LEVEL_41,
223 VVC_LEVEL_5, VVC_LEVEL_51, VVC_LEVEL_52, VVC_LEVEL_6, VVC_LEVEL_61} },
224 { VVC_LEVEL_62, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4, VVC_LEVEL_41,
225 VVC_LEVEL_5, VVC_LEVEL_51, VVC_LEVEL_52, VVC_LEVEL_6, VVC_LEVEL_61, VVC_LEVEL_62} },
226 { VVC_LEVEL_63, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4, VVC_LEVEL_41,
227 VVC_LEVEL_5, VVC_LEVEL_51, VVC_LEVEL_52, VVC_LEVEL_6, VVC_LEVEL_61, VVC_LEVEL_62,
228 VVC_LEVEL_63} },
229 { VVC_LEVEL_155, {VVC_LEVEL_1, VVC_LEVEL_2, VVC_LEVEL_21, VVC_LEVEL_3, VVC_LEVEL_31, VVC_LEVEL_4, VVC_LEVEL_41,
230 VVC_LEVEL_5, VVC_LEVEL_51, VVC_LEVEL_52, VVC_LEVEL_6, VVC_LEVEL_61, VVC_LEVEL_62,
231 VVC_LEVEL_63, VVC_LEVEL_155} },
232 };
233
234 struct BitrateModeMapping {
235 VideoEncodeBitrateMode innerMode;
236 OMX_VIDEO_CONTROLRATETYPE omxMode;
237 };
238 vector<BitrateModeMapping> g_bitrateModeTable {
239 {CBR, OMX_Video_ControlRateConstant},
240 {VBR, OMX_Video_ControlRateVariable},
241 {CBR_VIDEOCALL, static_cast<OMX_VIDEO_CONTROLRATETYPE>(OMX_Video_ControlRateConstantWithRlambda)},
242 {CQ, static_cast<OMX_VIDEO_CONTROLRATETYPE>(OMX_Video_ControlRateConstantWithCQ)},
243 {SQR, static_cast<OMX_VIDEO_CONTROLRATETYPE>(OMX_Video_ControlRateConstantWithSQR)},
244 {CRF, static_cast<OMX_VIDEO_CONTROLRATETYPE>(OMX_Video_ControlRateConstantWithCRF)},
245 };
246
HdiCodecTypeToInnerCodecType(CodecHDI::CodecType type)247 optional<AVCodecType> TypeConverter::HdiCodecTypeToInnerCodecType(CodecHDI::CodecType type)
248 {
249 static const map<CodecType, AVCodecType> table = {
250 {VIDEO_DECODER, AVCODEC_TYPE_VIDEO_DECODER},
251 {VIDEO_ENCODER, AVCODEC_TYPE_VIDEO_ENCODER}
252 };
253 auto it = table.find(type);
254 if (it == table.end()) {
255 LOGW("unknown codecType %d", type);
256 return std::nullopt;
257 }
258 return it->second;
259 }
260
HdiRoleToOmxCodingType(AvCodecRole role)261 std::optional<OMX_VIDEO_CODINGTYPE> TypeConverter::HdiRoleToOmxCodingType(AvCodecRole role)
262 {
263 auto it = find_if(g_protocolTable.begin(), g_protocolTable.end(), [role](const Protocol& p) {
264 return p.hdiRole == role;
265 });
266 if (it != g_protocolTable.end()) {
267 return it->omxCodingType;
268 }
269 LOGW("unknown AvCodecRole %d", role);
270 return nullopt;
271 }
272
HdiRoleToMime(AvCodecRole role)273 string TypeConverter::HdiRoleToMime(AvCodecRole role)
274 {
275 auto it = find_if(g_protocolTable.begin(), g_protocolTable.end(), [role](const Protocol& p) {
276 return p.hdiRole == role;
277 });
278 if (it != g_protocolTable.end()) {
279 return it->mime;
280 }
281 LOGW("unknown AvCodecRole %d", role);
282 return {};
283 }
284
GraphicFmtToFmt(GraphicPixelFormat format)285 std::optional<PixelFmt> TypeConverter::GraphicFmtToFmt(GraphicPixelFormat format)
286 {
287 auto it = find_if(g_pixelFmtTable.begin(), g_pixelFmtTable.end(), [format](const PixelFmt& p) {
288 return p.graphicFmt == format;
289 });
290 if (it != g_pixelFmtTable.end()) {
291 return *it;
292 }
293 LOGW("unknown GraphicPixelFormat %d", format);
294 return nullopt;
295 }
296
InnerFmtToFmt(VideoPixelFormat format)297 std::optional<PixelFmt> TypeConverter::InnerFmtToFmt(VideoPixelFormat format)
298 {
299 auto it = find_if(g_pixelFmtTable.begin(), g_pixelFmtTable.end(), [format](const PixelFmt& p) {
300 return p.innerFmt == format;
301 });
302 if (it != g_pixelFmtTable.end()) {
303 return *it;
304 }
305 LOGW("unknown VideoPixelFormat %d", format);
306 return nullopt;
307 }
308
DisplayFmtToInnerFmt(GraphicPixelFormat format)309 std::optional<VideoPixelFormat> TypeConverter::DisplayFmtToInnerFmt(GraphicPixelFormat format)
310 {
311 auto it = find_if(g_pixelFmtTable.begin(), g_pixelFmtTable.end(), [format](const PixelFmt& p) {
312 return p.graphicFmt == format;
313 });
314 if (it != g_pixelFmtTable.end()) {
315 return it->innerFmt;
316 }
317 LOGW("unknown GraphicPixelFormat %d", format);
318 return nullopt;
319 }
320
InnerRotateToDisplayRotate(VideoRotation rotate)321 std::optional<GraphicTransformType> TypeConverter::InnerRotateToDisplayRotate(VideoRotation rotate)
322 {
323 static const map<VideoRotation, GraphicTransformType> table = {
324 { VIDEO_ROTATION_0, GRAPHIC_ROTATE_NONE },
325 { VIDEO_ROTATION_90, GRAPHIC_ROTATE_270 },
326 { VIDEO_ROTATION_180, GRAPHIC_ROTATE_180 },
327 { VIDEO_ROTATION_270, GRAPHIC_ROTATE_90 },
328 };
329 auto it = table.find(rotate);
330 if (it == table.end()) {
331 LOGW("unknown VideoRotation %u", rotate);
332 return std::nullopt;
333 }
334 return it->second;
335 }
336
OmxAvcProfileToInnerProfile(OMX_VIDEO_AVCPROFILETYPE profile)337 std::optional<AVCProfile> TypeConverter::OmxAvcProfileToInnerProfile(OMX_VIDEO_AVCPROFILETYPE profile)
338 {
339 auto it = find_if(g_avcProfileTable.begin(), g_avcProfileTable.end(), [profile](const AVCProfileMapping& p) {
340 return p.omxProfile == profile;
341 });
342 if (it != g_avcProfileTable.end()) {
343 return it->innerProfile;
344 }
345 LOGW("unknown OMX_VIDEO_AVCPROFILETYPE %d", profile);
346 return nullopt;
347 }
348
OmxAvcLevelToInnerLevel(OMX_VIDEO_AVCLEVELTYPE level)349 std::optional<AVCLevel> TypeConverter::OmxAvcLevelToInnerLevel(OMX_VIDEO_AVCLEVELTYPE level)
350 {
351 auto it = find_if(g_avcLevelTable.begin(), g_avcLevelTable.end(), [level](const AVCLevelMapping& p) {
352 return p.omxLevel == level;
353 });
354 if (it != g_avcLevelTable.end()) {
355 return it->innerLevel;
356 }
357 LOGW("unknown OMX_VIDEO_AVCLEVELTYPE %d", level);
358 return nullopt;
359 }
360
OmxHevcProfileToInnerProfile(CodecHevcProfile profile)361 std::optional<HEVCProfile> TypeConverter::OmxHevcProfileToInnerProfile(CodecHevcProfile profile)
362 {
363 auto it = find_if(g_hevcProfileTable.begin(), g_hevcProfileTable.end(), [profile](const HEVCProfileMapping& p) {
364 return p.omxProfile == profile;
365 });
366 if (it != g_hevcProfileTable.end()) {
367 return it->innerProfile;
368 }
369 LOGW("unknown CodecHevcProfile %d", profile);
370 return nullopt;
371 }
372
OmxHevcLevelToInnerLevel(CodecHevcLevel level)373 std::optional<HEVCLevel> TypeConverter::OmxHevcLevelToInnerLevel(CodecHevcLevel level)
374 {
375 auto it = find_if(g_hevcLevelTable.begin(), g_hevcLevelTable.end(), [level](const HEVCLevelMapping& p) {
376 return p.omxLevel == level;
377 });
378 if (it != g_hevcLevelTable.end()) {
379 return it->innerLevel;
380 }
381 LOGW("unknown CodecHevcLevel %d", level);
382 return nullopt;
383 }
384
OmxVvcProfileToInnerProfile(CodecVvcProfile profile)385 std::optional<VVCProfile> TypeConverter::OmxVvcProfileToInnerProfile(CodecVvcProfile profile)
386 {
387 auto it = find_if(g_vvcProfileTable.begin(), g_vvcProfileTable.end(), [profile](const VVCProfileMapping& p) {
388 return p.omxProfile == profile;
389 });
390 if (it != g_vvcProfileTable.end()) {
391 return it->innerProfile;
392 }
393 LOGW("unknown CodecVvcProfile %d", profile);
394 return nullopt;
395 }
396
OmxVvcLevelToInnerLevel(CodecVvcLevel level)397 std::optional<VVCLevel> TypeConverter::OmxVvcLevelToInnerLevel(CodecVvcLevel level)
398 {
399 auto it = find_if(g_vvcLevelTable.begin(), g_vvcLevelTable.end(), [level](const VVCLevelMapping& p) {
400 return p.omxLevel == level;
401 });
402 if (it != g_vvcLevelTable.end()) {
403 return it->innerLevel;
404 }
405 LOGW("unknown CodecVvcLevel %d", level);
406 return nullopt;
407 }
408
InnerAvcProfileToOmxProfile(AVCProfile profile)409 std::optional<OMX_VIDEO_AVCPROFILETYPE> TypeConverter::InnerAvcProfileToOmxProfile(AVCProfile profile)
410 {
411 auto it = find_if(g_avcProfileTable.begin(), g_avcProfileTable.end(), [profile](const AVCProfileMapping& p) {
412 return p.innerProfile == profile;
413 });
414 if (it != g_avcProfileTable.end()) {
415 return it->omxProfile;
416 }
417 LOGW("unknown AVCProfile %d", profile);
418 return nullopt;
419 }
420
InnerHevcProfileToOmxProfile(HEVCProfile profile)421 std::optional<CodecHevcProfile> TypeConverter::InnerHevcProfileToOmxProfile(HEVCProfile profile)
422 {
423 auto it = find_if(g_hevcProfileTable.begin(), g_hevcProfileTable.end(), [profile](const HEVCProfileMapping& p) {
424 return p.innerProfile == profile;
425 });
426 if (it != g_hevcProfileTable.end()) {
427 return it->omxProfile;
428 }
429 LOGW("unknown CodecHevcProfile %d", profile);
430 return nullopt;
431 }
432
InnerVvcProfileToOmxProfile(VVCProfile profile)433 std::optional<CodecVvcProfile> TypeConverter::InnerVvcProfileToOmxProfile(VVCProfile profile)
434 {
435 auto it = find_if(g_vvcProfileTable.begin(), g_vvcProfileTable.end(), [profile](const VVCProfileMapping& p) {
436 return p.innerProfile == profile;
437 });
438 if (it != g_vvcProfileTable.end()) {
439 return it->omxProfile;
440 }
441 LOGW("unknown CodecVvcProfile %d", profile);
442 return nullopt;
443 }
444
InnerVvcMaxLevelToAllLevels(VVCLevel maxLevel)445 std::optional<std::vector<int32_t>> TypeConverter::InnerVvcMaxLevelToAllLevels(VVCLevel maxLevel)
446 {
447 auto it = find_if(g_vvcMaxLevelTable.begin(), g_vvcMaxLevelTable.end(), [maxLevel](const VVCMaxLevelMapping& p) {
448 return p.maxLevel == maxLevel;
449 });
450 if (it != g_vvcMaxLevelTable.end()) {
451 return it->allLevels;
452 }
453 LOGW("unknown VvcMaxLevel %d", maxLevel);
454 return nullopt;
455 }
456
InnerModeToOmxBitrateMode(VideoEncodeBitrateMode mode)457 std::optional<OMX_VIDEO_CONTROLRATETYPE> TypeConverter::InnerModeToOmxBitrateMode(VideoEncodeBitrateMode mode)
458 {
459 auto it = std::find_if(g_bitrateModeTable.begin(), g_bitrateModeTable.end(), [mode](const BitrateModeMapping& p) {
460 return p.innerMode == mode;
461 });
462 if (it == g_bitrateModeTable.end()) {
463 LOGW("unknown BitRateMode %d", mode);
464 return std::nullopt;
465 }
466 return it->omxMode;
467 }
468
OmxBitrateModeToInnerMode(OMX_VIDEO_CONTROLRATETYPE mode)469 std::optional<VideoEncodeBitrateMode> TypeConverter::OmxBitrateModeToInnerMode(OMX_VIDEO_CONTROLRATETYPE mode)
470 {
471 auto it = std::find_if(g_bitrateModeTable.begin(), g_bitrateModeTable.end(), [mode](const BitrateModeMapping& p) {
472 return p.omxMode == mode;
473 });
474 if (it == g_bitrateModeTable.end()) {
475 LOGW("unknown BitRateMode %d", mode);
476 return std::nullopt;
477 }
478 return it->innerMode;
479 }
480 }