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 "avcodec_log.h"
17 #include "avcodec_errors.h"
18 #include "codeclist_builder.h"
19 #ifndef CLIENT_SUPPORT_CODEC
20 #include "hcodec_loader.h"
21 #endif
22 #include "codec_ability_singleton.h"
23
24 namespace {
25 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_FRAMEWORK, "CodecAbilitySingleton"};
26 constexpr int32_t MAX_SQR_FACTOR = 51;
27 }
28
29 namespace OHOS {
30 namespace MediaAVCodec {
GetCodecLists()31 std::unordered_map<CodecType, std::shared_ptr<CodecListBase>> GetCodecLists()
32 {
33 std::unordered_map<CodecType, std::shared_ptr<CodecListBase>> codecLists;
34 #ifndef CLIENT_SUPPORT_CODEC
35 std::shared_ptr<CodecListBase> vcodecList = std::make_shared<VideoCodecList>();
36 codecLists.insert(std::make_pair(CodecType::AVCODEC_VIDEO_CODEC, vcodecList));
37 std::shared_ptr<CodecListBase> hevcDecoderList = std::make_shared<VideoHevcDecoderList>();
38 codecLists.insert(std::make_pair(CodecType::AVCODEC_VIDEO_HEVC_DECODER, hevcDecoderList));
39 std::shared_ptr<CodecListBase> avcEncoderList = std::make_shared<VideoAvcEncoderList>();
40 codecLists.insert(std::make_pair(CodecType::AVCODEC_VIDEO_AVC_ENCODER, avcEncoderList));
41 #endif
42 std::shared_ptr<CodecListBase> acodecList = std::make_shared<AudioCodecList>();
43 codecLists.insert(std::make_pair(CodecType::AVCODEC_AUDIO_CODEC, acodecList));
44 return codecLists;
45 }
46
GetInstance()47 CodecAbilitySingleton &CodecAbilitySingleton::GetInstance()
48 {
49 static CodecAbilitySingleton instance;
50 return instance;
51 }
52
CodecAbilitySingleton()53 CodecAbilitySingleton::CodecAbilitySingleton()
54 {
55 #ifndef CLIENT_SUPPORT_CODEC
56 std::vector<CapabilityData> videoCapaArray;
57 if (HCodecLoader::GetCapabilityList(videoCapaArray) == AVCS_ERR_OK) {
58 RegisterCapabilityArray(videoCapaArray, CodecType::AVCODEC_HCODEC);
59 }
60 #endif
61 std::unordered_map<CodecType, std::shared_ptr<CodecListBase>> codecLists = GetCodecLists();
62 for (auto iter = codecLists.begin(); iter != codecLists.end(); iter++) {
63 CodecType codecType = iter->first;
64 std::vector<CapabilityData> capaArray;
65 int32_t ret = iter->second->GetCapabilityList(capaArray);
66 if (ret == AVCS_ERR_OK) {
67 RegisterCapabilityArray(capaArray, codecType);
68 }
69 }
70 AVCODEC_LOGI("Succeed");
71 }
72
~CodecAbilitySingleton()73 CodecAbilitySingleton::~CodecAbilitySingleton()
74 {
75 AVCODEC_LOGI("Succeed");
76 }
77
IsCapabilityValid(const CapabilityData & cap)78 bool CodecAbilitySingleton::IsCapabilityValid(const CapabilityData &cap)
79 {
80 CHECK_AND_RETURN_RET_LOG(!cap.codecName.empty(), false, "codecName is empty");
81 CHECK_AND_RETURN_RET_LOG(cap.codecType > AVCodecType::AVCODEC_TYPE_NONE && cap.codecType <=
82 AVCodecType::AVCODEC_TYPE_AUDIO_DECODER, false, "codecType is invalid, %{public}d", cap.codecType);
83 CHECK_AND_RETURN_RET_LOG(!cap.mimeType.empty(), false, "mimeType is empty");
84 CHECK_AND_RETURN_RET_LOG(cap.maxInstance > 0, false, "maxInstance is invalid, %{public}d", cap.maxInstance);
85 if (cap.codecType == AVCodecType::AVCODEC_TYPE_VIDEO_ENCODER ||
86 cap.codecType == AVCodecType::AVCODEC_TYPE_VIDEO_DECODER) {
87 CHECK_AND_RETURN_RET_LOG(cap.width.minVal > 0 && cap.width.minVal <= cap.width.maxVal, false,
88 "width is invalid, range is [%{public}d, %{public}d]", cap.width.minVal, cap.width.maxVal);
89 CHECK_AND_RETURN_RET_LOG(cap.height.minVal > 0 && cap.height.minVal <= cap.height.maxVal, false,
90 "height is invalid, range is [%{public}d, %{public}d]", cap.height.minVal, cap.height.maxVal);
91 }
92 if (std::find(cap.bitrateMode.begin(), cap.bitrateMode.end(), SQR) != cap.bitrateMode.end()) {
93 CHECK_AND_RETURN_RET_LOG(cap.sqrFactor.maxVal <= MAX_SQR_FACTOR && cap.sqrFactor.minVal >= 0, false,
94 "sqrFactor is invalid, range is [%{public}d, %{public}d]", cap.sqrFactor.minVal, cap.sqrFactor.maxVal);
95 }
96 return true;
97 }
98
RegisterCapabilityArray(std::vector<CapabilityData> & capaArray,CodecType codecType)99 void CodecAbilitySingleton::RegisterCapabilityArray(std::vector<CapabilityData> &capaArray, CodecType codecType)
100 {
101 std::lock_guard<std::mutex> lock(mutex_);
102 size_t beginIdx = capabilityDataArray_.size();
103 for (auto iter = capaArray.begin(); iter != capaArray.end(); iter++) {
104 if (!IsCapabilityValid(*iter)) {
105 AVCODEC_LOGE("cap is invalid, codecName is %{public}s", (*iter).codecName.c_str());
106 continue;
107 }
108 std::string mimeType = (*iter).mimeType;
109 std::vector<size_t> idxVec;
110 if (mimeCapIdxMap_.find(mimeType) == mimeCapIdxMap_.end()) {
111 mimeCapIdxMap_.insert(std::make_pair(mimeType, idxVec));
112 }
113 if ((*iter).profileLevelsMap.size() > MAX_MAP_SIZE) {
114 while ((*iter).profileLevelsMap.size() > MAX_MAP_SIZE) {
115 auto rIter = (*iter).profileLevelsMap.end();
116 (*iter).profileLevelsMap.erase(--rIter);
117 }
118 std::vector<int32_t> newProfiles;
119 (*iter).profiles.swap(newProfiles);
120 auto nIter = (*iter).profileLevelsMap.begin();
121 while (nIter != (*iter).profileLevelsMap.end()) {
122 (*iter).profiles.emplace_back(nIter->first);
123 nIter++;
124 }
125 }
126 while ((*iter).measuredFrameRate.size() > MAX_MAP_SIZE) {
127 auto rIter = (*iter).measuredFrameRate.end();
128 (*iter).measuredFrameRate.erase(--rIter);
129 }
130 capabilityDataArray_.emplace_back(*iter);
131 mimeCapIdxMap_.at(mimeType).emplace_back(beginIdx);
132 nameCodecTypeMap_.insert(std::make_pair((*iter).codecName, codecType));
133 beginIdx++;
134 }
135 AVCODEC_LOGD("Register capability successful");
136 }
137
GetCapabilityArray()138 std::vector<CapabilityData> CodecAbilitySingleton::GetCapabilityArray()
139 {
140 std::lock_guard<std::mutex> lock(mutex_);
141 return capabilityDataArray_;
142 }
143
GetCapabilityByName(const std::string & name)144 std::optional<CapabilityData> CodecAbilitySingleton::GetCapabilityByName(const std::string &name)
145 {
146 auto it = std::find_if(capabilityDataArray_.begin(), capabilityDataArray_.end(), [&](const CapabilityData &cap) {
147 return cap.codecName == name;
148 });
149 return it == capabilityDataArray_.end() ? std::nullopt : std::make_optional<CapabilityData>(*it);
150 }
151
GetMimeByCodecName(const std::string & name)152 std::string CodecAbilitySingleton::GetMimeByCodecName(const std::string & name)
153 {
154 std::lock_guard<std::mutex> lock(mutex_);
155 for (const auto &cap : capabilityDataArray_) {
156 if (cap.codecName == name) {
157 return cap.mimeType;
158 }
159 }
160 return "";
161 }
162
GetNameCodecTypeMap()163 std::unordered_map<std::string, CodecType> CodecAbilitySingleton::GetNameCodecTypeMap()
164 {
165 std::lock_guard<std::mutex> lock(mutex_);
166 return nameCodecTypeMap_;
167 }
168
GetMimeCapIdxMap()169 std::unordered_map<std::string, std::vector<size_t>> CodecAbilitySingleton::GetMimeCapIdxMap()
170 {
171 std::lock_guard<std::mutex> lock(mutex_);
172 return mimeCapIdxMap_;
173 }
174 } // namespace MediaAVCodec
175 } // namespace OHOS
176