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