1 /*
2 * Copyright (C) 2021 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 "avcodeclist_engine_gst_impl.h"
17 #include <cmath>
18 #include "avcodec_ability_singleton.h"
19 #include "media_errors.h"
20 #include "media_log.h"
21
22 namespace {
23 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "AVCodecListEngineGstImpl"};
24 constexpr float EPSINON = 0.0001;
25 }
26
27 namespace OHOS {
28 namespace Media {
AVCodecListEngineGstImpl()29 AVCodecListEngineGstImpl::AVCodecListEngineGstImpl()
30 {
31 MEDIA_LOGD("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this));
32 }
33
~AVCodecListEngineGstImpl()34 AVCodecListEngineGstImpl::~AVCodecListEngineGstImpl()
35 {
36 MEDIA_LOGD("0x%{public}06" PRIXPTR " Instances destroy", FAKE_POINTER(this));
37 }
38
IsSupportMimeType(const Format & format,const CapabilityData & data)39 bool AVCodecListEngineGstImpl::IsSupportMimeType(const Format &format, const CapabilityData &data)
40 {
41 std::string targetMimeType;
42 if (!format.ContainKey("codec_mime")) {
43 MEDIA_LOGD("Get MimeType from format failed");
44 return false;
45 }
46 (void)format.GetStringValue("codec_mime", targetMimeType);
47 if (data.mimeType != targetMimeType) {
48 return false;
49 }
50 return true;
51 }
52
IsSupportBitrate(const Format & format,const CapabilityData & data)53 bool AVCodecListEngineGstImpl::IsSupportBitrate(const Format &format, const CapabilityData &data)
54 {
55 int32_t targetBitrate;
56 if (!format.ContainKey("bitrate")) {
57 MEDIA_LOGD("The bitrate of the format are not specified");
58 return true;
59 }
60 (void)format.GetIntValue("bitrate", targetBitrate);
61 if (data.bitrate.minVal > targetBitrate || data.bitrate.maxVal < targetBitrate) {
62 return false;
63 }
64 return true;
65 }
66
IsSupportSize(const Format & format,const CapabilityData & data)67 bool AVCodecListEngineGstImpl::IsSupportSize(const Format &format, const CapabilityData &data)
68 {
69 int32_t targetWidth;
70 int32_t targetHeight;
71 if ((!format.ContainKey("width")) || (!format.ContainKey("height"))) {
72 MEDIA_LOGD("The width and height of the format are not specified");
73 return true;
74 }
75 (void)format.GetIntValue("width", targetWidth);
76 (void)format.GetIntValue("height", targetHeight);
77 if (data.width.minVal > targetWidth || data.width.maxVal < targetWidth
78 || data.height.minVal > targetHeight || data.height.maxVal < targetHeight) {
79 return false;
80 }
81 return true;
82 }
83
IsSupportPixelFormat(const Format & format,const CapabilityData & data)84 bool AVCodecListEngineGstImpl::IsSupportPixelFormat(const Format &format, const CapabilityData &data)
85 {
86 if (data.codecType == AVCODEC_TYPE_AUDIO_ENCODER || data.codecType == AVCODEC_TYPE_AUDIO_DECODER) {
87 return true;
88 }
89 int32_t targetPixelFormat;
90 if (!format.ContainKey("pixel_format")) {
91 MEDIA_LOGD("The pixel_format of the format are not specified");
92 return true;
93 }
94 (void)format.GetIntValue("pixel_format", targetPixelFormat);
95 if (find(data.format.begin(), data.format.end(), targetPixelFormat) == data.format.end()) {
96 return false;
97 }
98 return true;
99 }
100
IsSupportFrameRate(const Format & format,const CapabilityData & data)101 bool AVCodecListEngineGstImpl::IsSupportFrameRate(const Format &format, const CapabilityData &data)
102 {
103 if (!format.ContainKey("frame_rate")) {
104 MEDIA_LOGD("The frame_rate of the format are not specified");
105 return true;
106 }
107
108 switch (format.GetValueType(std::string_view("frame_rate"))) {
109 case FORMAT_TYPE_INT32:
110 int32_t targetFrameRateInt;
111 (void)format.GetIntValue("frame_rate", targetFrameRateInt);
112 if (data.frameRate.minVal > targetFrameRateInt ||
113 data.frameRate.maxVal < targetFrameRateInt) {
114 return false;
115 }
116 break;
117 case FORMAT_TYPE_DOUBLE:
118 double targetFrameRateDouble;
119 (void)format.GetDoubleValue("frame_rate", targetFrameRateDouble);
120 if ((static_cast<double>(data.frameRate.minVal) > targetFrameRateDouble &&
121 fabs(static_cast<double>(data.frameRate.minVal) - targetFrameRateDouble) >= EPSINON) ||
122 (static_cast<double>(data.frameRate.maxVal) < targetFrameRateDouble &&
123 fabs(static_cast<double>(data.frameRate.maxVal) - targetFrameRateDouble) >= EPSINON)) {
124 return false;
125 }
126 break;
127 default:
128 break;
129 }
130 return true;
131 }
132
IsSupportChannel(const Format & format,const CapabilityData & data)133 bool AVCodecListEngineGstImpl::IsSupportChannel(const Format &format, const CapabilityData &data)
134 {
135 if (data.codecType == AVCODEC_TYPE_VIDEO_ENCODER || data.codecType == AVCODEC_TYPE_VIDEO_DECODER) {
136 return true;
137 }
138 int32_t targetChannel;
139 if (!format.ContainKey("channel_count")) {
140 MEDIA_LOGD("The channel_count of the format are not specified");
141 return true;
142 }
143 (void)format.GetIntValue("channel_count", targetChannel);
144 if (data.channels.minVal > targetChannel || data.channels.maxVal < targetChannel) {
145 return false;
146 }
147 return true;
148 }
149
IsSupportSampleRate(const Format & format,const CapabilityData & data)150 bool AVCodecListEngineGstImpl::IsSupportSampleRate(const Format &format, const CapabilityData &data)
151 {
152 if (data.codecType == AVCODEC_TYPE_VIDEO_ENCODER || data.codecType == AVCODEC_TYPE_VIDEO_DECODER) {
153 return true;
154 }
155 int32_t targetSampleRate;
156 if (!format.ContainKey("samplerate")) {
157 MEDIA_LOGD("The samplerate of the format are not specified");
158 return true;
159 }
160 (void)format.GetIntValue("samplerate", targetSampleRate);
161 if (find(data.sampleRate.begin(), data.sampleRate.end(), targetSampleRate) == data.sampleRate.end()) {
162 return false;
163 }
164 return true;
165 }
166
FindTargetCodec(const Format & format,const std::vector<CapabilityData> & capabilityDataArray,const AVCodecType & codecType)167 std::string AVCodecListEngineGstImpl::FindTargetCodec(const Format &format,
168 const std::vector<CapabilityData> &capabilityDataArray, const AVCodecType &codecType)
169 {
170 for (auto iter = capabilityDataArray.begin(); iter != capabilityDataArray.end(); ++iter) {
171 if ((*iter).codecType != codecType || !IsSupportMimeType(format, *iter) ||
172 !IsSupportBitrate(format, *iter) || !IsSupportSize(format, *iter) ||
173 !IsSupportPixelFormat(format, *iter) || !IsSupportFrameRate(format, *iter) ||
174 !IsSupportSampleRate(format, *iter) || !IsSupportChannel(format, *iter)) {
175 continue;
176 }
177 return (*iter).codecName;
178 }
179 return "";
180 }
181
FindVideoDecoder(const Format & format)182 std::string AVCodecListEngineGstImpl::FindVideoDecoder(const Format &format)
183 {
184 std::vector<CapabilityData> capabilityDataArray = GetCodecCapabilityInfos();
185 return FindTargetCodec(format, capabilityDataArray, AVCODEC_TYPE_VIDEO_DECODER);
186 }
187
FindVideoEncoder(const Format & format)188 std::string AVCodecListEngineGstImpl::FindVideoEncoder(const Format &format)
189 {
190 std::vector<CapabilityData> capabilityDataArray = GetCodecCapabilityInfos();
191 return FindTargetCodec(format, capabilityDataArray, AVCODEC_TYPE_VIDEO_ENCODER);
192 }
193
FindAudioDecoder(const Format & format)194 std::string AVCodecListEngineGstImpl::FindAudioDecoder(const Format &format)
195 {
196 std::vector<CapabilityData> capabilityDataArray = GetCodecCapabilityInfos();
197 return FindTargetCodec(format, capabilityDataArray, AVCODEC_TYPE_AUDIO_DECODER);
198 }
199
FindAudioEncoder(const Format & format)200 std::string AVCodecListEngineGstImpl::FindAudioEncoder(const Format &format)
201 {
202 std::vector<CapabilityData> capabilityDataArray = GetCodecCapabilityInfos();
203 return FindTargetCodec(format, capabilityDataArray, AVCODEC_TYPE_AUDIO_ENCODER);
204 }
205
GetCodecCapabilityInfos()206 std::vector<CapabilityData> AVCodecListEngineGstImpl::GetCodecCapabilityInfos()
207 {
208 AVCodecAbilitySingleton& codecAbilityInstance = AVCodecAbilitySingleton::GetInstance();
209 return codecAbilityInstance.GetCapabilityDataArray();
210 }
211 } // namespace Media
212 } // namespace OHOS