1 /*
2 * Copyright (c) 2023-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 #if defined(VIDEO_SUPPORT)
16
17 #define HST_LOG_TAG "CodecUtils"
18
19 #include "codec_utils.h"
20 #include <map>
21 #include "foundation/log.h"
22 #include "hdf_base.h"
23 #include "OMX_Core.h"
24
25 namespace OHOS {
26 namespace Media {
27 namespace Plugin {
28 namespace CodecAdapter {
29 const static std::map<HDF_STATUS, std::string> hdfStatusMap = {
30 {HDF_STATUS::HDF_SUCCESS, "HDF_SUCCESS"},
31 {HDF_STATUS::HDF_FAILURE, "HDF_FAILURE"},
32 {HDF_STATUS::HDF_ERR_NOT_SUPPORT, "HDF_ERR_NOT_SUPPORT"},
33 {HDF_STATUS::HDF_ERR_INVALID_PARAM, "HDF_ERR_INVALID_PARAM"},
34 {HDF_STATUS::HDF_ERR_INVALID_OBJECT, "HDF_ERR_INVALID_OBJECT"},
35 {HDF_STATUS::HDF_ERR_MALLOC_FAIL, "HDF_ERR_MALLOC_FAIL"},
36 {HDF_STATUS::HDF_ERR_TIMEOUT, "HDF_ERR_TIMEOUT"},
37 {HDF_STATUS::HDF_ERR_THREAD_CREATE_FAIL, "HDF_ERR_THREAD_CREATE_FAIL"},
38 {HDF_STATUS::HDF_ERR_QUEUE_FULL, "HDF_ERR_QUEUE_FULL"},
39 {HDF_STATUS::HDF_ERR_DEVICE_BUSY, "HDF_ERR_DEVICE_BUSY"},
40 {HDF_STATUS::HDF_ERR_IO, "HDF_ERR_IO"},
41 {HDF_STATUS::HDF_ERR_BAD_FD, "HDF_ERR_BAD_FD"},
42 {HDF_STATUS::HDF_ERR_NOPERM, "HDF_ERR_NOPERM"},
43 {HDF_STATUS::HDF_BSP_ERR_OP, "HDF_BSP_ERR_OP"},
44 {HDF_STATUS::HDF_ERR_BSP_PLT_API_ERR, "HDF_ERR_BSP_PLT_API_ERR"},
45 {HDF_STATUS::HDF_PAL_ERR_DEV_CREATE, "HDF_PAL_ERR_DEV_CREATE"},
46 {HDF_STATUS::HDF_PAL_ERR_INNER, "HDF_PAL_ERR_INNER"},
47 {HDF_STATUS::HDF_DEV_ERR_NO_MEMORY, "HDF_DEV_ERR_NO_MEMORY"},
48 {HDF_STATUS::HDF_DEV_ERR_NO_DEVICE, "HDF_DEV_ERR_NO_DEVICE"},
49 {HDF_STATUS::HDF_DEV_ERR_NO_DEVICE_SERVICE, "HDF_DEV_ERR_NO_DEVICE_SERVICE"},
50 {HDF_STATUS::HDF_DEV_ERR_DEV_INIT_FAIL, "HDF_DEV_ERR_DEV_INIT_FAIL"},
51 {HDF_STATUS::HDF_DEV_ERR_PUBLISH_FAIL, "HDF_DEV_ERR_PUBLISH_FAIL"},
52 {HDF_STATUS::HDF_DEV_ERR_ATTACHDEV_FAIL, "HDF_DEV_ERR_ATTACHDEV_FAIL"},
53 {HDF_STATUS::HDF_DEV_ERR_NODATA, "HDF_DEV_ERR_NODATA"},
54 {HDF_STATUS::HDF_DEV_ERR_NORANGE, "HDF_DEV_ERR_NORANGE"},
55 {HDF_STATUS::HDF_DEV_ERR_OP, "HDF_DEV_ERR_OP"},
56 };
57
58 const static std::map<OMX_ERRORTYPE, std::string> omxErrorTypeMap = {
59 {OMX_ErrorNone, "OMX_ErrorNone"},
60 {OMX_ErrorInsufficientResources, "OMX_ErrorInsufficientResources"},
61 {OMX_ErrorUndefined, "OMX_ErrorUndefined"},
62 {OMX_ErrorInvalidComponentName, "OMX_ErrorInvalidComponentName"},
63 {OMX_ErrorComponentNotFound, "OMX_ErrorComponentNotFound"},
64 {OMX_ErrorInvalidComponent, "OMX_ErrorInvalidComponent"},
65 {OMX_ErrorBadParameter, "OMX_ErrorBadParameter"},
66 {OMX_ErrorNotImplemented, "OMX_ErrorNotImplemented"},
67 {OMX_ErrorUnderflow, "OMX_ErrorUnderflow"},
68 {OMX_ErrorOverflow, "OMX_ErrorOverflow"},
69 {OMX_ErrorHardware, "OMX_ErrorHardware"},
70 {OMX_ErrorInvalidState, "OMX_ErrorInvalidState"},
71 {OMX_ErrorStreamCorrupt, "OMX_ErrorStreamCorrupt"},
72 {OMX_ErrorPortsNotCompatible, "OMX_ErrorPortsNotCompatible"},
73 {OMX_ErrorResourcesLost, "OMX_ErrorResourcesLost"},
74 {OMX_ErrorNoMore, "OMX_ErrorNoMore"},
75 {OMX_ErrorVersionMismatch, "OMX_ErrorVersionMismatch"},
76 {OMX_ErrorNotReady, "OMX_ErrorNotReady"},
77 {OMX_ErrorTimeout, "OMX_ErrorTimeout"},
78 {OMX_ErrorSameState, "OMX_ErrorSameState"},
79 {OMX_ErrorResourcesPreempted, "OMX_ErrorResourcesPreempted"},
80 {OMX_ErrorPortUnresponsiveDuringAllocation, "OMX_ErrorPortUnresponsiveDuringAllocation"},
81 {OMX_ErrorPortUnresponsiveDuringDeallocation, "OMX_ErrorPortUnresponsiveDuringDeallocation"},
82 {OMX_ErrorPortUnresponsiveDuringStop, "OMX_ErrorPortUnresponsiveDuringStop"},
83 {OMX_ErrorIncorrectStateTransition, "OMX_ErrorIncorrectStateTransition"},
84 {OMX_ErrorIncorrectStateOperation, "OMX_ErrorIncorrectStateOperation"},
85 {OMX_ErrorUnsupportedSetting, "OMX_ErrorUnsupportedSetting"},
86 {OMX_ErrorUnsupportedIndex, "OMX_ErrorUnsupportedIndex"},
87 {OMX_ErrorBadPortIndex, "OMX_ErrorBadPortIndex"},
88 {OMX_ErrorPortUnpopulated, "OMX_ErrorPortUnpopulated"},
89 {OMX_ErrorComponentSuspended, "OMX_ErrorComponentSuspended"},
90 {OMX_ErrorDynamicResourcesUnavailable, "OMX_ErrorDynamicResourcesUnavailable"},
91 {OMX_ErrorMbErrorsInFrame, "OMX_ErrorMbErrorsInFrame"},
92 {OMX_ErrorFormatNotDetected, "OMX_ErrorFormatNotDetected"},
93 {OMX_ErrorContentPipeOpenFailed, "OMX_ErrorContentPipeOpenFailed"},
94 {OMX_ErrorContentPipeCreationFailed, "OMX_ErrorContentPipeCreationFailed"},
95 {OMX_ErrorSeperateTablesUsed, "OMX_ErrorSeperateTablesUsed"},
96 {OMX_ErrorTunnelingUnsupported, "OMX_ErrorTunnelingUnsupported"},
97 {OMX_ErrorKhronosExtensions, "OMX_ErrorKhronosExtensions"},
98 {OMX_ErrorVendorStartUnused, "OMX_ErrorVendorStartUnused"},
99 {OMX_ErrorMax, "OMX_ErrorMax"},
100 };
101
102 const static std::pair<int32_t, Status> retStatusMap[] = {
103 {HDF_SUCCESS, Status::OK},
104 {HDF_FAILURE, Status::ERROR_UNKNOWN},
105 {HDF_ERR_NOT_SUPPORT, Status::ERROR_INVALID_OPERATION},
106 {HDF_ERR_INVALID_PARAM, Status::ERROR_INVALID_PARAMETER},
107 {HDF_ERR_MALLOC_FAIL, Status::ERROR_NO_MEMORY},
108 };
109
HdfStatus2String(int32_t status)110 std::string HdfStatus2String(int32_t status)
111 {
112 auto it = hdfStatusMap.find(static_cast<HDF_STATUS>(status));
113 if (it != hdfStatusMap.end()) {
114 return it->second;
115 }
116 MEDIA_LOG_E("Not find value: " PUBLIC_LOG_D32 " in hdfStatusMap", status);
117 return "null";
118 }
119
OmxErrorType2String(uint32_t errorType)120 std::string OmxErrorType2String(uint32_t errorType)
121 {
122 auto it = omxErrorTypeMap.find(static_cast<OMX_ERRORTYPE>(errorType));
123 if (it != omxErrorTypeMap.end()) {
124 return it->second;
125 }
126 MEDIA_LOG_E("Not find value: " PUBLIC_LOG_U32 " in omxErrorTypeMap", errorType);
127 return omxErrorTypeMap.at(OMX_ErrorNone);
128 }
129
130 template<typename T, typename U>
TranslatesByMap(const T & t,U & u,const std::pair<T,U> * transMap,size_t mapSize)131 bool TranslatesByMap(const T& t, U& u, const std::pair<T, U>* transMap, size_t mapSize)
132 {
133 for (size_t cnt = 0; cnt < mapSize; cnt++) {
134 if (t == transMap[cnt].first) {
135 u = transMap[cnt].second;
136 return true;
137 }
138 }
139 return false;
140 }
141
TransHdiRetVal2Status(const int32_t & ret)142 Status TransHdiRetVal2Status(const int32_t& ret)
143 {
144 Status status = Status::ERROR_UNKNOWN;
145 TranslatesByMap(ret, status, retStatusMap, sizeof(retStatusMap) / sizeof(retStatusMap[0]));
146 return status;
147 }
148
Translate2omxFlagSet(uint64_t pluginFlags)149 uint32_t Translate2omxFlagSet(uint64_t pluginFlags)
150 {
151 uint32_t ret = 0;
152 if (pluginFlags == BUFFER_FLAG_EOS) {
153 ret = OMX_BUFFERFLAG_EOS;
154 }
155 return ret;
156 }
157
Translate2PluginFlagSet(uint32_t omxBufFlag)158 uint64_t Translate2PluginFlagSet(uint32_t omxBufFlag)
159 {
160 uint64_t ret = 0;
161 if (omxBufFlag == OMX_BUFFERFLAG_EOS) {
162 ret = BUFFER_FLAG_EOS;
163 }
164 return ret;
165 }
166
167 static const std::map<std::string, OMX_VIDEO_CODINGTYPE> compressHstOmx = {
168 {MEDIA_MIME_VIDEO_H264, OMX_VIDEO_CodingAVC},
169 {MEDIA_MIME_VIDEO_H265, static_cast<OMX_VIDEO_CODINGTYPE>(CODEC_OMX_VIDEO_CodingHEVC)}
170 };
171
CodingTypeHstToHdi(const std::string & format)172 OMX_VIDEO_CODINGTYPE CodingTypeHstToHdi(const std::string& format)
173 {
174 if (compressHstOmx.find(format) != compressHstOmx.end()) {
175 return compressHstOmx.at(format);
176 }
177 return OMX_VIDEO_CodingUnused;
178 }
179
180 static const std::map<VideoPixelFormat, OMX_COLOR_FORMATTYPE> formatHstOmx = {
181 {VideoPixelFormat::NV12, OMX_COLOR_FormatYUV420SemiPlanar},
182 {VideoPixelFormat::NV21, OMX_COLOR_FormatYUV420SemiPlanar},
183 {VideoPixelFormat::BGRA, OMX_COLOR_Format32bitBGRA8888},
184 {VideoPixelFormat::RGBA, OMX_COLOR_Format32bitARGB8888},
185 {VideoPixelFormat::YUV420P, OMX_COLOR_FormatYUV420Planar},
186 };
187
FormatHstToOmx(const VideoPixelFormat format)188 OMX_COLOR_FORMATTYPE FormatHstToOmx(const VideoPixelFormat format)
189 {
190 if (formatHstOmx.find(format) != formatHstOmx.end()) {
191 return formatHstOmx.at(format);
192 }
193 MEDIA_LOG_W("Unknow VideoPixelFormat: " PUBLIC_LOG_U32, static_cast<uint32_t>(format));
194 return OMX_COLOR_FormatUnused;
195 }
196
197 static const std::map<OMX_STATETYPE, std::string> omxStateMap = {
198 {OMX_StateInvalid, "OMX_StateInvalid"},
199 {OMX_StateLoaded, "OMX_StateLoaded"},
200 {OMX_StateLoaded, "OMX_StateLoaded"},
201 {OMX_StateIdle, "OMX_StateIdle"},
202 {OMX_StateExecuting, "OMX_StateExecuting"},
203 {OMX_StatePause, "OMX_StatePause"},
204 {OMX_StateWaitForResources, "OMX_StateWaitForResources"},
205 {OMX_StateKhronosExtensions, "OMX_StateKhronosExtensions"},
206 {OMX_StateVendorStartUnused, "OMX_StateVendorStartUnused"},
207 {OMX_StateMax, "OMX_StateMax"},
208 };
209
OmxStateToString(OMX_STATETYPE state)210 std::string OmxStateToString(OMX_STATETYPE state)
211 {
212 auto iter = omxStateMap.find(state);
213 if (iter != omxStateMap.end()) {
214 return iter->second;
215 }
216 MEDIA_LOG_W("Not find value, maybe update the map");
217 return "null";
218 }
219
GetOmxBufferType(const MemoryType & bufMemType,bool isInput)220 uint32_t GetOmxBufferType(const MemoryType& bufMemType, bool isInput)
221 {
222 uint32_t bufferType;
223 switch (bufMemType) {
224 case MemoryType::SHARE_MEMORY:
225 bufferType = CODEC_BUFFER_TYPE_AVSHARE_MEM_FD;
226 break;
227 case MemoryType::SURFACE_BUFFER:
228 bufferType = CODEC_BUFFER_TYPE_HANDLE;
229 if (isInput) {
230 bufferType = CODEC_BUFFER_TYPE_DYNAMIC_HANDLE;
231 }
232 break;
233 default:
234 bufferType = CODEC_BUFFER_TYPE_INVALID;
235 MEDIA_LOG_E("MemoryType Error");
236 }
237 return bufferType;
238 }
239 } // namespace CodecAdapter
240 } // namespace Plugin
241 } // namespace Media
242 } // namespace OHOS
243 #endif