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