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