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 }
27
28 namespace OHOS {
29 namespace MediaAVCodec {
GetCodecLists()30 std::unordered_map<CodecType, std::shared_ptr<CodecListBase>> GetCodecLists()
31 {
32 std::unordered_map<CodecType, std::shared_ptr<CodecListBase>> codecLists;
33 #ifndef CLIENT_SUPPORT_CODEC
34 std::shared_ptr<CodecListBase> vcodecList = std::make_shared<VideoCodecList>();
35 codecLists.insert(std::make_pair(CodecType::AVCODEC_VIDEO_CODEC, vcodecList));
36 std::shared_ptr<CodecListBase> hevcDecoderList = std::make_shared<VideoHevcDecoderList>();
37 codecLists.insert(std::make_pair(CodecType::AVCODEC_VIDEO_HEVC_DECODER, hevcDecoderList));
38 #endif
39 std::shared_ptr<CodecListBase> acodecList = std::make_shared<AudioCodecList>();
40 codecLists.insert(std::make_pair(CodecType::AVCODEC_AUDIO_CODEC, acodecList));
41 return codecLists;
42 }
43
GetInstance()44 CodecAbilitySingleton &CodecAbilitySingleton::GetInstance()
45 {
46 static CodecAbilitySingleton instance;
47 return instance;
48 }
49
CodecAbilitySingleton()50 CodecAbilitySingleton::CodecAbilitySingleton()
51 {
52 #ifndef CLIENT_SUPPORT_CODEC
53 std::vector<CapabilityData> videoCapaArray;
54 if (HCodecLoader::GetCapabilityList(videoCapaArray) == AVCS_ERR_OK) {
55 RegisterCapabilityArray(videoCapaArray, CodecType::AVCODEC_HCODEC);
56 }
57 #endif
58 std::unordered_map<CodecType, std::shared_ptr<CodecListBase>> codecLists = GetCodecLists();
59 for (auto iter = codecLists.begin(); iter != codecLists.end(); iter++) {
60 CodecType codecType = iter->first;
61 std::vector<CapabilityData> capaArray;
62 int32_t ret = iter->second->GetCapabilityList(capaArray);
63 if (ret == AVCS_ERR_OK) {
64 RegisterCapabilityArray(capaArray, codecType);
65 }
66 }
67 AVCODEC_LOGI("Succeed");
68 }
69
~CodecAbilitySingleton()70 CodecAbilitySingleton::~CodecAbilitySingleton()
71 {
72 AVCODEC_LOGI("Succeed");
73 }
74
RegisterCapabilityArray(std::vector<CapabilityData> & capaArray,CodecType codecType)75 void CodecAbilitySingleton::RegisterCapabilityArray(std::vector<CapabilityData> &capaArray, CodecType codecType)
76 {
77 std::lock_guard<std::mutex> lock(mutex_);
78 size_t beginIdx = capabilityDataArray_.size();
79 for (auto iter = capaArray.begin(); iter != capaArray.end(); iter++) {
80 std::string mimeType = (*iter).mimeType;
81 std::vector<size_t> idxVec;
82 if (mimeCapIdxMap_.find(mimeType) == mimeCapIdxMap_.end()) {
83 mimeCapIdxMap_.insert(std::make_pair(mimeType, idxVec));
84 }
85 if ((*iter).profileLevelsMap.size() > MAX_MAP_SIZE) {
86 while ((*iter).profileLevelsMap.size() > MAX_MAP_SIZE) {
87 auto rIter = (*iter).profileLevelsMap.end();
88 (*iter).profileLevelsMap.erase(--rIter);
89 }
90 std::vector<int32_t> newProfiles;
91 (*iter).profiles.swap(newProfiles);
92 auto nIter = (*iter).profileLevelsMap.begin();
93 while (nIter != (*iter).profileLevelsMap.end()) {
94 (*iter).profiles.emplace_back(nIter->first);
95 nIter++;
96 }
97 }
98 while ((*iter).measuredFrameRate.size() > MAX_MAP_SIZE) {
99 auto rIter = (*iter).measuredFrameRate.end();
100 (*iter).measuredFrameRate.erase(--rIter);
101 }
102 capabilityDataArray_.emplace_back(*iter);
103 mimeCapIdxMap_.at(mimeType).emplace_back(beginIdx);
104 nameCodecTypeMap_.insert(std::make_pair((*iter).codecName, codecType));
105 beginIdx++;
106 }
107 AVCODEC_LOGD("Register capability successful");
108 }
109
GetCapabilityArray()110 std::vector<CapabilityData> CodecAbilitySingleton::GetCapabilityArray()
111 {
112 std::lock_guard<std::mutex> lock(mutex_);
113 return capabilityDataArray_;
114 }
115
GetCapabilityByName(const std::string & name)116 std::optional<CapabilityData> CodecAbilitySingleton::GetCapabilityByName(const std::string &name)
117 {
118 auto it = std::find_if(capabilityDataArray_.begin(), capabilityDataArray_.end(), [&](const CapabilityData &cap) {
119 return cap.codecName == name;
120 });
121 return it == capabilityDataArray_.end() ? std::nullopt : std::make_optional<CapabilityData>(*it);
122 }
123
GetNameCodecTypeMap()124 std::unordered_map<std::string, CodecType> CodecAbilitySingleton::GetNameCodecTypeMap()
125 {
126 std::lock_guard<std::mutex> lock(mutex_);
127 return nameCodecTypeMap_;
128 }
129
GetMimeCapIdxMap()130 std::unordered_map<std::string, std::vector<size_t>> CodecAbilitySingleton::GetMimeCapIdxMap()
131 {
132 std::lock_guard<std::mutex> lock(mutex_);
133 return mimeCapIdxMap_;
134 }
135 } // namespace MediaAVCodec
136 } // namespace OHOS
137