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 <AudioRtpPayloadDecoderNode.h>
18 #include <ImsMediaAudioUtil.h>
19 #include <ImsMediaTrace.h>
20 #include <AudioConfig.h>
21
AudioRtpPayloadDecoderNode(BaseSessionCallback * callback)22 AudioRtpPayloadDecoderNode::AudioRtpPayloadDecoderNode(BaseSessionCallback* callback) :
23 BaseNode(callback)
24 {
25 mCodecType = 0;
26 mOctetAligned = 0;
27 memset(mPayload, 0, sizeof(mPayload));
28 mListFrameType.clear();
29 mPrevCMR = 15;
30 mEvsBandwidth = kEvsBandwidthNone;
31 mEvsCodecMode = kEvsCodecModePrimary;
32 mEvsPayloadHeaderMode = kRtpPyaloadHeaderModeEvsCompact;
33 mEvsMode = kEvsAmrIoModeBitrate00660;
34 mCoreEvsMode = 0;
35 mEvsOffset = 0;
36 EvsChAOffset = 0;
37 }
38
~AudioRtpPayloadDecoderNode()39 AudioRtpPayloadDecoderNode::~AudioRtpPayloadDecoderNode() {}
40
GetNodeId()41 kBaseNodeId AudioRtpPayloadDecoderNode::GetNodeId()
42 {
43 return kNodeIdAudioPayloadDecoder;
44 }
45
Start()46 ImsMediaResult AudioRtpPayloadDecoderNode::Start()
47 {
48 IMLOGD0("[Start]");
49 mEvsMode = (kEvsBitrate)ImsMediaAudioUtil::GetMaximumEvsMode(mCoreEvsMode);
50 mEvsCodecMode = (kEvsCodecMode)ImsMediaAudioUtil::ConvertEvsCodecMode(mEvsMode);
51
52 mPrevCMR = mCodecType == kAudioCodecEvs ? 127 : 15;
53 mListFrameType.clear();
54 mNodeState = kNodeStateRunning;
55 return RESULT_SUCCESS;
56 }
57
Stop()58 void AudioRtpPayloadDecoderNode::Stop()
59 {
60 IMLOGD0("[Stop]");
61 mNodeState = kNodeStateStopped;
62 }
63
IsRunTime()64 bool AudioRtpPayloadDecoderNode::IsRunTime()
65 {
66 return true;
67 }
68
IsSourceNode()69 bool AudioRtpPayloadDecoderNode::IsSourceNode()
70 {
71 return false;
72 }
73
SetConfig(void * config)74 void AudioRtpPayloadDecoderNode::SetConfig(void* config)
75 {
76 AudioConfig* pConfig = reinterpret_cast<AudioConfig*>(config);
77 if (pConfig != nullptr)
78 {
79 mCodecType = ImsMediaAudioUtil::ConvertCodecType(pConfig->getCodecType());
80 if (mCodecType == kAudioCodecAmr || mCodecType == kAudioCodecAmrWb)
81 {
82 mOctetAligned = pConfig->getAmrParams().getOctetAligned();
83 }
84 else if (mCodecType == kAudioCodecEvs)
85 {
86 mEvsBandwidth = pConfig->getEvsParams().getEvsBandwidth();
87 mCoreEvsMode = pConfig->getEvsParams().getEvsMode();
88 mEvsPayloadHeaderMode =
89 (kRtpPyaloadHeaderMode)pConfig->getEvsParams().getUseHeaderFullOnly();
90 mEvsOffset = pConfig->getEvsParams().getChannelAwareMode();
91 }
92 }
93 }
94
IsSameConfig(void * config)95 bool AudioRtpPayloadDecoderNode::IsSameConfig(void* config)
96 {
97 if (config == nullptr)
98 return true;
99 AudioConfig* pConfig = reinterpret_cast<AudioConfig*>(config);
100
101 if (mCodecType == ImsMediaAudioUtil::ConvertCodecType(pConfig->getCodecType()))
102 {
103 if (mCodecType == kAudioCodecAmr || mCodecType == kAudioCodecAmrWb)
104 {
105 return (mOctetAligned == pConfig->getAmrParams().getOctetAligned());
106 }
107 else if (mCodecType == kAudioCodecEvs)
108 {
109 return (mEvsBandwidth == pConfig->getEvsParams().getEvsBandwidth() &&
110 mEvsPayloadHeaderMode ==
111 (kRtpPyaloadHeaderMode)pConfig->getEvsParams().getUseHeaderFullOnly() &&
112 mCoreEvsMode ==
113 ImsMediaAudioUtil::GetMaximumEvsMode(
114 pConfig->getEvsParams().getEvsMode()) &&
115 mEvsOffset == pConfig->getEvsParams().getChannelAwareMode());
116 }
117 }
118
119 return false;
120 }
121
OnDataFromFrontNode(ImsMediaSubType subtype,uint8_t * pData,uint32_t nDataSize,uint32_t nTimestamp,bool bMark,uint32_t nSeqNum,ImsMediaSubType nDataType,uint32_t arrivalTime)122 void AudioRtpPayloadDecoderNode::OnDataFromFrontNode(ImsMediaSubType subtype, uint8_t* pData,
123 uint32_t nDataSize, uint32_t nTimestamp, bool bMark, uint32_t nSeqNum,
124 ImsMediaSubType nDataType, uint32_t arrivalTime)
125 {
126 if (subtype == MEDIASUBTYPE_REFRESHED)
127 {
128 SendDataToRearNode(subtype, nullptr, nDataSize, 0, 0, 0, MEDIASUBTYPE_UNDEFINED);
129 return;
130 }
131
132 switch (mCodecType)
133 {
134 case kAudioCodecAmr:
135 case kAudioCodecAmrWb:
136 DecodePayloadAmr(pData, nDataSize, nTimestamp, nSeqNum, arrivalTime);
137 break;
138 case kAudioCodecPcmu:
139 case kAudioCodecPcma:
140 SendDataToRearNode(
141 MEDIASUBTYPE_RTPPAYLOAD, pData, nDataSize, nTimestamp, bMark, nSeqNum);
142 break;
143 case kAudioCodecEvs:
144 DecodePayloadEvs(pData, nDataSize, nTimestamp, bMark, nSeqNum, arrivalTime);
145 break;
146 default:
147 IMLOGE1("[OnDataFromFrontNode] invalid codec type[%d]", mCodecType);
148 SendDataToRearNode(MEDIASUBTYPE_RTPPAYLOAD, pData, nDataSize, nTimestamp, bMark,
149 nSeqNum, nDataType, arrivalTime);
150 break;
151 }
152 }
153
DecodePayloadAmr(uint8_t * pData,uint32_t nDataSize,uint32_t nTimestamp,uint32_t nSeqNum,uint32_t arrivalTime)154 void AudioRtpPayloadDecoderNode::DecodePayloadAmr(uint8_t* pData, uint32_t nDataSize,
155 uint32_t nTimestamp, uint32_t nSeqNum, uint32_t arrivalTime)
156 {
157 if (pData == nullptr || nDataSize == 0)
158 {
159 return;
160 }
161
162 uint32_t timestamp = nTimestamp;
163 uint32_t eRate;
164 uint32_t f;
165 uint32_t cmr;
166 uint32_t QbitPos; // Q_Speech_Sid_Bad
167
168 IMLOGD_PACKET5(IM_PACKET_LOG_PH,
169 "[DecodePayloadAmr] codec type[%d], octetAligned[%d], size[%d], TS[%u], "
170 "arrivalTime[%u]",
171 mCodecType, mOctetAligned, nDataSize, timestamp, arrivalTime);
172
173 mBitReader.SetBuffer(pData, nDataSize);
174 // read cmr
175 cmr = mBitReader.Read(4);
176
177 if (mOctetAligned == true)
178 {
179 mBitReader.Read(4);
180 }
181
182 #ifdef SIMULATE_CMR_AMR
183 const int kMaxMode = mCodecType == kAudioCodecAmrWb ? 9 : 8;
184 static int sCmr = 0;
185 static int sCount = 0;
186 if ((sCount++ % 250) == 0) // every 5 second
187 {
188 mCallback->SendEvent(kRequestAudioCmr, (sCmr++ % kMaxMode));
189 }
190 #endif
191
192 if (cmr != mPrevCMR)
193 {
194 if ((mCodecType == kAudioCodecAmr && cmr <= 7) ||
195 (mCodecType == kAudioCodecAmrWb && cmr <= 8))
196 {
197 IMLOGD2("[DecodePayloadAmr] CMR %d->%d", mPrevCMR, cmr);
198 // send internal event to operate cmr operation in encoder side
199 mCallback->SendEvent(kRequestAudioCmr, cmr);
200 mPrevCMR = cmr;
201 }
202 else if (cmr == 15)
203 {
204 mCallback->SendEvent(kRequestAudioCmr, cmr);
205 mPrevCMR = cmr;
206 }
207 else
208 {
209 IMLOGE1("[DecodePayloadAmr] invalid cmr value %d", cmr);
210 }
211 }
212
213 // get num of frame
214 do
215 {
216 f = mBitReader.Read(1); // f(1)
217 eRate = mBitReader.Read(4); // ft(4)
218 QbitPos = mBitReader.Read(1); // q(2)
219 IMLOGD_PACKET3(
220 IM_PACKET_LOG_PH, "[DecodePayloadAmr] cmr[%d], f[%d], ft[%d]", cmr, f, eRate);
221 mListFrameType.push_back(eRate);
222 if (mOctetAligned == true)
223 {
224 mBitReader.Read(2); // padding
225 }
226 } while (f == 1);
227
228 IMLOGD_PACKET3(IM_PACKET_LOG_PH,
229 "[DecodePayloadAmr] Q_Speech_SID <Q_Speech_SID> f[%d] eRate[%d] QbitPos[%d]", f, eRate,
230 QbitPos); // Q_Speech_SID
231
232 // read speech frames
233 while (mListFrameType.size() > 0)
234 {
235 uint32_t nDataBitSize;
236 uint32_t mode = mListFrameType.front();
237 if (mCodecType == kAudioCodecAmr)
238 {
239 nDataBitSize = ImsMediaAudioUtil::ConvertAmrModeToBitLen(mode);
240 }
241 else
242 {
243 nDataBitSize = ImsMediaAudioUtil::ConvertAmrWbModeToBitLen(mode);
244 }
245
246 mListFrameType.pop_front();
247 mBitWriter.SetBuffer(mPayload, MAX_AUDIO_PAYLOAD_SIZE);
248 uint32_t bufferSize = (nDataBitSize + 7) >> 3;
249 // set TOC
250 mBitWriter.Write(f, 1);
251 mBitWriter.Write(eRate, 4);
252 mBitWriter.Write(QbitPos, 1);
253 mBitWriter.Write(0, 2);
254 mBitReader.ReadByteBuffer(mPayload + 1, nDataBitSize);
255 bufferSize++;
256
257 IMLOGD_PACKET6(IM_PACKET_LOG_PH,
258 "[DecodePayloadAmr] result = %02X %02X %02X %02X, len[%d], eRate[%d]", mPayload[0],
259 mPayload[1], mPayload[2], mPayload[3], bufferSize, eRate);
260
261 ImsMediaSubType subType = MEDIASUBTYPE_AUDIO_NORMAL;
262
263 if (bufferSize == 1 || eRate == 15)
264 {
265 subType = MEDIASUBTYPE_AUDIO_NODATA;
266 }
267 else if ((eRate == 8 && mCodecType == kAudioCodecAmr) ||
268 (eRate == 9 && mCodecType == kAudioCodecAmrWb))
269 {
270 subType = MEDIASUBTYPE_AUDIO_SID;
271 }
272
273 // send remaining packet number in bundle as bMark value
274 SendDataToRearNode(MEDIASUBTYPE_RTPPAYLOAD, mPayload, bufferSize, timestamp,
275 mListFrameType.size(), nSeqNum, subType, arrivalTime);
276
277 timestamp += 20;
278 }
279 }
280
DecodePayloadEvs(uint8_t * pData,uint32_t nDataSize,uint32_t nTimeStamp,bool bMark,uint32_t nSeqNum,uint32_t arrivalTime)281 void AudioRtpPayloadDecoderNode::DecodePayloadEvs(uint8_t* pData, uint32_t nDataSize,
282 uint32_t nTimeStamp, bool bMark, uint32_t nSeqNum, uint32_t arrivalTime)
283 {
284 if (pData == nullptr || nDataSize == 0)
285 {
286 return;
287 }
288
289 IMLOGD_PACKET4(IM_PACKET_LOG_PH,
290 "[DecodePayloadEvs] codec type[%d], size[%d], TS[%u], arrivalTime[%u]", mCodecType,
291 nDataSize, nTimeStamp, arrivalTime);
292
293 kRtpPyaloadHeaderMode eEVSReceivedPHFormat = kRtpPyaloadHeaderModeEvsCompact;
294 kEvsCodecMode kEvsCodecMode = kEvsCodecModePrimary;
295
296 #ifdef SIMULATE_CMR_EVS
297 const int kMaxMode = 12;
298 static int sCmr = 1;
299 static int sCount = 0;
300 if ((sCount++ % 250) == 0) // every 5 second
301 {
302 mCallback->SendEvent(kRequestAudioCmrEvs, kEvsCmrCodeTypeSwb, (sCmr++ % kMaxMode));
303 }
304 #endif
305
306 // uint32_t nEVSBW = 0;
307 // uint32_t nEVSBR = 0;
308 uint32_t nEVSCompactId = 0;
309 uint32_t nDataBitSize = 0;
310 uint32_t timestamp = nTimeStamp;
311
312 // CMR byte
313 uint32_t h = 0; // 1bit, Header Type identification bit(always set to 1)
314 uint32_t cmr_t = 0; // 3bits, Type of Request
315 uint32_t cmr_d = 0; // 4bits, Codec Mode Request
316
317 // ToC byte
318 uint32_t toc_f = 0; // 1bit, follow another speech frame
319 uint32_t toc_ft_m = 0; // 1bit, EVS mode
320 uint32_t toc_ft_q = 0; // 1bit, AMR-WB Q bit
321 uint32_t toc_ft_b = 0; // 4bits, EVS bit rate
322 ImsMediaSubType subType = MEDIASUBTYPE_AUDIO_NORMAL;
323
324 mBitReader.SetBuffer(pData, nDataSize);
325
326 // check RTP payload format
327 eEVSReceivedPHFormat =
328 ImsMediaAudioUtil::ConvertEVSPayloadMode(nDataSize, &kEvsCodecMode, &nEVSCompactId);
329
330 if (nDataSize == 1)
331 {
332 subType = MEDIASUBTYPE_AUDIO_NODATA;
333 nEVSCompactId = 13;
334 }
335 else if (nDataSize == 5 || nDataSize == 6)
336 {
337 subType = MEDIASUBTYPE_AUDIO_SID;
338 }
339 else if (nDataSize == 7 && (((pData[0] >> 7) == 1 && pData[1] == 12) || pData[0] == 12))
340 {
341 eEVSReceivedPHFormat = kRtpPyaloadHeaderModeEvsHeaderFull;
342 subType = MEDIASUBTYPE_AUDIO_SID;
343 nEVSCompactId = 12;
344 }
345 else if (nDataSize == 8 && (pData[0] >> 7) == 1 && pData[1] == 12)
346 {
347 subType = MEDIASUBTYPE_AUDIO_SID;
348 nEVSCompactId = 12;
349 }
350
351 if ((kEvsCodecMode == kEvsCodecModePrimary) && (nEVSCompactId == 0)) // special case
352 {
353 // first bit of the EVS Primary 2.8kbps in compact format is always set to '0'
354 if ((pData[0] >> 7) == 0)
355 {
356 // EVS Primary 2.8 kbps frame in Compact format
357 eEVSReceivedPHFormat = kRtpPyaloadHeaderModeEvsCompact;
358 }
359 else
360 {
361 // EVS AMR-WB IO SID frame in Header-Full format with one CMR byte
362 eEVSReceivedPHFormat = kRtpPyaloadHeaderModeEvsHeaderFull;
363 }
364 }
365
366 if (eEVSReceivedPHFormat == kRtpPyaloadHeaderModeEvsCompact)
367 {
368 if (kEvsCodecMode == kEvsCodecModePrimary)
369 {
370 // calculate nDataBitSize from nDataSize
371 uint32_t nFrameType = (uint32_t)ImsMediaAudioUtil::ConvertLenToEVSAudioMode(nDataSize);
372 // TODO: remove kImsAudioEvsMode
373 nDataBitSize =
374 ImsMediaAudioUtil::ConvertEVSAudioModeToBitLen((kImsAudioEvsMode)nFrameType);
375
376 mBitReader.ReadByteBuffer(mPayload, nDataBitSize);
377
378 IMLOGD_PACKET6(IM_PACKET_LOG_PH,
379 "[DecodePayloadEvs] Result=%02X %02X %02X %02X, len=%d,nFrameType=%d",
380 mPayload[0], mPayload[1], mPayload[2], mPayload[3], nDataSize, nFrameType);
381
382 SendDataToRearNode(MEDIASUBTYPE_RTPPAYLOAD, mPayload, nDataSize, timestamp, bMark,
383 nSeqNum, subType, arrivalTime);
384 }
385 else if (kEvsCodecMode == kEvsCodecModeAmrIo)
386 {
387 // calculate nDataBitSize from nDataSize
388 uint32_t nFrameType = (uint32_t)ImsMediaAudioUtil::ConvertLenToAmrWbMode(nDataSize);
389
390 nDataBitSize = ImsMediaAudioUtil::ConvertAmrWbModeToBitLen(nFrameType);
391
392 // read cmr except SID
393 // at EVS AMR WB IO Mode, SID packet does not include cmr field...
394 if (nFrameType != kImsAudioAmrWbModeSID)
395 {
396 uint32_t cmr = mBitReader.Read(3);
397
398 if (cmr != mPrevCMR)
399 {
400 if (cmr != kEvsCmrCodeTypeNoReq)
401 {
402 ProcessCMRForEVS(kRtpPyaloadHeaderModeEvsCompact, kEvsCmrCodeTypeNoReq,
403 (kEvsCmrCodeDefine)cmr);
404 // Save Prev CMR value for checking
405 mPrevCMR = cmr;
406 }
407 else
408 {
409 kEvsBandwidth nOriginBW =
410 ImsMediaAudioUtil::FindMaxEvsBandwidthFromRange(mEvsBandwidth);
411 uint32_t nOriginBR = mEvsMode;
412 kEvsCmrCodeType nCodeType = kEvsCmrCodeTypeNoReq;
413 kEvsCmrCodeDefine nCodeDefine = kEvsCmrCodeDefineNoReq;
414
415 if (mEvsCodecMode == kEvsCodecModePrimary)
416 {
417 // to convert EVS CMR type
418 nOriginBR -= (uint32_t)kEvsPrimaryModeBitrate00590;
419 }
420
421 // check AMR IO and ChA
422 if (mEvsCodecMode == kEvsCodecModeAmrIo)
423 {
424 nCodeType = kEvsCmrCodeTypeAmrIO;
425 nCodeDefine = (kEvsCmrCodeDefine)nOriginBR;
426 }
427 else if ((kEvsPrimaryModeBitrate01320 ==
428 (nOriginBR + (uint32_t)kEvsPrimaryModeBitrate00590)) &&
429 ((EvsChAOffset > 0) && (EvsChAOffset < 8))) // ChA case.
430 {
431 if (nOriginBW == kEvsBandwidthSWB)
432 {
433 nCodeType = kEvsCmrCodeTypeSwbCha;
434 }
435 else
436 {
437 nCodeType = kEvsCmrCodeTypeWbCha;
438 }
439
440 switch (EvsChAOffset)
441 {
442 case 2:
443 nCodeDefine = kEvsCmrCodeDefineChaOffsetH2;
444 break;
445 case 3:
446 nCodeDefine = kEvsCmrCodeDefineChaOffsetH3;
447 break;
448 case 5:
449 nCodeDefine = kEvsCmrCodeDefineChaOffsetH5;
450 break;
451 case 7:
452 nCodeDefine = kEvsCmrCodeDefineChaOffsetH7;
453 break;
454 default:
455 IMLOGD3("[DecodePayloadEvs] no selected chmode offset[%d], "
456 "originBW[%d], originBR[%d]",
457 EvsChAOffset, nOriginBW, nOriginBR);
458 nCodeType = kEvsCmrCodeTypeNoReq;
459 nCodeDefine = kEvsCmrCodeDefineNoReq;
460 break;
461 }
462 }
463 else // primary case
464 {
465 nCodeDefine = (kEvsCmrCodeDefine)nOriginBR;
466
467 switch (nOriginBW)
468 {
469 case kEvsBandwidthNB:
470 nCodeType = kEvsCmrCodeTypeNb;
471 break;
472 case kEvsBandwidthWB:
473 nCodeType = kEvsCmrCodeTypeWb;
474 break;
475 case kEvsBandwidthSWB:
476 nCodeType = kEvsCmrCodeTypeSwb;
477 break;
478 case kEvsBandwidthFB:
479 nCodeType = kEvsCmrCodeTypeFb;
480 break;
481 default:
482 IMLOGD2("[DecodePayloadEvs] no CodeType - primary mode, "
483 "originBW[%d], "
484 "originBR[%d]",
485 nOriginBW, nOriginBR);
486 nCodeType = kEvsCmrCodeTypeNoReq;
487 nCodeDefine = kEvsCmrCodeDefineNoReq;
488 break;
489 }
490 }
491
492 // process CMR
493 ProcessCMRForEVS(
494 kRtpPyaloadHeaderModeEvsHeaderFull, nCodeType, nCodeDefine);
495
496 // Save Prev CMR value for checking
497 mPrevCMR = cmr;
498 }
499 }
500 }
501
502 mBitReader.ReadByteBuffer(mPayload, nDataBitSize);
503
504 // last data bit is speech first bit..
505 if (nFrameType != kImsAudioAmrWbModeSID)
506 {
507 uint8_t nLastBit0 = 0;
508 uint32_t i = 0;
509 uint32_t remain = 0;
510
511 remain = nDataBitSize % 8;
512 if (remain == 0)
513 {
514 nLastBit0 = mPayload[nDataSize - 1] & 0x01;
515 }
516 else
517 {
518 nLastBit0 = (mPayload[nDataSize - 1] << (remain - 1)) >> 7;
519 mPayload[nDataSize - 1] = (mPayload[nDataSize - 1] >> (9 - remain))
520 << (9 - remain);
521 }
522
523 for (i = (nDataSize - 1); i > 0; i--)
524 {
525 mPayload[i] = mPayload[i] >> 1;
526 mPayload[i] = mPayload[i] + ((mPayload[i - 1] & 0x01) << 7);
527 }
528 mPayload[0] = (mPayload[0] >> 1);
529 mPayload[0] = mPayload[0] + (nLastBit0 << 7);
530 }
531
532 IMLOGD_PACKET6(IM_PACKET_LOG_PH,
533 "[DecodePayloadEvs] result = %02X %02X %02X %02X, len=%d, nFrameType=%d",
534 mPayload[0], mPayload[1], mPayload[2], mPayload[3], nDataSize, nFrameType);
535
536 SendDataToRearNode(MEDIASUBTYPE_RTPPAYLOAD, mPayload, nDataSize, timestamp, bMark,
537 nSeqNum, subType, arrivalTime);
538 }
539 else
540 {
541 IMLOGI0("[DecodePayloadEvs] Invalid codec mode");
542 return;
543 }
544 }
545 else if (eEVSReceivedPHFormat == kRtpPyaloadHeaderModeEvsHeaderFull)
546 {
547 do
548 {
549 h = mBitReader.Read(1);
550 toc_f = 1;
551
552 if (h == 1) // CMR byte
553 {
554 cmr_t = mBitReader.Read(3);
555 cmr_d = mBitReader.Read(4);
556 uint32_t currCmr = (cmr_t << 4) + cmr_d;
557
558 if (currCmr != mPrevCMR)
559 {
560 // process cmr
561 if (currCmr != 127)
562 {
563 IMLOGI0("[DecodePayloadEvs] Process CMR");
564 // Process CMR
565 ProcessCMRForEVS(kRtpPyaloadHeaderModeEvsHeaderFull, (kEvsCmrCodeType)cmr_t,
566 (kEvsCmrCodeDefine)cmr_d);
567
568 // Save Prev CMR value for checking
569 mPrevCMR = currCmr;
570 }
571 else
572 {
573 uint32_t nOriginBW =
574 ImsMediaAudioUtil::FindMaxEvsBandwidthFromRange(mEvsBandwidth);
575 uint32_t nOriginBR = mEvsMode;
576 kEvsCmrCodeType nCodeType = kEvsCmrCodeTypeNoReq;
577 kEvsCmrCodeDefine nCodeDefine = kEvsCmrCodeDefineNoReq;
578
579 if (mEvsCodecMode == kEvsCodecModePrimary)
580 {
581 // to convert evs primary mode
582 nOriginBR -= (uint32_t)kEvsPrimaryModeBitrate00590;
583 }
584
585 // check AMR IO and ChA
586 if (mEvsCodecMode == kEvsCodecModeAmrIo)
587 {
588 nCodeType = kEvsCmrCodeTypeAmrIO;
589 nCodeDefine = (kEvsCmrCodeDefine)nOriginBR;
590 }
591 else if ((kEvsPrimaryModeBitrate01320 ==
592 (nOriginBR + (uint32_t)kEvsPrimaryModeBitrate00590)) &&
593 ((EvsChAOffset > 0) && (EvsChAOffset < 8))) // ChA case.
594 {
595 if (nOriginBW == (uint32_t)kEvsBandwidthSWB)
596 {
597 nCodeType = kEvsCmrCodeTypeSwbCha;
598 }
599 else
600 {
601 nCodeType = kEvsCmrCodeTypeWbCha;
602 }
603
604 switch (EvsChAOffset)
605 {
606 case 2:
607 nCodeDefine = kEvsCmrCodeDefineChaOffsetH2;
608 break;
609 case 3:
610 nCodeDefine = kEvsCmrCodeDefineChaOffsetH3;
611 break;
612 case 5:
613 nCodeDefine = kEvsCmrCodeDefineChaOffsetH5;
614 break;
615 case 7:
616 nCodeDefine = kEvsCmrCodeDefineChaOffsetH7;
617 break;
618 default:
619 IMLOGI3("[DecodePayloadEvs] No selected chmode offset[%d], "
620 "originBW[%d], originBR[%d]",
621 EvsChAOffset, nOriginBW, nOriginBR);
622 nCodeType = kEvsCmrCodeTypeNoReq;
623 nCodeDefine = kEvsCmrCodeDefineNoReq;
624 break;
625 }
626 }
627 else // primary case
628 {
629 nCodeDefine = (kEvsCmrCodeDefine)nOriginBR;
630
631 switch (nOriginBW)
632 {
633 case 0:
634 nCodeType = kEvsCmrCodeTypeNb;
635 break;
636 case 1:
637 nCodeType = kEvsCmrCodeTypeWb;
638 break;
639 case 2:
640 nCodeType = kEvsCmrCodeTypeSwb;
641 break;
642 case 3:
643 nCodeType = kEvsCmrCodeTypeFb;
644 break;
645 default:
646 IMLOGI2("[DecodePayloadEvs] No CodeType - primary mode, "
647 "originBW[%d], "
648 "originBR[%d]",
649 nOriginBW, nOriginBR);
650 nCodeType = kEvsCmrCodeTypeNoReq;
651 nCodeDefine = kEvsCmrCodeDefineNoReq;
652 break;
653 }
654 }
655
656 // process CMR
657 ProcessCMRForEVS(
658 kRtpPyaloadHeaderModeEvsHeaderFull, nCodeType, nCodeDefine);
659
660 // Save Prev CMR value for checking
661 mPrevCMR = currCmr;
662 }
663 }
664 }
665 else // ToC byte
666 {
667 toc_f = mBitReader.Read(1);
668 toc_ft_m = mBitReader.Read(1);
669 toc_ft_q = mBitReader.Read(1);
670 toc_ft_b = mBitReader.Read(4);
671
672 mListFrameType.push_back(toc_ft_b);
673 }
674 } while (toc_f == 1);
675
676 //
677 // read speech frames
678 //
679 while (mListFrameType.size() > 0)
680 {
681 mListFrameType.pop_front();
682
683 if (toc_ft_m == 0) // EVS Primary mode
684 {
685 nDataBitSize =
686 ImsMediaAudioUtil::ConvertEVSAudioModeToBitLen((kImsAudioEvsMode)toc_ft_b);
687 }
688 else // AMR-WB IO mode
689 {
690 nDataBitSize = ImsMediaAudioUtil::ConvertAmrWbModeToBitLen(toc_ft_b);
691 }
692
693 mBitWriter.SetBuffer(mPayload, MAX_AUDIO_PAYLOAD_SIZE);
694 uint32_t bufferSize = (nDataBitSize + 7) >> 3;
695
696 // set TOC
697 mBitWriter.Write(h, 1);
698 mBitWriter.Write(toc_f, 1);
699 mBitWriter.Write(toc_ft_m, 1);
700 mBitWriter.Write(toc_ft_q, 1);
701 mBitWriter.Write(toc_ft_b, 4);
702 mBitReader.ReadByteBuffer(mPayload + 1, nDataBitSize);
703 bufferSize++;
704
705 // remove padding bit
706 {
707 uint32_t nPaddingSize;
708 nPaddingSize = (8 - (nDataBitSize & 0x07)) & 0x07;
709 mBitReader.Read(nPaddingSize);
710 }
711
712 IMLOGD_PACKET6(IM_PACKET_LOG_PH,
713 "[DecodePayloadEvs] result = %02X %02X %02X %02X, len=%d, eRate=%d",
714 mPayload[0], mPayload[1], mPayload[2], mPayload[3], bufferSize, toc_ft_b);
715
716 SendDataToRearNode(MEDIASUBTYPE_RTPPAYLOAD, mPayload, bufferSize, timestamp,
717 mListFrameType.size(), nSeqNum, subType, arrivalTime);
718
719 timestamp += 20;
720 }
721 }
722 else
723 {
724 IMLOGE0("[DecodePayloadEvs] Invalid payload format");
725 return;
726 }
727 }
728
ProcessCMRForEVS(kRtpPyaloadHeaderMode eEVSPayloadHeaderMode,kEvsCmrCodeType cmr_t,kEvsCmrCodeDefine cmr_d)729 bool AudioRtpPayloadDecoderNode::ProcessCMRForEVS(
730 kRtpPyaloadHeaderMode eEVSPayloadHeaderMode, kEvsCmrCodeType cmr_t, kEvsCmrCodeDefine cmr_d)
731 {
732 kEvsCmrCodeType eNewEVSCMRCodeType = kEvsCmrCodeTypeNoReq;
733 kEvsCmrCodeDefine eNewEVSCMRCodeDefine = kEvsCmrCodeDefineNoReq;
734
735 if (eEVSPayloadHeaderMode == kRtpPyaloadHeaderModeEvsHeaderFull)
736 {
737 if (cmr_t < 8) // cmr_type is 3bit validation.
738 {
739 eNewEVSCMRCodeType = cmr_t;
740 }
741
742 if (cmr_d < 16) // cmr_define is 4bit validation
743 {
744 eNewEVSCMRCodeDefine = cmr_d;
745 }
746 }
747 else if (eEVSPayloadHeaderMode == kRtpPyaloadHeaderModeEvsCompact) // only EVS AMR IO Mode
748 {
749 eNewEVSCMRCodeType = kEvsCmrCodeTypeAmrIO;
750
751 switch (cmr_d)
752 {
753 case 0:
754 eNewEVSCMRCodeDefine = kEvsCmrCodeDefineAmrIo660;
755 break;
756 case 1:
757 eNewEVSCMRCodeDefine = kEvsCmrCodeDefineAmrIo885;
758 break;
759 case 2:
760 eNewEVSCMRCodeDefine = kEvsCmrCodeDefineAmrIo1265;
761 break;
762 case 3:
763 eNewEVSCMRCodeDefine = kEvsCmrCodeDefineAmrIo1585;
764 break;
765 case 4:
766 eNewEVSCMRCodeDefine = kEvsCmrCodeDefineAmrIo1825;
767 break;
768 case 5:
769 eNewEVSCMRCodeDefine = kEvsCmrCodeDefineAmrIo2305;
770 break;
771 case 6:
772 eNewEVSCMRCodeDefine = kEvsCmrCodeDefineAmrIo2385;
773 break;
774 case 7:
775 default:
776 eNewEVSCMRCodeDefine = kEvsCmrCodeDefineNoReq;
777 break;
778 }
779 }
780 else
781 {
782 IMLOGI0("[ProcessCMRForEVS] Invalid EVS codec mode");
783 return false;
784 }
785
786 if (eNewEVSCMRCodeDefine == kEvsCmrCodeDefineNoReq)
787 {
788 IMLOGI0("[ProcessCMRForEVS] Invalid CMR Value");
789 return true;
790 }
791
792 IMLOGD2("[ProcessCMRForEVS] Change request bnadwidth[%d], bitrate[%d]", eNewEVSCMRCodeType,
793 eNewEVSCMRCodeDefine);
794
795 if (mCallback)
796 {
797 mCallback->SendEvent(kRequestAudioCmrEvs, eNewEVSCMRCodeType, eNewEVSCMRCodeDefine);
798 }
799
800 return true;
801 }
802