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 MIN_BIT_RATE_MP3_ENCODE = 8000;
32 constexpr int MAX_CHANNEL_COUNT_MP3 = 2;
33 constexpr int MAX_CHANNEL_COUNT_APE = 2;
34 constexpr int MAX_CHANNEL_COUNT_RAW = 16;
35 constexpr int MAX_CHANNEL_COUNT_G711A = 6;
36
37 constexpr int MIN_BIT_RATE_AAC = 8000;
38 constexpr int MAX_BIT_RATE_AAC = 960000;
39 constexpr int MIN_VORBIS_SAMPLE_RATE = 8000;
40 constexpr int MAX_VORBIS_SAMPLE_RATE = 96000;
41 constexpr int MIN_FLAC_SAMPLE_RATE = 8000;
42 constexpr int MAX_FLAC_SAMPLE_RATE = 384000;
43 constexpr int MAX_INT32 = 0x7FFFFFFF; // 2147483647
44
45 const std::vector<int32_t> AUDIO_VORBIS_SAMPLE_RATE = {8000, 11025, 12000, 16000, 22050, 24000,
46 32000, 44100, 48000, 64000, 88200, 96000};
47 const std::vector<int32_t> AUDIO_AMRNB_SAMPLE_RATE = {8000};
48
49 const std::vector<int32_t> AUDIO_AMRWB_SAMPLE_RATE = {16000};
50
51 const std::vector<int32_t> AUDIO_G711MU_SAMPLE_RATE = {8000};
52
53 const std::vector<int32_t> AUDIO_G711A_SAMPLE_RATE = {8000, 11025, 12000, 16000, 22050, 24000, 32000,
54 44100, 48000};
55
56 const std::vector<int32_t> AUDIO_FLAC_SAMPLE_RATE = {8000, 11025, 12000, 16000, 22050, 24000, 32000,
57 44100, 48000, 64000, 88200, 96000, 192000};
58
59 const std::vector<int32_t> AUDIO_FLAC_ENC_SAMPLE_RATE = {8000, 16000, 22050, 24000, 32000,
60 44100, 48000, 88200, 96000};
61
62 const std::vector<int32_t> AUDIO_AAC_SAMPLE_RATE = {7350, 8000, 11025, 12000, 16000, 22050, 24000, 32000,
63 44100, 48000, 64000, 88200, 96000};
64
65 const std::vector<int32_t> AUDIO_MP3_SAMPLE_RATE = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000};
66 const std::vector<int32_t> AUDIO_RAW_SAMPLE_RATE = {8000, 11025, 12000, 16000, 22050, 24000, 32000,
67 44100, 48000, 64000, 88200, 96000, 192000};
68
69 constexpr int MIN_BIT_RATE_FLAC = 32000;
70 constexpr int MAX_BIT_RATE_FLAC = 1536000;
71 constexpr int MIN_FLAC_COMPLIANCE_LEVEL = -2;
72 constexpr int MAX_FLAC_COMPLIANCE_LEVEL = 2;
73 constexpr int MAX_BIT_RATE_APE = 2100000;
74 constexpr int MIN_BIT_RATE_VORBIS = 32000;
75 constexpr int MAX_BIT_RATE_VORBIS = 500000;
76
77 constexpr int MIN_BIT_RATE_AMRWB = 6600;
78 constexpr int MAX_BIT_RATE_AMRWB = 23850;
79 constexpr int MIN_BIT_RATE_AMRNB = 4750;
80 constexpr int MAX_BIT_RATE_AMRNB = 12200;
81
82 constexpr int MIN_BIT_RATE_AAC_ENCODER = 1;
83 constexpr int MAX_BIT_RATE_AAC_ENCODER = 500000;
84
85 constexpr int MAX_BIT_RATE_RAW = 1536000;
86
87 #ifdef AV_CODEC_AUDIO_VIVID_CAPACITY
88 const std::vector<int32_t> AUDIO_VIVID_SAMPLE_RATE = {32000, 44100, 48000, 96000, 192000};
89 constexpr int MIN_BIT_RATE_VIVID_DECODER = 16000;
90 constexpr int MAX_BIT_RATE_VIVID_DECODER = 3075000;
91 constexpr int MAX_CHANNEL_COUNT_VIVID = 16;
92 const std::vector<int32_t> AUDIO_L2HC_SAMPLE_RATE = {44100, 48000, 88200, 96000, 176400, 192000};
93 constexpr int MIN_BITRATE_L2HC = 160000;
94 constexpr int MAX_BITRATE_L2HC = 10000000;
95 constexpr int MAX_CHANNEL_COUNT_L2HC = 12;
96 constexpr int MAX_SUPPORT_L2HC_VERSION = 4;
97 constexpr int MIN_BIT_RATE_OPUS = 6000;
98 constexpr int MAX_BIT_RATE_OPUS = 510000;
99 constexpr int MIN_OPUS_COMPLIANCE_LEVEL = 1;
100 constexpr int MAX_OPUS_COMPLIANCE_LEVEL = 10;
101 constexpr int MAX_CHANNEL_COUNT_OPUS = 2;
102 const std::vector<int32_t> AUDIO_OPUS_SAMPLE_RATE = {8000, 12000, 16000, 24000, 48000};
103 #endif
104 #ifdef SUPPORT_CODEC_COOK
105 constexpr int MAX_BIT_RATE_COOK = 510000;
106 const std::vector<int32_t> AUDIO_COOK_SAMPLE_RATE = {8000, 11025, 22050, 44100};
107 #endif
108 constexpr int MIN_BIT_RATE_AC3 = 32000;
109 constexpr int MAX_BIT_RATE_AC3 = 640000;
110 const std::vector<int32_t> AUDIO_AC3_SAMPLE_RATE = {32000, 44100, 48000};
111 constexpr int MAX_BIT_RATE_G711MU_DECODER = 64000;
112 constexpr int MAX_BIT_RATE_G711MU_ENCODER = 64000;
113 constexpr int MAX_BIT_RATE_G711A_DECODER = 64000;
114
115 const std::string VENDOR_AAC_LIB_PATH = std::string(AV_CODEC_PATH) + "/libaudiocodec_aac_proxy_1.0.z.so";
116
convertVectorToRange(const std::vector<int32_t> sampleRate)117 static std::vector<Range> convertVectorToRange(const std::vector<int32_t> sampleRate)
118 {
119 std::vector<Range> sampleRateRange;
120 uint32_t sampleRateSize = sampleRate.size();
121 for (uint32_t i = 0; i < sampleRateSize; i++) {
122 sampleRateRange.push_back(Range(sampleRate[i], sampleRate[i]));
123 }
124 return sampleRateRange;
125 }
126
GetMP3DecoderCapability()127 CapabilityData AudioCodeclistInfo::GetMP3DecoderCapability()
128 {
129 CapabilityData audioMp3Capability;
130 audioMp3Capability.codecName = AVCodecCodecName::AUDIO_DECODER_MP3_NAME;
131 audioMp3Capability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
132 audioMp3Capability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_MPEG;
133 audioMp3Capability.isVendor = false;
134 audioMp3Capability.bitrate = Range(MIN_BIT_RATE_MP3, MAX_BIT_RATE_MP3);
135 audioMp3Capability.channels = Range(1, MAX_CHANNEL_COUNT_MP3);
136 audioMp3Capability.sampleRate = AUDIO_MP3_SAMPLE_RATE;
137 audioMp3Capability.sampleRateRanges = convertVectorToRange(AUDIO_MP3_SAMPLE_RATE);
138 audioMp3Capability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
139 return audioMp3Capability;
140 }
141
GetMP3EncoderCapability()142 CapabilityData AudioCodeclistInfo::GetMP3EncoderCapability()
143 {
144 CapabilityData audioMp3Capability;
145 audioMp3Capability.codecName = AVCodecCodecName::AUDIO_ENCODER_MP3_NAME;
146 audioMp3Capability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
147 audioMp3Capability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_MPEG;
148 audioMp3Capability.isVendor = false;
149 audioMp3Capability.bitrate = Range(MIN_BIT_RATE_MP3_ENCODE, MAX_BIT_RATE_MP3);
150 audioMp3Capability.channels = Range(1, MAX_CHANNEL_COUNT_MP3);
151 audioMp3Capability.sampleRate = AUDIO_MP3_SAMPLE_RATE;
152 audioMp3Capability.sampleRateRanges = convertVectorToRange(AUDIO_MP3_SAMPLE_RATE);
153 audioMp3Capability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
154 return audioMp3Capability;
155 }
156
GetAacDecoderCapability()157 CapabilityData AudioCodeclistInfo::GetAacDecoderCapability()
158 {
159 CapabilityData audioAacCapability;
160 audioAacCapability.codecName = AVCodecCodecName::AUDIO_DECODER_AAC_NAME;
161 audioAacCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
162 audioAacCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AAC;
163 audioAacCapability.isVendor = false;
164 audioAacCapability.bitrate = Range(MIN_BIT_RATE_AAC, MAX_BIT_RATE_AAC);
165 audioAacCapability.channels = Range(1, MAX_AUDIO_CHANNEL_COUNT);
166 audioAacCapability.sampleRate = AUDIO_AAC_SAMPLE_RATE;
167 audioAacCapability.sampleRateRanges = convertVectorToRange(AUDIO_AAC_SAMPLE_RATE);
168 audioAacCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
169 return audioAacCapability;
170 }
171
GetFlacDecoderCapability()172 CapabilityData AudioCodeclistInfo::GetFlacDecoderCapability()
173 {
174 CapabilityData audioFlacCapability;
175 audioFlacCapability.codecName = AVCodecCodecName::AUDIO_DECODER_FLAC_NAME;
176 audioFlacCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
177 audioFlacCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_FLAC;
178 audioFlacCapability.isVendor = false;
179 audioFlacCapability.bitrate = Range(1, MAX_BIT_RATE_FLAC);
180 audioFlacCapability.channels = Range(1, MAX_AUDIO_CHANNEL_COUNT);
181 audioFlacCapability.sampleRate = AUDIO_FLAC_SAMPLE_RATE;
182 audioFlacCapability.sampleRateRanges = {Range(MIN_FLAC_SAMPLE_RATE, MAX_FLAC_SAMPLE_RATE)};
183 audioFlacCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
184 return audioFlacCapability;
185 }
186
GetVorbisDecoderCapability()187 CapabilityData AudioCodeclistInfo::GetVorbisDecoderCapability()
188 {
189 CapabilityData audioVorbisCapability;
190 audioVorbisCapability.codecName = AVCodecCodecName::AUDIO_DECODER_VORBIS_NAME;
191 audioVorbisCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
192 audioVorbisCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_VORBIS;
193 audioVorbisCapability.isVendor = false;
194 audioVorbisCapability.bitrate = Range(MIN_BIT_RATE_VORBIS, MAX_BIT_RATE_VORBIS);
195 audioVorbisCapability.channels = Range(1, MAX_AUDIO_CHANNEL_COUNT);
196 audioVorbisCapability.sampleRate = AUDIO_VORBIS_SAMPLE_RATE;
197 audioVorbisCapability.sampleRateRanges = {Range(MIN_VORBIS_SAMPLE_RATE, MAX_VORBIS_SAMPLE_RATE)};
198 audioVorbisCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
199 return audioVorbisCapability;
200 }
201
GetAmrnbDecoderCapability()202 CapabilityData AudioCodeclistInfo::GetAmrnbDecoderCapability()
203 {
204 CapabilityData audioAmrnbCapability;
205 audioAmrnbCapability.codecName = AVCodecCodecName::AUDIO_DECODER_AMRNB_NAME;
206 audioAmrnbCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
207 audioAmrnbCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRNB;
208 audioAmrnbCapability.isVendor = false;
209 audioAmrnbCapability.bitrate = Range(MIN_BIT_RATE_AMRNB, MAX_BIT_RATE_AMRNB);
210 audioAmrnbCapability.channels = Range(1, 1);
211 audioAmrnbCapability.sampleRate = AUDIO_AMRNB_SAMPLE_RATE;
212 audioAmrnbCapability.sampleRateRanges = convertVectorToRange(AUDIO_AMRNB_SAMPLE_RATE);
213 audioAmrnbCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
214 return audioAmrnbCapability;
215 }
216
GetAmrwbDecoderCapability()217 CapabilityData AudioCodeclistInfo::GetAmrwbDecoderCapability()
218 {
219 CapabilityData audioAmrwbCapability;
220 audioAmrwbCapability.codecName = AVCodecCodecName::AUDIO_DECODER_AMRWB_NAME;
221 audioAmrwbCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
222 audioAmrwbCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRWB;
223 audioAmrwbCapability.isVendor = false;
224 audioAmrwbCapability.bitrate = Range(MIN_BIT_RATE_AMRWB, MAX_BIT_RATE_AMRWB);
225 audioAmrwbCapability.channels = Range(1, 1);
226 audioAmrwbCapability.sampleRate = AUDIO_AMRWB_SAMPLE_RATE;
227 audioAmrwbCapability.sampleRateRanges = convertVectorToRange(AUDIO_AMRWB_SAMPLE_RATE);
228 audioAmrwbCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
229 return audioAmrwbCapability;
230 }
231
GetAPEDecoderCapability()232 CapabilityData AudioCodeclistInfo::GetAPEDecoderCapability()
233 {
234 CapabilityData audioApeCapability;
235 audioApeCapability.codecName = AVCodecCodecName::AUDIO_DECODER_APE_NAME;
236 audioApeCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
237 audioApeCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_APE;
238 audioApeCapability.isVendor = false;
239 audioApeCapability.bitrate = Range(0, MAX_BIT_RATE_APE);
240 audioApeCapability.channels = Range(1, MAX_CHANNEL_COUNT_APE);
241 audioApeCapability.sampleRate = AUDIO_SAMPLE_RATE;
242 audioApeCapability.sampleRateRanges = {Range(1, MAX_INT32)};
243 audioApeCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
244 return audioApeCapability;
245 }
246
GetRawDecoderCapability()247 CapabilityData AudioCodeclistInfo::GetRawDecoderCapability()
248 {
249 CapabilityData audioRawCapability;
250 audioRawCapability.codecName = AVCodecCodecName::AUDIO_DECODER_RAW_NAME;
251 audioRawCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
252 audioRawCapability.mimeType = CodecMimeType::AUDIO_RAW;
253 audioRawCapability.isVendor = false;
254 audioRawCapability.bitrate = Range(0, MAX_BIT_RATE_RAW);
255 audioRawCapability.channels = Range(1, MAX_CHANNEL_COUNT_RAW);
256 audioRawCapability.sampleRate = AUDIO_RAW_SAMPLE_RATE;
257 audioRawCapability.sampleRateRanges = {Range(1, MAX_INT32)};
258 audioRawCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
259 return audioRawCapability;
260 }
261
262 #ifdef AV_CODEC_AUDIO_VIVID_CAPACITY
GetVividDecoderCapability()263 CapabilityData AudioCodeclistInfo::GetVividDecoderCapability()
264 {
265 CapabilityData audioVividCapability;
266 audioVividCapability.codecName = AVCodecCodecName::AUDIO_DECODER_VIVID_NAME;
267 audioVividCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
268 audioVividCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_VIVID;
269 audioVividCapability.isVendor = false;
270 audioVividCapability.bitrate = Range(MIN_BIT_RATE_VIVID_DECODER, MAX_BIT_RATE_VIVID_DECODER);
271 audioVividCapability.channels = Range(1, MAX_CHANNEL_COUNT_VIVID);
272 audioVividCapability.sampleRate = AUDIO_VIVID_SAMPLE_RATE;
273 audioVividCapability.sampleRateRanges = convertVectorToRange(AUDIO_VIVID_SAMPLE_RATE);
274 audioVividCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
275 return audioVividCapability;
276 }
277
GetAmrnbEncoderCapability()278 CapabilityData AudioCodeclistInfo::GetAmrnbEncoderCapability()
279 {
280 CapabilityData audioAmrnbCapability;
281 audioAmrnbCapability.codecName = AVCodecCodecName::AUDIO_ENCODER_AMRNB_NAME;
282 audioAmrnbCapability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
283 audioAmrnbCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRNB;
284 audioAmrnbCapability.isVendor = false;
285 audioAmrnbCapability.bitrate = Range(1, MAX_BIT_RATE_AMRNB);
286 audioAmrnbCapability.channels = Range(1, 1);
287 audioAmrnbCapability.sampleRate = AUDIO_AMRNB_SAMPLE_RATE;
288 audioAmrnbCapability.sampleRateRanges = convertVectorToRange(AUDIO_AMRNB_SAMPLE_RATE);
289 audioAmrnbCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
290 return audioAmrnbCapability;
291 }
292
GetAmrwbEncoderCapability()293 CapabilityData AudioCodeclistInfo::GetAmrwbEncoderCapability()
294 {
295 CapabilityData audioAmrwbCapability;
296 audioAmrwbCapability.codecName = AVCodecCodecName::AUDIO_ENCODER_AMRWB_NAME;
297 audioAmrwbCapability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
298 audioAmrwbCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRWB;
299 audioAmrwbCapability.isVendor = false;
300 audioAmrwbCapability.bitrate = Range(1, MAX_BIT_RATE_AMRWB);
301 audioAmrwbCapability.channels = Range(1, 1);
302 audioAmrwbCapability.sampleRate = AUDIO_AMRWB_SAMPLE_RATE;
303 audioAmrwbCapability.sampleRateRanges = convertVectorToRange(AUDIO_AMRWB_SAMPLE_RATE);
304 audioAmrwbCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
305 return audioAmrwbCapability;
306 }
307
GetLbvcDecoderCapability()308 CapabilityData AudioCodeclistInfo::GetLbvcDecoderCapability()
309 {
310 CapabilityData audioLbvcCapability;
311
312 std::shared_ptr<Media::Plugins::Hdi::HdiCodec> hdiCodec_;
313 hdiCodec_ = std::make_shared<Media::Plugins::Hdi::HdiCodec>();
314 if (!hdiCodec_->IsSupportCodecType("OMX.audio.decoder.lbvc", &audioLbvcCapability)) {
315 audioLbvcCapability.codecName = "";
316 audioLbvcCapability.mimeType = "";
317 audioLbvcCapability.maxInstance = 0;
318 audioLbvcCapability.codecType = AVCODEC_TYPE_NONE;
319 audioLbvcCapability.isVendor = false;
320 audioLbvcCapability.bitrate = Range(0, 0);
321 audioLbvcCapability.channels = Range(0, 0);
322 audioLbvcCapability.sampleRate = {0};
323 return audioLbvcCapability;
324 }
325 audioLbvcCapability.codecName = AVCodecCodecName::AUDIO_DECODER_LBVC_NAME;
326 audioLbvcCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
327 audioLbvcCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_LBVC;
328 audioLbvcCapability.isVendor = true;
329 return audioLbvcCapability;
330 }
331
GetLbvcEncoderCapability()332 CapabilityData AudioCodeclistInfo::GetLbvcEncoderCapability()
333 {
334 CapabilityData audioLbvcCapability;
335
336 std::shared_ptr<Media::Plugins::Hdi::HdiCodec> hdiCodec_;
337 hdiCodec_ = std::make_shared<Media::Plugins::Hdi::HdiCodec>();
338 if (!hdiCodec_->IsSupportCodecType("OMX.audio.encoder.lbvc", &audioLbvcCapability)) {
339 audioLbvcCapability.codecName = "";
340 audioLbvcCapability.mimeType = "";
341 audioLbvcCapability.maxInstance = 0;
342 audioLbvcCapability.codecType = AVCODEC_TYPE_NONE;
343 audioLbvcCapability.isVendor = false;
344 audioLbvcCapability.bitrate = Range(0, 0);
345 audioLbvcCapability.channels = Range(0, 0);
346 audioLbvcCapability.sampleRate = {0};
347 return audioLbvcCapability;
348 }
349 audioLbvcCapability.codecName = AVCodecCodecName::AUDIO_ENCODER_LBVC_NAME;
350 audioLbvcCapability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
351 audioLbvcCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_LBVC;
352 audioLbvcCapability.isVendor = true;
353 return audioLbvcCapability;
354 }
355
GetL2hcEncoderCapability()356 CapabilityData AudioCodeclistInfo::GetL2hcEncoderCapability()
357 {
358 CapabilityData l2hcEncodeCapability;
359 l2hcEncodeCapability.codecName = AVCodecCodecName::AUDIO_ENCODER_L2HC_NAME;
360 l2hcEncodeCapability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
361 l2hcEncodeCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_L2HC;
362 l2hcEncodeCapability.isVendor = false;
363 l2hcEncodeCapability.bitrate = Range(MIN_BITRATE_L2HC, MAX_BITRATE_L2HC);
364 l2hcEncodeCapability.channels = Range(1, MAX_CHANNEL_COUNT_L2HC);
365 l2hcEncodeCapability.sampleRate = AUDIO_L2HC_SAMPLE_RATE;
366 l2hcEncodeCapability.sampleRateRanges = convertVectorToRange(AUDIO_L2HC_SAMPLE_RATE);
367 l2hcEncodeCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
368 l2hcEncodeCapability.maxVersion = MAX_SUPPORT_L2HC_VERSION;
369 return l2hcEncodeCapability;
370 }
371
GetL2hcDecoderCapability()372 CapabilityData AudioCodeclistInfo::GetL2hcDecoderCapability()
373 {
374 CapabilityData l2hcDecodeCapability;
375 l2hcDecodeCapability.codecName = AVCodecCodecName::AUDIO_DECODER_L2HC_NAME;
376 l2hcDecodeCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
377 l2hcDecodeCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_L2HC;
378 l2hcDecodeCapability.isVendor = false;
379 l2hcDecodeCapability.bitrate = Range(0, 0);
380 l2hcDecodeCapability.channels = Range(1, MAX_CHANNEL_COUNT_L2HC);
381 l2hcDecodeCapability.sampleRate = AUDIO_L2HC_SAMPLE_RATE;
382 l2hcDecodeCapability.sampleRateRanges = convertVectorToRange(AUDIO_L2HC_SAMPLE_RATE);
383 l2hcDecodeCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
384 l2hcDecodeCapability.maxVersion = MAX_SUPPORT_L2HC_VERSION;
385 return l2hcDecodeCapability;
386 }
387
GetVendorAacEncoderCapability()388 CapabilityData AudioCodeclistInfo::GetVendorAacEncoderCapability()
389 {
390 std::unique_ptr<std::ifstream> libFile = std::make_unique<std::ifstream>(VENDOR_AAC_LIB_PATH, std::ios::binary);
391 CapabilityData audioAacCapability;
392 if (!libFile->is_open()) {
393 audioAacCapability.codecName = "";
394 audioAacCapability.mimeType = "";
395 audioAacCapability.maxInstance = 0;
396 audioAacCapability.codecType = AVCODEC_TYPE_NONE;
397 audioAacCapability.isVendor = false;
398 audioAacCapability.bitrate = Range(0, 0);
399 audioAacCapability.channels = Range(0, 0);
400 audioAacCapability.sampleRate = {0};
401 return audioAacCapability;
402 }
403 libFile->close();
404 audioAacCapability.codecName = AVCodecCodecName::AUDIO_ENCODER_VENDOR_AAC_NAME;
405 audioAacCapability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
406 audioAacCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AAC;
407 audioAacCapability.isVendor = false;
408 audioAacCapability.bitrate = Range(MIN_BIT_RATE_AAC_ENCODER, MAX_BIT_RATE_AAC_ENCODER);
409 audioAacCapability.channels = Range(1, MAX_AUDIO_CHANNEL_COUNT);
410 audioAacCapability.sampleRate = AUDIO_AAC_SAMPLE_RATE;
411 audioAacCapability.sampleRateRanges = convertVectorToRange(AUDIO_AAC_SAMPLE_RATE);
412 audioAacCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
413 audioAacCapability.profiles = { AAC_PROFILE_LC, AAC_PROFILE_HE, AAC_PROFILE_HE_V2 };
414 audioAacCapability.rank = 1; // larger than default rank 0
415 return audioAacCapability;
416 }
417
GetOpusEncoderCapability()418 CapabilityData AudioCodeclistInfo::GetOpusEncoderCapability()
419 {
420 CapabilityData audioOpusCapability;
421 audioOpusCapability.codecName = AVCodecCodecName::AUDIO_ENCODER_OPUS_NAME;
422 audioOpusCapability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
423 audioOpusCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_OPUS;
424 audioOpusCapability.isVendor = false;
425 audioOpusCapability.bitrate = Range(MIN_BIT_RATE_OPUS, MAX_BIT_RATE_OPUS);
426 audioOpusCapability.channels = Range(1, MAX_CHANNEL_COUNT_OPUS);
427 audioOpusCapability.sampleRate = AUDIO_OPUS_SAMPLE_RATE;
428 audioOpusCapability.sampleRateRanges = convertVectorToRange(AUDIO_OPUS_SAMPLE_RATE);
429 audioOpusCapability.complexity = Range(MIN_OPUS_COMPLIANCE_LEVEL, MAX_OPUS_COMPLIANCE_LEVEL);
430 audioOpusCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
431 return audioOpusCapability;
432 }
433
GetOpusDecoderCapability()434 CapabilityData AudioCodeclistInfo::GetOpusDecoderCapability()
435 {
436 CapabilityData audioOpusCapability;
437 audioOpusCapability.codecName = AVCodecCodecName::AUDIO_DECODER_OPUS_NAME;
438 audioOpusCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
439 audioOpusCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_OPUS;
440 audioOpusCapability.isVendor = false;
441 audioOpusCapability.bitrate = Range(1, MAX_BIT_RATE_OPUS);
442 audioOpusCapability.channels = Range(1, MAX_AUDIO_CHANNEL_COUNT);
443 audioOpusCapability.sampleRate = AUDIO_OPUS_SAMPLE_RATE;
444 audioOpusCapability.sampleRateRanges = convertVectorToRange(AUDIO_OPUS_SAMPLE_RATE);
445 audioOpusCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
446 return audioOpusCapability;
447 }
448 #endif
449
GetAacEncoderCapability()450 CapabilityData AudioCodeclistInfo::GetAacEncoderCapability()
451 {
452 CapabilityData audioAacCapability;
453 audioAacCapability.codecName = AVCodecCodecName::AUDIO_ENCODER_AAC_NAME;
454 audioAacCapability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
455 audioAacCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AAC;
456 audioAacCapability.isVendor = false;
457 audioAacCapability.bitrate = Range(MIN_BIT_RATE_AAC_ENCODER, MAX_BIT_RATE_AAC_ENCODER);
458 audioAacCapability.channels = Range(1, MAX_AUDIO_CHANNEL_COUNT);
459 audioAacCapability.sampleRate = AUDIO_AAC_SAMPLE_RATE;
460 audioAacCapability.sampleRateRanges = convertVectorToRange(AUDIO_AAC_SAMPLE_RATE);
461 audioAacCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
462 audioAacCapability.profiles = { AAC_PROFILE_LC };
463 return audioAacCapability;
464 }
465
GetFlacEncoderCapability()466 CapabilityData AudioCodeclistInfo::GetFlacEncoderCapability()
467 {
468 CapabilityData audioFlacCapability;
469 audioFlacCapability.codecName = AVCodecCodecName::AUDIO_ENCODER_FLAC_NAME;
470 audioFlacCapability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
471 audioFlacCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_FLAC;
472 audioFlacCapability.isVendor = false;
473 audioFlacCapability.bitrate = Range(MIN_BIT_RATE_FLAC, MAX_BIT_RATE_FLAC);
474 audioFlacCapability.channels = Range(1, MAX_AUDIO_CHANNEL_COUNT);
475 audioFlacCapability.sampleRate = AUDIO_FLAC_ENC_SAMPLE_RATE;
476 audioFlacCapability.sampleRateRanges = convertVectorToRange(AUDIO_FLAC_ENC_SAMPLE_RATE);
477 audioFlacCapability.complexity = Range(MIN_FLAC_COMPLIANCE_LEVEL, MAX_FLAC_COMPLIANCE_LEVEL);
478 audioFlacCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
479 return audioFlacCapability;
480 }
481
GetG711muDecoderCapability()482 CapabilityData AudioCodeclistInfo::GetG711muDecoderCapability()
483 {
484 CapabilityData audioG711muDecoderCapability;
485 audioG711muDecoderCapability.codecName = AVCodecCodecName::AUDIO_DECODER_G711MU_NAME;
486 audioG711muDecoderCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
487 audioG711muDecoderCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_G711MU;
488 audioG711muDecoderCapability.isVendor = false;
489 audioG711muDecoderCapability.bitrate = Range(1, MAX_BIT_RATE_G711MU_DECODER);
490 audioG711muDecoderCapability.channels = Range(1, 1);
491 audioG711muDecoderCapability.sampleRate = AUDIO_G711MU_SAMPLE_RATE;
492 audioG711muDecoderCapability.sampleRateRanges = convertVectorToRange(AUDIO_G711MU_SAMPLE_RATE);
493 audioG711muDecoderCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
494 return audioG711muDecoderCapability;
495 }
496
GetG711muEncoderCapability()497 CapabilityData AudioCodeclistInfo::GetG711muEncoderCapability()
498 {
499 CapabilityData audioG711muEncoderCapability;
500 audioG711muEncoderCapability.codecName = AVCodecCodecName::AUDIO_ENCODER_G711MU_NAME;
501 audioG711muEncoderCapability.codecType = AVCODEC_TYPE_AUDIO_ENCODER;
502 audioG711muEncoderCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_G711MU;
503 audioG711muEncoderCapability.isVendor = false;
504 // G.711 has only one bitrate 64K, bitrate is no need to set during encoding.
505 audioG711muEncoderCapability.bitrate = Range(MAX_BIT_RATE_G711MU_ENCODER, MAX_BIT_RATE_G711MU_ENCODER);
506 audioG711muEncoderCapability.channels = Range(1, 1);
507 audioG711muEncoderCapability.sampleRate = AUDIO_G711MU_SAMPLE_RATE;
508 audioG711muEncoderCapability.sampleRateRanges = convertVectorToRange(AUDIO_G711MU_SAMPLE_RATE);
509 audioG711muEncoderCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
510 return audioG711muEncoderCapability;
511 }
512
GetG711aDecoderCapability()513 CapabilityData AudioCodeclistInfo::GetG711aDecoderCapability()
514 {
515 CapabilityData audioG711aDecoderCapability;
516 audioG711aDecoderCapability.codecName = AVCodecCodecName::AUDIO_DECODER_G711A_NAME;
517 audioG711aDecoderCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
518 audioG711aDecoderCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_G711A;
519 audioG711aDecoderCapability.isVendor = false;
520 audioG711aDecoderCapability.bitrate = Range(1, MAX_BIT_RATE_G711A_DECODER);
521 audioG711aDecoderCapability.channels = Range(1, MAX_CHANNEL_COUNT_G711A);
522 audioG711aDecoderCapability.sampleRate = AUDIO_G711A_SAMPLE_RATE;
523 audioG711aDecoderCapability.sampleRateRanges = convertVectorToRange(AUDIO_G711A_SAMPLE_RATE);
524 audioG711aDecoderCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
525 return audioG711aDecoderCapability;
526 }
527
528 #ifdef SUPPORT_CODEC_COOK
GetCookDecoderCapability()529 CapabilityData AudioCodeclistInfo::GetCookDecoderCapability()
530 {
531 CapabilityData audioCookCapability;
532 audioCookCapability.codecName = AVCodecCodecName::AUDIO_DECODER_COOK_NAME;
533 audioCookCapability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
534 audioCookCapability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_COOK;
535 audioCookCapability.isVendor = false;
536 audioCookCapability.bitrate = Range(1, MAX_BIT_RATE_COOK);
537 audioCookCapability.channels = Range(1, MAX_AUDIO_CHANNEL_COUNT);
538 audioCookCapability.sampleRate = AUDIO_COOK_SAMPLE_RATE;
539 audioCookCapability.sampleRateRanges = convertVectorToRange(AUDIO_COOK_SAMPLE_RATE);
540 audioCookCapability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
541 return audioCookCapability;
542 }
543 #endif
544
GetAc3DecoderCapability()545 CapabilityData AudioCodeclistInfo::GetAc3DecoderCapability()
546 {
547 CapabilityData audioAc3Capability;
548 audioAc3Capability.codecName = AVCodecCodecName::AUDIO_DECODER_AC3_NAME;
549 audioAc3Capability.codecType = AVCODEC_TYPE_AUDIO_DECODER;
550 audioAc3Capability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AC3;
551 audioAc3Capability.isVendor = false;
552 audioAc3Capability.bitrate = Range(MIN_BIT_RATE_AC3, MAX_BIT_RATE_AC3);
553 audioAc3Capability.channels = Range(1, MAX_AUDIO_CHANNEL_COUNT);
554 audioAc3Capability.sampleRate = AUDIO_AC3_SAMPLE_RATE;
555 audioAc3Capability.sampleRateRanges = convertVectorToRange(AUDIO_AC3_SAMPLE_RATE);
556 audioAc3Capability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE;
557 return audioAc3Capability;
558 }
559
AudioCodeclistInfo()560 AudioCodeclistInfo::AudioCodeclistInfo()
561 {
562 audioCapabilities_ = {
563 #ifdef AV_CODEC_AUDIO_VIVID_CAPACITY
564 GetVendorAacEncoderCapability(),
565 #endif
566 GetMP3DecoderCapability(), GetAacDecoderCapability(), GetFlacDecoderCapability(),
567 GetVorbisDecoderCapability(), GetAmrnbDecoderCapability(), GetAmrwbDecoderCapability(),
568 GetG711muDecoderCapability(), GetRawDecoderCapability(), GetAacEncoderCapability(),
569 GetFlacEncoderCapability(), GetG711muEncoderCapability(), GetAPEDecoderCapability(),
570 GetMP3EncoderCapability(), GetG711aDecoderCapability(),
571 #ifdef AV_CODEC_AUDIO_VIVID_CAPACITY
572 GetVividDecoderCapability(), GetAmrnbEncoderCapability(), GetAmrwbEncoderCapability(),
573 GetLbvcDecoderCapability(), GetLbvcEncoderCapability(), GetL2hcEncoderCapability(),
574 GetL2hcDecoderCapability(), GetOpusDecoderCapability(), GetOpusEncoderCapability(),
575 #endif
576 #ifdef SUPPORT_CODEC_COOK
577 GetCookDecoderCapability(),
578 #endif
579 GetAc3DecoderCapability(),
580 };
581 }
582
~AudioCodeclistInfo()583 AudioCodeclistInfo::~AudioCodeclistInfo()
584 {
585 audioCapabilities_.clear();
586 }
587
GetInstance()588 AudioCodeclistInfo &AudioCodeclistInfo::GetInstance()
589 {
590 static AudioCodeclistInfo audioCodecList;
591 return audioCodecList;
592 }
593
GetAudioCapabilities() const594 std::vector<CapabilityData> AudioCodeclistInfo::GetAudioCapabilities() const noexcept
595 {
596 return audioCapabilities_;
597 }
598 } // namespace MediaAVCodec
599 } // namespace OHOS