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 "audio_codeclist_info.h"
17 #include "avcodec_mime_type.h"
18 #include "avcodec_codec_name.h"
19 #include "hdi_codec.h"
20 #include <fstream>
21
22 namespace OHOS {
23 namespace MediaAVCodec {
24 const std::vector<int32_t> AUDIO_SAMPLE_RATE = {8000, 11025, 12000, 16000, 22050, 24000,
25 32000, 44100, 48000, 64000, 88200, 96000};
26 constexpr int MAX_AUDIO_CHANNEL_COUNT = 8;
27 constexpr int MAX_SUPPORT_AUDIO_INSTANCE = 16;
28
29 constexpr int MIN_BIT_RATE_MP3 = 32000;
30 constexpr int MAX_BIT_RATE_MP3 = 320000;
31 constexpr int MAX_BIT_RATE_OPUS = 510000;
32 constexpr int MIN_BIT_RATE_MP3_ENCODE = 8000;
33 constexpr int MAX_CHANNEL_COUNT_MP3 = 2;
34 constexpr int MAX_CHANNEL_COUNT_APE = 2;
35
36 constexpr int MIN_BIT_RATE_AAC = 8000;
37 constexpr int MAX_BIT_RATE_AAC = 960000;
38 const std::vector<int32_t> AUDIO_VORBIS_SAMPLE_RATE = {8000, 11025, 12000, 16000, 22050, 24000,
39 32000, 44100, 48000, 64000, 88200, 96000};
40 const std::vector<int32_t> AUDIO_AMRNB_SAMPLE_RATE = {8000};
41
42 const std::vector<int32_t> AUDIO_AMRWB_SAMPLE_RATE = {16000};
43
44 const std::vector<int32_t> AUDIO_G711MU_SAMPLE_RATE = {8000};
45
46 const std::vector<int32_t> AUDIO_FLAC_SAMPLE_RATE = {8000, 11025, 12000, 16000, 22050, 24000, 32000,
47 44100, 48000, 64000, 88200, 96000, 192000};
48
49 const std::vector<int32_t> AUDIO_MP3_EN_SAMPLE_RATE = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000};
50 const std::vector<int32_t> AUDIO_LBVC_SAMPLE_RATE = {16000};
51
52 constexpr int MAX_BIT_RATE_FLAC = 2100000;
53 constexpr int MAX_BIT_RATE_APE = 2100000;
54 constexpr int MIN_BIT_RATE_VORBIS = 32000;
55 constexpr int MAX_BIT_RATE_VORBIS = 500000;
56
57 constexpr int MAX_BIT_RATE_AMRWB = 23850;
58 constexpr int MAX_BIT_RATE_AMRNB = 12200;
59
60 constexpr int MIN_BIT_RATE_AAC_ENCODER = 8000;
61 constexpr int MAX_BIT_RATE_AAC_ENCODER = 448000;
62
63 #ifdef AV_CODEC_AUDIO_VIVID_CAPACITY
64 constexpr int MAX_BIT_RATE_LBVC = 6000;
65 const std::vector<int32_t> AUDIO_VIVID_SAMPLE_RATE = {32000, 44100, 48000, 96000, 192000};
66 constexpr int MIN_BIT_RATE_VIVID_DECODER = 16000;
67 constexpr int MAX_BIT_RATE_VIVID_DECODER = 3075000;
68 constexpr int MAX_CHANNEL_COUNT_VIVID = 16;
69 #endif
70 constexpr int MAX_BIT_RATE_G711MU_DECODER = 64000;
71 constexpr int MAX_BIT_RATE_G711MU_ENCODER = 64000;
72
73 const std::string VENDOR_AAC_LIB_PATH = std::string(AV_CODEC_PATH) + "/libaac_enc.z.so";
74
GetMP3DecoderCapability()75 CapabilityData AudioCodeclistInfo::GetMP3DecoderCapability()
76 {
77 CapabilityData audioMp3Capability;
78 audioMp3Capability.codecName = AVCodecCodecName::AUDIO_DECODER_MP3_NAME;
79 audioMp3Capability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
80 audioMp3Capability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_MPEG;
81 audioMp3Capability.isVendor = false;
82 audioMp3Capability.bitrate = Range(MIN_BIT_RATE_MP3, MAX_BIT_RATE_MP3);
83 audioMp3Capability.channels = Range(1, MAX_CHANNEL_COUNT_MP3);
84 audioMp3Capability.sampleRate = AUDIO_SAMPLE_RATE;
85 audioMp3Capability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
86 return audioMp3Capability;
87 }
88
GetMP3EncoderCapability()89 CapabilityData AudioCodeclistInfo::GetMP3EncoderCapability()
90 {
91 CapabilityData audioMp3Capability;
92 audioMp3Capability.codecName = AVCodecCodecName::AUDIO_ENCODER_MP3_NAME;
93 audioMp3Capability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
94 audioMp3Capability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_MPEG;
95 audioMp3Capability.isVendor = false;
96 audioMp3Capability.bitrate = Range(MIN_BIT_RATE_MP3_ENCODE, MAX_BIT_RATE_MP3);
97 audioMp3Capability.channels = Range(1, MAX_CHANNEL_COUNT_MP3);
98 audioMp3Capability.sampleRate = AUDIO_MP3_EN_SAMPLE_RATE;
99 audioMp3Capability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
100 return audioMp3Capability;
101 }
102
GetAacDecoderCapability()103 CapabilityData AudioCodeclistInfo::GetAacDecoderCapability()
104 {
105 CapabilityData audioAacCapability;
106 audioAacCapability.codecName = AVCodecCodecName::AUDIO_DECODER_AAC_NAME;
107 audioAacCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
108 audioAacCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AAC;
109 audioAacCapability.isVendor = false;
110 audioAacCapability.bitrate = Range(MIN_BIT_RATE_AAC, MAX_BIT_RATE_AAC);
111 audioAacCapability.channels = Range(1, MAX_AUDIO_CHANNEL_COUNT);
112 audioAacCapability.sampleRate = AUDIO_SAMPLE_RATE;
113 audioAacCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
114 return audioAacCapability;
115 }
116
GetOpusDecoderCapability()117 CapabilityData AudioCodeclistInfo::GetOpusDecoderCapability()
118 {
119 CapabilityData audioOpusCapability;
120 audioOpusCapability.codecName = AVCodecCodecName::AUDIO_DECODER_OPUS_NAME;
121 audioOpusCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
122 audioOpusCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_OPUS;
123 audioOpusCapability.isVendor = false;
124 audioOpusCapability.bitrate = Range(1, MAX_BIT_RATE_OPUS);
125 audioOpusCapability.channels = Range(1, MAX_AUDIO_CHANNEL_COUNT);
126 audioOpusCapability.sampleRate = AUDIO_SAMPLE_RATE;
127 audioOpusCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
128 return audioOpusCapability;
129 }
130
GetFlacDecoderCapability()131 CapabilityData AudioCodeclistInfo::GetFlacDecoderCapability()
132 {
133 CapabilityData audioFlacCapability;
134 audioFlacCapability.codecName = AVCodecCodecName::AUDIO_DECODER_FLAC_NAME;
135 audioFlacCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
136 audioFlacCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_FLAC;
137 audioFlacCapability.isVendor = false;
138 audioFlacCapability.bitrate = Range(1, MAX_BIT_RATE_FLAC);
139 audioFlacCapability.channels = Range(1, MAX_AUDIO_CHANNEL_COUNT);
140 audioFlacCapability.sampleRate = AUDIO_FLAC_SAMPLE_RATE;
141 audioFlacCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
142 return audioFlacCapability;
143 }
144
GetVorbisDecoderCapability()145 CapabilityData AudioCodeclistInfo::GetVorbisDecoderCapability()
146 {
147 CapabilityData audioVorbisCapability;
148 audioVorbisCapability.codecName = AVCodecCodecName::AUDIO_DECODER_VORBIS_NAME;
149 audioVorbisCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
150 audioVorbisCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_VORBIS;
151 audioVorbisCapability.isVendor = false;
152 audioVorbisCapability.bitrate = Range(MIN_BIT_RATE_VORBIS, MAX_BIT_RATE_VORBIS);
153 audioVorbisCapability.channels = Range(1, MAX_AUDIO_CHANNEL_COUNT);
154 audioVorbisCapability.sampleRate = AUDIO_VORBIS_SAMPLE_RATE;
155 audioVorbisCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
156 return audioVorbisCapability;
157 }
158
GetAmrnbDecoderCapability()159 CapabilityData AudioCodeclistInfo::GetAmrnbDecoderCapability()
160 {
161 CapabilityData audioAmrnbCapability;
162 audioAmrnbCapability.codecName = AVCodecCodecName::AUDIO_DECODER_AMRNB_NAME;
163 audioAmrnbCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
164 audioAmrnbCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRNB;
165 audioAmrnbCapability.isVendor = false;
166 audioAmrnbCapability.bitrate = Range(1, MAX_BIT_RATE_AMRNB);
167 audioAmrnbCapability.channels = Range(1, 1);
168 audioAmrnbCapability.sampleRate = AUDIO_AMRNB_SAMPLE_RATE;
169 audioAmrnbCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
170 return audioAmrnbCapability;
171 }
172
GetAmrwbDecoderCapability()173 CapabilityData AudioCodeclistInfo::GetAmrwbDecoderCapability()
174 {
175 CapabilityData audioAmrwbCapability;
176 audioAmrwbCapability.codecName = AVCodecCodecName::AUDIO_DECODER_AMRWB_NAME;
177 audioAmrwbCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
178 audioAmrwbCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRWB;
179 audioAmrwbCapability.isVendor = false;
180 audioAmrwbCapability.bitrate = Range(1, MAX_BIT_RATE_AMRWB);
181 audioAmrwbCapability.channels = Range(1, 1);
182 audioAmrwbCapability.sampleRate = AUDIO_AMRWB_SAMPLE_RATE;
183 audioAmrwbCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
184 return audioAmrwbCapability;
185 }
186
GetAPEDecoderCapability()187 CapabilityData AudioCodeclistInfo::GetAPEDecoderCapability()
188 {
189 CapabilityData audioApeCapability;
190 audioApeCapability.codecName = AVCodecCodecName::AUDIO_DECODER_APE_NAME;
191 audioApeCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
192 audioApeCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_APE;
193 audioApeCapability.isVendor = false;
194 audioApeCapability.bitrate = Range(0, MAX_BIT_RATE_APE);
195 audioApeCapability.channels = Range(1, MAX_CHANNEL_COUNT_APE);
196 audioApeCapability.sampleRate = AUDIO_SAMPLE_RATE;
197 audioApeCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
198 return audioApeCapability;
199 }
200
201 #ifdef AV_CODEC_AUDIO_VIVID_CAPACITY
GetVividDecoderCapability()202 CapabilityData AudioCodeclistInfo::GetVividDecoderCapability()
203 {
204 CapabilityData audioVividCapability;
205 audioVividCapability.codecName = AVCodecCodecName::AUDIO_DECODER_VIVID_NAME;
206 audioVividCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
207 audioVividCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_VIVID;
208 audioVividCapability.isVendor = false;
209 audioVividCapability.bitrate = Range(MIN_BIT_RATE_VIVID_DECODER, MAX_BIT_RATE_VIVID_DECODER);
210 audioVividCapability.channels = Range(1, MAX_CHANNEL_COUNT_VIVID);
211 audioVividCapability.sampleRate = AUDIO_VIVID_SAMPLE_RATE;
212 audioVividCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
213 return audioVividCapability;
214 }
215
GetAmrnbEncoderCapability()216 CapabilityData AudioCodeclistInfo::GetAmrnbEncoderCapability()
217 {
218 CapabilityData audioAmrnbCapability;
219 audioAmrnbCapability.codecName = AVCodecCodecName::AUDIO_ENCODER_AMRNB_NAME;
220 audioAmrnbCapability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
221 audioAmrnbCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRNB;
222 audioAmrnbCapability.isVendor = false;
223 audioAmrnbCapability.bitrate = Range(1, MAX_BIT_RATE_AMRNB);
224 audioAmrnbCapability.channels = Range(1, 1);
225 audioAmrnbCapability.sampleRate = AUDIO_AMRNB_SAMPLE_RATE;
226 audioAmrnbCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
227 return audioAmrnbCapability;
228 }
229
GetAmrwbEncoderCapability()230 CapabilityData AudioCodeclistInfo::GetAmrwbEncoderCapability()
231 {
232 CapabilityData audioAmrwbCapability;
233 audioAmrwbCapability.codecName = AVCodecCodecName::AUDIO_ENCODER_AMRWB_NAME;
234 audioAmrwbCapability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
235 audioAmrwbCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRWB;
236 audioAmrwbCapability.isVendor = false;
237 audioAmrwbCapability.bitrate = Range(1, MAX_BIT_RATE_AMRWB);
238 audioAmrwbCapability.channels = Range(1, 1);
239 audioAmrwbCapability.sampleRate = AUDIO_AMRWB_SAMPLE_RATE;
240 audioAmrwbCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
241 return audioAmrwbCapability;
242 }
243
GetLbvcDecoderCapability()244 CapabilityData AudioCodeclistInfo::GetLbvcDecoderCapability()
245 {
246 CapabilityData audioLbvcCapability;
247
248 std::shared_ptr<Media::Plugins::Hdi::HdiCodec> hdiCodec_;
249 hdiCodec_ = std::make_shared<Media::Plugins::Hdi::HdiCodec>();
250 if (!hdiCodec_->IsSupportCodecType("OMX.audio.decoder.lbvc")) {
251 audioLbvcCapability.codecName = "";
252 audioLbvcCapability.mimeType = "";
253 audioLbvcCapability.maxInstance = 0;
254 audioLbvcCapability.codecType = AVCODEC_TYPE_NONE;
255 audioLbvcCapability.isVendor = false;
256 audioLbvcCapability.bitrate = Range(0, 0);
257 audioLbvcCapability.channels = Range(0, 0);
258 audioLbvcCapability.sampleRate = {0};
259 return audioLbvcCapability;
260 }
261 audioLbvcCapability.codecName = AVCodecCodecName::AUDIO_DECODER_LBVC_NAME;
262 audioLbvcCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
263 audioLbvcCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_LBVC;
264 audioLbvcCapability.isVendor = true;
265 audioLbvcCapability.bitrate = Range(MAX_BIT_RATE_LBVC, MAX_BIT_RATE_LBVC);
266 audioLbvcCapability.channels = Range(1, 1);
267 audioLbvcCapability.sampleRate = AUDIO_LBVC_SAMPLE_RATE;
268 audioLbvcCapability.maxInstance = 1;
269 return audioLbvcCapability;
270 }
271
GetLbvcEncoderCapability()272 CapabilityData AudioCodeclistInfo::GetLbvcEncoderCapability()
273 {
274 CapabilityData audioLbvcCapability;
275
276 std::shared_ptr<Media::Plugins::Hdi::HdiCodec> hdiCodec_;
277 hdiCodec_ = std::make_shared<Media::Plugins::Hdi::HdiCodec>();
278 if (!hdiCodec_->IsSupportCodecType("OMX.audio.encoder.lbvc")) {
279 audioLbvcCapability.codecName = "";
280 audioLbvcCapability.mimeType = "";
281 audioLbvcCapability.maxInstance = 0;
282 audioLbvcCapability.codecType = AVCODEC_TYPE_NONE;
283 audioLbvcCapability.isVendor = false;
284 audioLbvcCapability.bitrate = Range(0, 0);
285 audioLbvcCapability.channels = Range(0, 0);
286 audioLbvcCapability.sampleRate = {0};
287 return audioLbvcCapability;
288 }
289 audioLbvcCapability.codecName = AVCodecCodecName::AUDIO_ENCODER_LBVC_NAME;
290 audioLbvcCapability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
291 audioLbvcCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_LBVC;
292 audioLbvcCapability.isVendor = true;
293 audioLbvcCapability.bitrate = Range(MAX_BIT_RATE_LBVC, MAX_BIT_RATE_LBVC);
294 audioLbvcCapability.channels = Range(1, 1);
295 audioLbvcCapability.sampleRate = AUDIO_LBVC_SAMPLE_RATE;
296 audioLbvcCapability.maxInstance = 1;
297 return audioLbvcCapability;
298 }
299
GetVendorAacEncoderCapability()300 CapabilityData AudioCodeclistInfo::GetVendorAacEncoderCapability()
301 {
302 std::unique_ptr<std::ifstream> libFile = std::make_unique<std::ifstream>(VENDOR_AAC_LIB_PATH, std::ios::binary);
303 CapabilityData audioAacCapability;
304 if (!libFile->is_open()) {
305 audioAacCapability.codecName = "";
306 audioAacCapability.mimeType = "";
307 audioAacCapability.maxInstance = 0;
308 audioAacCapability.codecType = AVCODEC_TYPE_NONE;
309 audioAacCapability.isVendor = false;
310 audioAacCapability.bitrate = Range(0, 0);
311 audioAacCapability.channels = Range(0, 0);
312 audioAacCapability.sampleRate = {0};
313 return audioAacCapability;
314 }
315 libFile->close();
316 audioAacCapability.codecName = AVCodecCodecName::AUDIO_ENCODER_VENDOR_AAC_NAME;
317 audioAacCapability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
318 audioAacCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AAC;
319 audioAacCapability.isVendor = false;
320 audioAacCapability.bitrate = Range(MIN_BIT_RATE_AAC_ENCODER, MAX_BIT_RATE_AAC_ENCODER);
321 audioAacCapability.channels = Range(1, MAX_AUDIO_CHANNEL_COUNT);
322 audioAacCapability.sampleRate = AUDIO_SAMPLE_RATE;
323 audioAacCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
324 audioAacCapability.profiles = { AAC_PROFILE_LC, AAC_PROFILE_HE, AAC_PROFILE_HE_V2 };
325 audioAacCapability.rank = 1; // larger than default rank 0
326 return audioAacCapability;
327 }
328 #endif
329
GetAacEncoderCapability()330 CapabilityData AudioCodeclistInfo::GetAacEncoderCapability()
331 {
332 CapabilityData audioAacCapability;
333 audioAacCapability.codecName = AVCodecCodecName::AUDIO_ENCODER_AAC_NAME;
334 audioAacCapability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
335 audioAacCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AAC;
336 audioAacCapability.isVendor = false;
337 audioAacCapability.bitrate = Range(MIN_BIT_RATE_AAC_ENCODER, MAX_BIT_RATE_AAC_ENCODER);
338 audioAacCapability.channels = Range(1, MAX_AUDIO_CHANNEL_COUNT);
339 audioAacCapability.sampleRate = AUDIO_SAMPLE_RATE;
340 audioAacCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
341 audioAacCapability.profiles = { AAC_PROFILE_LC };
342 return audioAacCapability;
343 }
344
GetOpusEncoderCapability()345 CapabilityData AudioCodeclistInfo::GetOpusEncoderCapability()
346 {
347 CapabilityData audioOpusCapability;
348 audioOpusCapability.codecName = AVCodecCodecName::AUDIO_ENCODER_OPUS_NAME;
349 audioOpusCapability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
350 audioOpusCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_OPUS;
351 audioOpusCapability.isVendor = false;
352 audioOpusCapability.bitrate = Range(1, MAX_BIT_RATE_OPUS);
353 audioOpusCapability.channels = Range(1, MAX_AUDIO_CHANNEL_COUNT);
354 audioOpusCapability.sampleRate = AUDIO_SAMPLE_RATE;
355 audioOpusCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
356 return audioOpusCapability;
357 }
358
GetFlacEncoderCapability()359 CapabilityData AudioCodeclistInfo::GetFlacEncoderCapability()
360 {
361 CapabilityData audioFlacCapability;
362 audioFlacCapability.codecName = AVCodecCodecName::AUDIO_ENCODER_FLAC_NAME;
363 audioFlacCapability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
364 audioFlacCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_FLAC;
365 audioFlacCapability.isVendor = false;
366 audioFlacCapability.bitrate = Range(1, MAX_BIT_RATE_FLAC);
367 audioFlacCapability.channels = Range(1, MAX_AUDIO_CHANNEL_COUNT);
368 audioFlacCapability.sampleRate = AUDIO_SAMPLE_RATE;
369 audioFlacCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
370 return audioFlacCapability;
371 }
372
GetG711muDecoderCapability()373 CapabilityData AudioCodeclistInfo::GetG711muDecoderCapability()
374 {
375 CapabilityData audioG711muDecoderCapability;
376 audioG711muDecoderCapability.codecName = AVCodecCodecName::AUDIO_DECODER_G711MU_NAME;
377 audioG711muDecoderCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
378 audioG711muDecoderCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_G711MU;
379 audioG711muDecoderCapability.isVendor = false;
380 audioG711muDecoderCapability.bitrate = Range(1, MAX_BIT_RATE_G711MU_DECODER);
381 audioG711muDecoderCapability.channels = Range(1, 1);
382 audioG711muDecoderCapability.sampleRate = AUDIO_G711MU_SAMPLE_RATE;
383 audioG711muDecoderCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
384 return audioG711muDecoderCapability;
385 }
386
GetG711muEncoderCapability()387 CapabilityData AudioCodeclistInfo::GetG711muEncoderCapability()
388 {
389 CapabilityData audioG711muEncoderCapability;
390 audioG711muEncoderCapability.codecName = AVCodecCodecName::AUDIO_ENCODER_G711MU_NAME;
391 audioG711muEncoderCapability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
392 audioG711muEncoderCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_G711MU;
393 audioG711muEncoderCapability.isVendor = false;
394 audioG711muEncoderCapability.bitrate = Range(1, MAX_BIT_RATE_G711MU_ENCODER);
395 audioG711muEncoderCapability.channels = Range(1, 1);
396 audioG711muEncoderCapability.sampleRate = AUDIO_G711MU_SAMPLE_RATE;
397 audioG711muEncoderCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
398 return audioG711muEncoderCapability;
399 }
400
AudioCodeclistInfo()401 AudioCodeclistInfo::AudioCodeclistInfo()
402 {
403 audioCapabilities_ = {
404 #ifdef AV_CODEC_AUDIO_VIVID_CAPACITY
405 GetVendorAacEncoderCapability(),
406 #endif
407 GetMP3DecoderCapability(), GetAacDecoderCapability(), GetFlacDecoderCapability(),
408 GetOpusDecoderCapability(), GetVorbisDecoderCapability(), GetAmrnbDecoderCapability(),
409 GetAmrwbDecoderCapability(), GetG711muDecoderCapability(), GetAacEncoderCapability(),
410 GetFlacEncoderCapability(), GetOpusEncoderCapability(), GetG711muEncoderCapability(),
411 GetAPEDecoderCapability(), GetMP3EncoderCapability(),
412 #ifdef AV_CODEC_AUDIO_VIVID_CAPACITY
413 GetVividDecoderCapability(), GetAmrnbEncoderCapability(), GetAmrwbEncoderCapability(),
414 GetLbvcDecoderCapability(), GetLbvcEncoderCapability(),
415 #endif
416 };
417 }
418
~AudioCodeclistInfo()419 AudioCodeclistInfo::~AudioCodeclistInfo()
420 {
421 audioCapabilities_.clear();
422 }
423
GetInstance()424 AudioCodeclistInfo &AudioCodeclistInfo::GetInstance()
425 {
426 static AudioCodeclistInfo audioCodecList;
427 return audioCodecList;
428 }
429
GetAudioCapabilities() const430 std::vector<CapabilityData> AudioCodeclistInfo::GetAudioCapabilities() const noexcept
431 {
432 return audioCapabilities_;
433 }
434 } // namespace MediaAVCodec
435 } // namespace OHOS