1 /**
2 * Copyright (C) 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <ImsMediaAudioUtil.h>
18 #include <ImsMediaDefine.h>
19 #include <AudioConfig.h>
20 #include <ImsMediaTrace.h>
21 #include <string.h>
22
23 #define MAX_AMR_MODE 8
24 #define MAX_EVS_MODE 20
25
26 static const uint32_t gaAMRWBLen[32] = {
27 17, // 6.6
28 23, // 8.85
29 32, // 12.65
30 36, // 14.25
31 40, // 15.85
32 46, // 18.25
33 50, // 19.85
34 58, // 23.05
35 60, // 23.85
36 5, // SID
37 0,
38 };
39
40 static const uint32_t gaAMRWBbitLen[32] = {
41 132, // 6.6
42 177, // 8.85
43 253, // 12.65
44 285, // 14.25
45 317, // 15.85
46 365, // 18.25
47 397, // 19.85
48 461, // 23.05
49 477, // 23.85
50 40, // SID
51 0,
52 };
53
54 static const uint32_t gaEVSPrimaryByteLen[32] = {
55 7, // 2.8 special case
56 18, // 7.2
57 20, // 8.0
58 24, // 9.6
59 33, // 13.2
60 41, // 16.4
61 61, // 24.4
62 80, // 32.0
63 120, // 48.0
64 160, // 64.0
65 240, // 96.0
66 320, // 128.0
67 6, // SID
68 0,
69 };
70
71 static const uint32_t gaEVSPrimaryHeaderFullByteLen[32] = {
72 8, // 2.8 special case
73 19, // 7.2
74 21, // 8.0
75 25, // 9.6
76 34, // 13.2
77 42, // 16.4
78 62, // 24.4
79 81, // 32.0
80 121, // 48.0
81 161, // 64.0
82 241, // 96.0
83 321, // 128.0
84 7, // SID
85 };
86
87 static const uint32_t gaEVSPrimaryBitLen[32] = {
88 56, // 2.8 Special case
89 144, // 7.2
90 160, // 8.0
91 192, // 9.6
92 264, // 13.2
93 328, // 16.4
94 488, // 24.4
95 640, // 32.0
96 960, // 48.0
97 1280, // 64.0
98 1920, // 96.0
99 2560, // 128.0
100 48, // SID
101 0,
102 };
103
104 static const uint32_t gaEVSAMRWBIOLen[32] = {
105 17, // 6.6
106 23, // 8.85
107 32, // 12.65
108 36, // 14.25
109 40, // 15.85
110 46, // 18.25
111 50, // 19.85
112 58, // 23.05
113 60, // 23.85
114 5, // SID
115 0,
116 };
117
118 static const uint32_t gaEVSAmrWbIoBitLen[32] = {
119 136, // 6.6 AMR-WB IO
120 184, // 8.85 AMR-WB IO
121 256, // 12.65 AMR-WB IO
122 288, // 14.25 AMR-WB IO
123 320, // 15.85 AMR-WB IO
124 368, // 18.25 AMR-WB IO
125 400, // 19.85 AMR-WB IO
126 464, // 23.05 AMR-WB IO
127 480, // 23.85 AMR-WB IO
128 40, // SID for AMR-WB IO
129 0, /* Note that no Compact frame format EVS AMR-WB IO SID frames is defined.
130 For such frames the Header-Full format with CMR byte shall be used*/
131 };
132
133 static const uint32_t gaAMRLen[16] = {
134 12, // 4.75
135 13, // 5.15
136 15, // 5.90
137 17, // 6.70
138 19, // 7.40
139 20, // 7.95
140 26, // 10.20
141 31, // 12.20
142 5, // SID
143 0,
144 };
145
146 static const uint32_t gaAMRBitLen[16] = {
147 95, // 4.75
148 103, // 5.15
149 118, // 5.90
150 134, // 6.70
151 148, // 7.40
152 159, // 7.95
153 204, // 10.20
154 244, // 12.20
155 39, // SID
156 0,
157 };
158
ConvertCodecType(int32_t type)159 int32_t ImsMediaAudioUtil::ConvertCodecType(int32_t type)
160 {
161 switch (type)
162 {
163 default:
164 case AudioConfig::CODEC_AMR:
165 return kAudioCodecAmr;
166 case AudioConfig::CODEC_AMR_WB:
167 return kAudioCodecAmrWb;
168 case AudioConfig::CODEC_EVS:
169 return kAudioCodecEvs;
170 case AudioConfig::CODEC_PCMA:
171 return kAudioCodecPcma;
172 case AudioConfig::CODEC_PCMU:
173 return kAudioCodecPcmu;
174 }
175 }
176
ConvertEvsBandwidthToStr(kEvsBandwidth bandwidth,char * nBandwidth,uint32_t nLen)177 void ImsMediaAudioUtil::ConvertEvsBandwidthToStr(
178 kEvsBandwidth bandwidth, char* nBandwidth, uint32_t nLen)
179 {
180 switch (bandwidth)
181 {
182 case kEvsBandwidthNone:
183 strlcpy(nBandwidth, "NONE", nLen);
184 break;
185 case kEvsBandwidthNB:
186 strlcpy(nBandwidth, "NB", nLen);
187 break;
188 case kEvsBandwidthWB:
189 strlcpy(nBandwidth, "WB", nLen);
190 break;
191 case kEvsBandwidthSWB:
192 strlcpy(nBandwidth, "SWB", nLen);
193 break;
194 case kEvsBandwidthFB:
195 strlcpy(nBandwidth, "FB", nLen);
196 break;
197 default:
198 strlcpy(nBandwidth, "SWB", nLen);
199 break;
200 }
201 }
202
ConvertEvsCodecMode(int32_t evsMode)203 int32_t ImsMediaAudioUtil::ConvertEvsCodecMode(int32_t evsMode)
204 {
205 if (evsMode > MAX_AMR_MODE && evsMode <= MAX_EVS_MODE)
206 {
207 return kEvsCodecModePrimary;
208 }
209 else if (evsMode >= 0 && evsMode <= MAX_AMR_MODE)
210 {
211 return kEvsCodecModeAmrIo;
212 }
213 else
214 {
215 return kEvsCodecModeMax;
216 }
217 }
218
ConvertAmrModeToLen(uint32_t mode)219 uint32_t ImsMediaAudioUtil::ConvertAmrModeToLen(uint32_t mode)
220 {
221 if (mode > kImsAudioAmrModeSID)
222 { // over SID
223 return 0;
224 }
225 return gaAMRLen[mode];
226 }
227
ConvertAmrModeToBitLen(uint32_t mode)228 uint32_t ImsMediaAudioUtil::ConvertAmrModeToBitLen(uint32_t mode)
229 {
230 if (mode > kImsAudioAmrModeSID)
231 { // over SID
232 return 0;
233 }
234 return gaAMRBitLen[mode];
235 }
236
ConvertLenToAmrMode(uint32_t nLen)237 uint32_t ImsMediaAudioUtil::ConvertLenToAmrMode(uint32_t nLen)
238 {
239 uint32_t i;
240 if (nLen == 0)
241 {
242 return 15;
243 }
244
245 for (i = 0; i <= MAX_AMR_MODE; i++)
246 {
247 if (gaAMRLen[i] == nLen)
248 return i;
249 }
250 return 0;
251 }
252
ConvertAmrWbModeToLen(uint32_t mode)253 uint32_t ImsMediaAudioUtil::ConvertAmrWbModeToLen(uint32_t mode)
254 {
255 if (mode == kImsAudioAmrWbModeNoData)
256 return 0;
257 if (mode > kImsAudioAmrWbModeSID)
258 return 0;
259 return gaAMRWBLen[mode];
260 }
261
ConvertAmrWbModeToBitLen(uint32_t mode)262 uint32_t ImsMediaAudioUtil::ConvertAmrWbModeToBitLen(uint32_t mode)
263 {
264 if (mode == kImsAudioAmrWbModeNoData)
265 return 0;
266 if (mode > kImsAudioAmrWbModeSID)
267 return 0;
268 return gaAMRWBbitLen[mode];
269 }
270
ConvertLenToAmrWbMode(uint32_t nLen)271 uint32_t ImsMediaAudioUtil::ConvertLenToAmrWbMode(uint32_t nLen)
272 {
273 uint32_t i;
274 if (nLen == 0)
275 return kImsAudioAmrWbModeNoData;
276 for (i = 0; i <= kImsAudioAmrWbModeSID; i++)
277 {
278 if (gaAMRWBLen[i] == nLen)
279 return i;
280 }
281 return 0;
282 }
283
CheckEVSPrimaryHeaderFullModeFromSize(uint32_t size)284 bool ImsMediaAudioUtil::CheckEVSPrimaryHeaderFullModeFromSize(uint32_t size)
285 {
286 auto it = std::find(std::begin(gaEVSPrimaryHeaderFullByteLen),
287 std::end(gaEVSPrimaryHeaderFullByteLen), size);
288
289 // Check if the Evs size is headerfull or not
290 if (it != std::end(gaEVSPrimaryHeaderFullByteLen))
291 {
292 return true;
293 }
294
295 return false;
296 }
ConvertLenToEVSAudioMode(uint32_t nLen)297 uint32_t ImsMediaAudioUtil::ConvertLenToEVSAudioMode(uint32_t nLen)
298 {
299 uint32_t i = 0;
300 if (nLen == 0)
301 return kImsAudioEvsPrimaryModeNoData;
302 for (i = 0; i <= kImsAudioEvsPrimaryModeSID; i++)
303 {
304 if (gaEVSPrimaryByteLen[i] == nLen)
305 return i;
306 }
307 IMLOGD0("[ConvertLenToEVSAudioMode] No primery bit len found....");
308 return 0;
309 }
310
ConvertLenToEVSAMRIOAudioMode(uint32_t nLen)311 uint32_t ImsMediaAudioUtil::ConvertLenToEVSAMRIOAudioMode(uint32_t nLen)
312 {
313 uint32_t i = 0;
314 if (nLen == 0)
315 return kImsAudioEvsAmrWbIoModeNoData;
316 for (i = 0; i <= kImsAudioEvsAmrWbIoModeSID; i++)
317 {
318 if (gaEVSAMRWBIOLen[i] == nLen)
319 return i;
320 }
321 return 0;
322 }
323
ConvertEVSAudioModeToBitLen(uint32_t mode)324 uint32_t ImsMediaAudioUtil::ConvertEVSAudioModeToBitLen(uint32_t mode)
325 {
326 if (mode == 15)
327 return 0;
328 if (mode > 12)
329 return 0;
330 return gaEVSPrimaryBitLen[mode];
331 }
332
ConvertEVSAMRIOAudioModeToBitLen(uint32_t mode)333 uint32_t ImsMediaAudioUtil::ConvertEVSAMRIOAudioModeToBitLen(uint32_t mode)
334 {
335 if (mode == 15)
336 return 0;
337 if (mode > 9)
338 return 0;
339 return gaEVSAmrWbIoBitLen[mode];
340 }
341
ConvertAmrModeToBitrate(uint32_t mode)342 uint32_t ImsMediaAudioUtil::ConvertAmrModeToBitrate(uint32_t mode)
343 {
344 switch ((kImsAudioAmrMode)mode)
345 {
346 case kImsAudioAmrMode475:
347 return 4750;
348 case kImsAudioAmrMode515:
349 return 5150;
350 case kImsAudioAmrMode590:
351 return 5900;
352 case kImsAudioAmrMode670:
353 return 6700;
354 case kImsAudioAmrMode740:
355 return 7400;
356 case kImsAudioAmrMode795:
357 return 7950;
358 case kImsAudioAmrMode1020:
359 return 10200;
360 default:
361 case kImsAudioAmrMode1220:
362 return 12200;
363 }
364 }
365
ConvertAmrWbModeToBitrate(uint32_t mode)366 uint32_t ImsMediaAudioUtil::ConvertAmrWbModeToBitrate(uint32_t mode)
367 {
368 switch ((kImsAudioAmrWbMode)mode)
369 {
370 case kImsAudioAmrWbMode660:
371 return 6600;
372 case kImsAudioAmrWbMode885:
373 return 8850;
374 case kImsAudioAmrWbMode1265:
375 return 12650;
376 case kImsAudioAmrWbMode1425:
377 return 14250;
378 case kImsAudioAmrWbMode1585:
379 return 15850;
380 case kImsAudioAmrWbMode1825:
381 return 18250;
382 case kImsAudioAmrWbMode1985:
383 return 19850;
384 case kImsAudioAmrWbMode2305:
385 return 23050;
386 default:
387 case kImsAudioAmrWbMode2385:
388 return 23850;
389 }
390 }
391
GetMaximumAmrMode(int32_t bitmask)392 uint32_t ImsMediaAudioUtil::GetMaximumAmrMode(int32_t bitmask)
393 {
394 uint32_t maxMode = 0;
395
396 for (int32_t i = 0; i <= MAX_AMR_MODE; i++)
397 {
398 if (bitmask & (1 << i))
399 {
400 maxMode = i;
401 }
402 }
403
404 return maxMode;
405 }
406
GetMaximumEvsMode(int32_t bitmask)407 uint32_t ImsMediaAudioUtil::GetMaximumEvsMode(int32_t bitmask)
408 {
409 uint32_t maxMode = 0;
410
411 for (int32_t i = 0; i <= MAX_EVS_MODE; i++)
412 {
413 if (bitmask & (1 << i))
414 {
415 maxMode = i;
416 }
417 }
418
419 return maxMode;
420 }
421
ConvertEVSModeToBitRate(const int32_t mode)422 int32_t ImsMediaAudioUtil::ConvertEVSModeToBitRate(const int32_t mode)
423 {
424 switch ((kImsAudioEvsMode)mode)
425 {
426 case kImsAudioEvsAmrWbIoMode660:
427 return 6600;
428 case kImsAudioEvsAmrWbIoMode885:
429 return 8850;
430 case kImsAudioEvsAmrWbIoMode1265:
431 return 12650;
432 case kImsAudioEvsAmrWbIoMode1425:
433 return 14250;
434 case kImsAudioEvsAmrWbIoMode1585:
435 return 15850;
436 case kImsAudioEvsAmrWbIoMode1825:
437 return 18250;
438 case kImsAudioEvsAmrWbIoMode1985:
439 return 19850;
440 case kImsAudioEvsAmrWbIoMode2305:
441 return 23050;
442 case kImsAudioEvsAmrWbIoMode2385:
443 return 23850;
444 case kImsAudioEvsPrimaryMode5900:
445 return 5900;
446 case kImsAudioEvsPrimaryMode7200:
447 return 7200;
448 case kImsAudioEvsPrimaryMode8000:
449 return 8000;
450 case kImsAudioEvsPrimaryMode9600:
451 return 9600;
452 case kImsAudioEvsPrimaryMode13200:
453 return 13200;
454 case kImsAudioEvsPrimaryMode16400:
455 return 16400;
456 case kImsAudioEvsPrimaryMode24400:
457 return 24400;
458 case kImsAudioEvsPrimaryMode32000:
459 return 32000;
460 case kImsAudioEvsPrimaryMode48000:
461 return 48000;
462 case kImsAudioEvsPrimaryMode64000:
463 return 64000;
464 case kImsAudioEvsPrimaryMode96000:
465 return 96000;
466 case kImsAudioEvsPrimaryMode128000:
467 return 128000;
468 default:
469 return 13200;
470 }
471 }
472
CheckEVSCodecMode(const uint32_t nAudioFrameLength)473 kEvsCodecMode ImsMediaAudioUtil::CheckEVSCodecMode(const uint32_t nAudioFrameLength)
474 {
475 switch (nAudioFrameLength)
476 {
477 // EVS AMR IO Mode Case
478 case 17:
479 case 23:
480 case 32:
481 case 36:
482 case 40:
483 case 46:
484 case 50:
485 case 58:
486 case 60:
487 case 5:
488 return kEvsCodecModeAmrIo;
489 // EVS Primary Mode Case
490 case 7:
491 case 18:
492 case 20:
493 case 24:
494 case 33:
495 case 41:
496 case 61:
497 case 80:
498 case 120:
499 case 160:
500 case 240:
501 case 320:
502 case 6:
503 default:
504 return kEvsCodecModePrimary;
505 }
506 }
507
ConvertEVSPayloadMode(uint32_t nDataSize,kEvsCodecMode * pEVSCodecMode,uint32_t * pEVSCompactId)508 kRtpPyaloadHeaderMode ImsMediaAudioUtil::ConvertEVSPayloadMode(
509 uint32_t nDataSize, kEvsCodecMode* pEVSCodecMode, uint32_t* pEVSCompactId)
510 {
511 uint32_t i = 0;
512 uint32_t nDataBitSize = 0;
513 // nDataBitSize -= 2;
514 nDataBitSize = nDataSize * 8; // change byte to bit size
515
516 // compact format & primary mode
517 for (i = 0; i < EVS_COMPACT_PRIMARY_PAYLOAD_NUM; i++)
518 {
519 if (gaEVSPrimaryBitLen[i] == nDataBitSize)
520 {
521 *pEVSCodecMode = kEvsCodecModePrimary;
522 *pEVSCompactId = i;
523 return kRtpPyaloadHeaderModeEvsCompact;
524 }
525 }
526
527 // compact format & amr-wb io mode
528 for (i = 0; i < EVS_COMPACT_AMRWBIO_PAYLOAD_NUM; i++)
529 {
530 if (gaEVSAmrWbIoBitLen[i] == nDataBitSize)
531 {
532 *pEVSCodecMode = kEvsCodecModeAmrIo;
533 *pEVSCompactId = i;
534 return kRtpPyaloadHeaderModeEvsCompact;
535 }
536 }
537
538 // TODO : need to check ID...
539 *pEVSCodecMode = kEvsCodecModePrimary;
540 *pEVSCompactId = EVS_COMPACT_PAYLOAD_MAX_NUM;
541 return kRtpPyaloadHeaderModeEvsHeaderFull;
542 }
543
FindMaxEvsBandwidthFromRange(const int32_t EvsBandwidthRange)544 kEvsBandwidth ImsMediaAudioUtil::FindMaxEvsBandwidthFromRange(const int32_t EvsBandwidthRange)
545 {
546 if (EvsBandwidthRange & kEvsBandwidthFB)
547 {
548 return kEvsBandwidthFB;
549 }
550 else if (EvsBandwidthRange & kEvsBandwidthSWB)
551 {
552 return kEvsBandwidthSWB;
553 }
554 else if (EvsBandwidthRange & kEvsBandwidthWB)
555 {
556 return kEvsBandwidthWB;
557 }
558 else if (EvsBandwidthRange & kEvsBandwidthNB)
559 {
560 return kEvsBandwidthNB;
561 }
562 else
563 {
564 return kEvsBandwidthNone;
565 }
566 }
567