Snap for 9648369 from ec1f8847cbb9bbb0744df408393406ab5ad623fb to mainline-rkpd-release

Change-Id: I23d059ed0b127d12cc3662065b3c6300b0634ae1

5 files changed, 703 insertions, 31 deletions

diff --git a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/config/RtpHeaderExtensionTest.cpp b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/config/RtpHeaderExtensionTest.cpp
new file mode 100644
index 00000000..926e917f
--- /dev/null
+++ b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/config/RtpHeaderExtensionTest.cpp
@@ -0,0 +1,100 @@
+/**
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <RtpHeaderExtension.h>
+#include <gtest/gtest.h>
+
+using namespace android::telephony::imsmedia;
+
+const int32_t kIdentifier = 15;
+const uint8_t kExtensionData[] = {0x01, 0x02};
+const int32_t kExtensionDataSize = 2;
+
+class RtpHeaderExtensionTest : public ::testing::Test
+{
+public:
+    RtpHeaderExtensionTest() { extension = nullptr; }
+    virtual ~RtpHeaderExtensionTest() {}
+
+protected:
+    RtpHeaderExtension* extension;
+
+    virtual void SetUp() override
+    {
+        extension = new RtpHeaderExtension();
+        extension->setExtensionData(kExtensionData, kExtensionDataSize);
+        extension->setLocalIdentifier(kIdentifier);
+        extension->setExtensionDataSize(kExtensionDataSize);
+    }
+
+    virtual void TearDown() override { delete extension; }
+};
+
+TEST_F(RtpHeaderExtensionTest, TestGetterSetter)
+{
+    EXPECT_EQ(memcmp(extension->getExtensionData(), kExtensionData, kExtensionDataSize), 0);
+    EXPECT_EQ(extension->getLocalIdentifier(), kIdentifier);
+    EXPECT_EQ(extension->getExtensionDataSize(), kExtensionDataSize);
+}
+
+TEST_F(RtpHeaderExtensionTest, TestParcel)
+{
+    android::Parcel parcel;
+    extension->writeToParcel(&parcel);
+    parcel.setDataPosition(0);
+
+    RtpHeaderExtension* extension2 = new RtpHeaderExtension();
+    extension2->readFromParcel(&parcel);
+    EXPECT_EQ(*extension2, *extension);
+    delete extension2;
+}
+
+TEST_F(RtpHeaderExtensionTest, TestAssign)
+{
+    RtpHeaderExtension extension2;
+    extension2 = *extension;
+    EXPECT_EQ(*extension, extension2);
+}
+
+TEST_F(RtpHeaderExtensionTest, TestEqual)
+{
+    RtpHeaderExtension* extension2 = new RtpHeaderExtension();
+    extension2->setExtensionData(kExtensionData, kExtensionDataSize);
+    extension2->setLocalIdentifier(kIdentifier);
+    extension2->setExtensionDataSize(kExtensionDataSize);
+    EXPECT_EQ(*extension, *extension2);
+    delete extension2;
+}
+
+TEST_F(RtpHeaderExtensionTest, TestNotEqual)
+{
+    RtpHeaderExtension* extension2 = new RtpHeaderExtension();
+    const uint8_t data[] = {0x03, 0x04};
+    extension2->setExtensionData(data, 2);
+    extension2->setLocalIdentifier(kIdentifier);
+    extension2->setExtensionDataSize(kExtensionDataSize);
+
+    RtpHeaderExtension* extension3 = new RtpHeaderExtension();
+    extension3->setExtensionData(kExtensionData, kExtensionDataSize);
+    extension3->setLocalIdentifier(9999);
+    extension3->setExtensionDataSize(kExtensionDataSize);
+
+    EXPECT_NE(*extension, *extension2);
+    EXPECT_NE(*extension, *extension3);
+
+    delete extension2;
+    delete extension3;
+}
\ No newline at end of file
diff --git a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/AudioJitterBufferTest.cpp b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/AudioJitterBufferTest.cpp
new file mode 100644
index 00000000..5d1f19cb
--- /dev/null
+++ b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/AudioJitterBufferTest.cpp
@@ -0,0 +1,494 @@
+/**
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <AudioJitterBuffer.h>
+
+#define TEST_BUFFER_SIZE    10
+#define TEST_FRAME_INTERVAL 20
+
+class AudioJitterBufferCallback : public BaseSessionCallback
+{
+public:
+    AudioJitterBufferCallback()
+    {
+        numNormal = 0;
+        numLost = 0;
+        numDuplicated = 0;
+        numDiscarded = 0;
+    }
+    virtual ~AudioJitterBufferCallback() {}
+
+    virtual void onEvent(int32_t type, uint64_t param1, uint64_t /*param2*/)
+    {
+        if (type == kCollectRxRtpStatus)
+        {
+            SessionCallbackParameter* param = reinterpret_cast<SessionCallbackParameter*>(param1);
+
+            if (param == nullptr)
+            {
+                return;
+            }
+
+            switch (param->param1)
+            {
+                case kRtpStatusDuplicated:
+                    numDuplicated++;
+                    break;
+                case kRtpStatusDiscarded:
+                    numDiscarded++;
+                    break;
+                case kRtpStatusNormal:
+                    numNormal++;
+                    break;
+                default:
+                    break;
+            }
+
+            delete param;
+        }
+        else if (type == kCollectOptionalInfo)
+        {
+            SessionCallbackParameter* param = reinterpret_cast<SessionCallbackParameter*>(param1);
+
+            if (param == nullptr)
+            {
+                return;
+            }
+
+            if (param->type == kReportPacketLossGap)
+            {
+                numLost += param->param2;
+            }
+
+            delete param;
+        }
+    }
+
+    int32_t getNumNormal() { return numNormal; }
+    int32_t getNumLost() { return numLost; }
+    int32_t getNumDuplicated() { return numDuplicated; }
+    int32_t getNumDiscarded() { return numDiscarded; }
+
+private:
+    int32_t numNormal;
+    int32_t numLost;
+    int32_t numDuplicated;
+    int32_t numDiscarded;
+};
+
+class AudioJitterBufferTest : public ::testing::Test
+{
+public:
+    AudioJitterBufferTest() {}
+    virtual ~AudioJitterBufferTest() {}
+
+protected:
+    AudioJitterBuffer* mJitterBuffer;
+    AudioJitterBufferCallback mCallback;
+    int32_t mStartJitterBufferSize;
+    int32_t mMinJitterBufferSize;
+    int32_t mMaxJitterBufferSize;
+
+    virtual void SetUp() override
+    {
+        mStartJitterBufferSize = 4;
+        mMinJitterBufferSize = 4;
+        mMaxJitterBufferSize = 9;
+
+        mJitterBuffer = new AudioJitterBuffer();
+        mJitterBuffer->SetCodecType(kAudioCodecAmr);
+        mJitterBuffer->SetSessionCallback(&mCallback);
+        mJitterBuffer->SetJitterBufferSize(
+                mStartJitterBufferSize, mMinJitterBufferSize, mMaxJitterBufferSize);
+        mJitterBuffer->SetJitterOptions(80, 1, 2.5f, false);
+    }
+
+    virtual void TearDown() override { delete mJitterBuffer; }
+};
+
+TEST_F(AudioJitterBufferTest, TestNormalAddGet)
+{
+    const int32_t kNumFrames = 50;
+    char buffer[TEST_BUFFER_SIZE] = {"\x1"};
+    int32_t countGet = 0;
+    int32_t countGetFrame = 0;
+    int32_t countNotGet = 0;
+    int32_t getTime = 0;
+
+    ImsMediaSubType subtype = MEDIASUBTYPE_UNDEFINED;
+    uint8_t* data = nullptr;
+    uint32_t size = 0;
+    uint32_t timestamp = 0;
+    bool mark = false;
+    uint32_t seq = 0;
+
+    for (int32_t i = 0; i < kNumFrames; i++)
+    {
+        int32_t addTime = i * TEST_FRAME_INTERVAL;
+        mJitterBuffer->Add(MEDIASUBTYPE_UNDEFINED, reinterpret_cast<uint8_t*>(buffer), 1,
+                i * TEST_FRAME_INTERVAL, false, i, MEDIASUBTYPE_UNDEFINED, addTime);
+
+        getTime = countGet * TEST_FRAME_INTERVAL;
+
+        if (mJitterBuffer->Get(&subtype, &data, &size, &timestamp, &mark, &seq, getTime))
+        {
+            EXPECT_EQ(size, 1);
+            EXPECT_EQ(timestamp, countGetFrame * TEST_FRAME_INTERVAL);
+            EXPECT_EQ(seq, countGetFrame);
+            mJitterBuffer->Delete();
+            countGetFrame++;
+        }
+        else
+        {
+            countNotGet++;
+        }
+
+        countGet++;
+    }
+
+    while (mJitterBuffer->GetCount() > 0)
+    {
+        getTime = countGet * TEST_FRAME_INTERVAL;
+
+        if (mJitterBuffer->Get(&subtype, &data, &size, &timestamp, &mark, &seq, getTime))
+        {
+            EXPECT_EQ(size, 1);
+            EXPECT_EQ(timestamp, countGetFrame * TEST_FRAME_INTERVAL);
+            EXPECT_EQ(seq, countGetFrame);
+            mJitterBuffer->Delete();
+            countGetFrame++;
+        }
+        else
+        {
+            countNotGet++;
+        }
+
+        countGet++;
+    }
+
+    EXPECT_EQ(countNotGet, mStartJitterBufferSize);
+    EXPECT_EQ(mCallback.getNumNormal(), kNumFrames);
+}
+
+TEST_F(AudioJitterBufferTest, TestNormalAddGetSeqRounding)
+{
+    const int32_t kNumFrames = 20;
+    char buffer[TEST_BUFFER_SIZE] = {"\x1"};
+    int32_t countGet = 0;
+    int32_t countGetFrame = 0;
+    int32_t countNotGet = 0;
+    int32_t getTime = 0;
+
+    ImsMediaSubType subtype = MEDIASUBTYPE_UNDEFINED;
+    uint8_t* data = nullptr;
+    uint32_t size = 0;
+    uint32_t timestamp = 0;
+    bool mark = false;
+    uint32_t seq = 0;
+    uint16_t startSeq = 65530;
+    uint16_t addSeq = 0;
+    uint16_t getSeq = 0;
+
+    for (int32_t i = 0; i < kNumFrames; i++)
+    {
+        addSeq = startSeq + (uint16_t)i;
+        int32_t addTime = i * TEST_FRAME_INTERVAL;
+        mJitterBuffer->Add(MEDIASUBTYPE_UNDEFINED, reinterpret_cast<uint8_t*>(buffer), 1,
+                i * TEST_FRAME_INTERVAL, false, addSeq, MEDIASUBTYPE_UNDEFINED, addTime);
+
+        getTime = countGet * TEST_FRAME_INTERVAL;
+
+        if (mJitterBuffer->Get(&subtype, &data, &size, &timestamp, &mark, &seq, getTime))
+        {
+            getSeq = startSeq + (uint16_t)countGetFrame;
+            EXPECT_EQ(size, 1);
+            EXPECT_EQ(timestamp, countGetFrame * TEST_FRAME_INTERVAL);
+            EXPECT_EQ(seq, getSeq);
+            mJitterBuffer->Delete();
+            countGetFrame++;
+        }
+        else
+        {
+            countNotGet++;
+        }
+        countGet++;
+    }
+
+    while (mJitterBuffer->GetCount() > 0)
+    {
+        getTime = countGet * TEST_FRAME_INTERVAL;
+
+        if (mJitterBuffer->Get(&subtype, &data, &size, &timestamp, &mark, &seq, getTime))
+        {
+            getSeq = startSeq + (uint16_t)countGetFrame;
+            EXPECT_EQ(size, 1);
+            EXPECT_EQ(timestamp, countGetFrame * TEST_FRAME_INTERVAL);
+            EXPECT_EQ(seq, getSeq);
+            mJitterBuffer->Delete();
+            countGetFrame++;
+        }
+        else
+        {
+            countNotGet++;
+        }
+
+        countGet++;
+    }
+
+    EXPECT_EQ(countNotGet, mStartJitterBufferSize);
+    EXPECT_EQ(mCallback.getNumNormal(), kNumFrames);
+}
+
+TEST_F(AudioJitterBufferTest, TestNormalAddGetTimestampRounding)
+{
+    const int32_t kNumFrames = 50;
+    char buffer[TEST_BUFFER_SIZE] = {"\x1"};
+    int32_t countGet = 0;
+    int32_t countGetFrame = 0;
+    int32_t countNotGet = 0;
+    int32_t getTime = 0;
+
+    ImsMediaSubType subtype = MEDIASUBTYPE_UNDEFINED;
+    uint8_t* data = nullptr;
+    uint32_t size = 0;
+    uint32_t timestamp = 0;
+    bool mark = false;
+    uint32_t seq = 0;
+    uint32_t startTimestamp = 4294967295 - 200;
+    uint32_t addTimestamp = 0;
+    uint32_t getTimestamp = 0;
+
+    for (int32_t i = 0; i < kNumFrames; i++)
+    {
+        addTimestamp = startTimestamp + i * TEST_FRAME_INTERVAL;
+        int32_t addTime = i * TEST_FRAME_INTERVAL;
+        mJitterBuffer->Add(MEDIASUBTYPE_UNDEFINED, reinterpret_cast<uint8_t*>(buffer), 1,
+                addTimestamp, false, i, MEDIASUBTYPE_UNDEFINED, addTime);
+
+        getTime = countGet * TEST_FRAME_INTERVAL;
+
+        if (mJitterBuffer->Get(&subtype, &data, &size, &timestamp, &mark, &seq, getTime))
+        {
+            getTimestamp = startTimestamp + countGetFrame * TEST_FRAME_INTERVAL;
+            EXPECT_EQ(size, 1);
+            EXPECT_EQ(timestamp, getTimestamp);
+            EXPECT_EQ(seq, countGetFrame);
+            mJitterBuffer->Delete();
+            countGetFrame++;
+        }
+        else
+        {
+            countNotGet++;
+        }
+
+        countGet++;
+    }
+
+    while (mJitterBuffer->GetCount() > 0)
+    {
+        getTime = countGet * TEST_FRAME_INTERVAL;
+
+        if (mJitterBuffer->Get(&subtype, &data, &size, &timestamp, &mark, &seq, getTime))
+        {
+            getTimestamp = startTimestamp + countGetFrame * TEST_FRAME_INTERVAL;
+            EXPECT_EQ(size, 1);
+            EXPECT_EQ(timestamp, getTimestamp);
+            EXPECT_EQ(seq, countGetFrame);
+            mJitterBuffer->Delete();
+            countGetFrame++;
+        }
+        else
+        {
+            countNotGet++;
+        }
+
+        countGet++;
+    }
+
+    EXPECT_EQ(countNotGet, mStartJitterBufferSize);
+    EXPECT_EQ(mCallback.getNumNormal(), kNumFrames);
+}
+
+TEST_F(AudioJitterBufferTest, TestAddGetDuplicatedSeqDetection)
+{
+    const int32_t kNumFrames = 20;
+    char buffer[TEST_BUFFER_SIZE] = {"\x1"};
+    int32_t countGet = 0;
+    int32_t countGetFrame = 0;
+    int32_t countNotGet = 0;
+    int32_t getTime = 0;
+
+    ImsMediaSubType subtype = MEDIASUBTYPE_UNDEFINED;
+    uint8_t* data = nullptr;
+    uint32_t size = 0;
+    uint32_t timestamp = 0;
+    bool mark = false;
+    uint32_t seq = 0;
+    uint16_t startSeq = 0;
+    uint16_t addSeq = 0;
+    uint16_t getSeq = 0;
+
+    for (int32_t i = 0; i < kNumFrames; i++)
+    {
+        addSeq = startSeq + (uint16_t)i;
+        int32_t addTime = i * TEST_FRAME_INTERVAL;
+        mJitterBuffer->Add(MEDIASUBTYPE_UNDEFINED, reinterpret_cast<uint8_t*>(buffer), 1,
+                i * TEST_FRAME_INTERVAL, false, addSeq, MEDIASUBTYPE_UNDEFINED, addTime);
+
+        if (i == 5)
+        {
+            mJitterBuffer->Add(MEDIASUBTYPE_UNDEFINED, reinterpret_cast<uint8_t*>(buffer), 1,
+                    i * TEST_FRAME_INTERVAL, false, addSeq, MEDIASUBTYPE_UNDEFINED, addTime);
+        }
+
+        getTime = countGet * TEST_FRAME_INTERVAL;
+
+        if (mJitterBuffer->Get(&subtype, &data, &size, &timestamp, &mark, &seq, getTime))
+        {
+            getSeq = startSeq + (uint16_t)countGetFrame;
+            EXPECT_EQ(size, 1);
+            EXPECT_EQ(timestamp, countGetFrame * TEST_FRAME_INTERVAL);
+            EXPECT_EQ(seq, getSeq);
+            mJitterBuffer->Delete();
+            countGetFrame++;
+        }
+        else
+        {
+            countNotGet++;
+        }
+
+        countGet++;
+    }
+
+    while (mJitterBuffer->GetCount() > 0)
+    {
+        getTime = countGet * TEST_FRAME_INTERVAL;
+
+        if (mJitterBuffer->Get(&subtype, &data, &size, &timestamp, &mark, &seq, getTime))
+        {
+            getSeq = startSeq + (uint16_t)countGetFrame;
+            EXPECT_EQ(size, 1);
+            EXPECT_EQ(timestamp, countGetFrame * TEST_FRAME_INTERVAL);
+            EXPECT_EQ(seq, getSeq);
+            mJitterBuffer->Delete();
+            countGetFrame++;
+        }
+        else
+        {
+            countNotGet++;
+        }
+
+        countGet++;
+    }
+
+    EXPECT_EQ(mCallback.getNumLost(), 0);
+    EXPECT_EQ(mCallback.getNumDuplicated(), 1);
+    EXPECT_EQ(mCallback.getNumDiscarded(), 0);
+    EXPECT_EQ(countNotGet, mStartJitterBufferSize);
+    EXPECT_EQ(mCallback.getNumNormal(), kNumFrames);
+}
+
+TEST_F(AudioJitterBufferTest, TestAddGetInBurstIncoming)
+{
+    const int32_t kNumFrames = 20;
+    char buffer[TEST_BUFFER_SIZE] = {"\x1"};
+    int32_t countGet = 0;
+    int32_t countGetFrame = 0;
+    int32_t countNotGet = 0;
+    int32_t getTime = 0;
+
+    ImsMediaSubType subtype = MEDIASUBTYPE_UNDEFINED;
+    uint8_t* data = nullptr;
+    uint32_t size = 0;
+    uint32_t timestamp = 0;
+    bool mark = false;
+    uint32_t seq = 0;
+    uint16_t startSeq = 0;
+    uint16_t addSeq = startSeq;
+    uint16_t getSeq = startSeq;
+    uint32_t addTimestamp = 0;
+
+    int32_t addTime = 0;
+    int iter = 0;
+
+    while (addSeq < kNumFrames)
+    {
+        if (iter > 5 && iter < 10)  // not added for 4 frame interval
+        {
+            addTime += TEST_FRAME_INTERVAL;
+        }
+        else if (iter >= 10 && iter < 15)  // 5 frames burst added
+        {
+            mJitterBuffer->Add(MEDIASUBTYPE_UNDEFINED, reinterpret_cast<uint8_t*>(buffer), 1,
+                    addTimestamp, false, addSeq++, MEDIASUBTYPE_UNDEFINED, addTime);
+            addTime += 1;  // 1ms burst
+            addTimestamp += TEST_FRAME_INTERVAL;
+        }
+        else  // normal
+        {
+            mJitterBuffer->Add(MEDIASUBTYPE_UNDEFINED, reinterpret_cast<uint8_t*>(buffer), 1,
+                    addTimestamp, false, addSeq++, MEDIASUBTYPE_UNDEFINED, addTime);
+            addTime += TEST_FRAME_INTERVAL;
+            addTimestamp += TEST_FRAME_INTERVAL;
+        }
+
+        iter++;
+        getTime = countGet * TEST_FRAME_INTERVAL;
+
+        if (mJitterBuffer->Get(&subtype, &data, &size, &timestamp, &mark, &seq, getTime))
+        {
+            EXPECT_EQ(size, 1);
+            EXPECT_EQ(timestamp, countGetFrame * TEST_FRAME_INTERVAL);
+            EXPECT_EQ(seq, getSeq++);
+            mJitterBuffer->Delete();
+            countGetFrame++;
+        }
+        else
+        {
+            countNotGet++;
+        }
+
+        countGet++;
+    }
+
+    while (mJitterBuffer->GetCount() > 0)
+    {
+        getTime = countGet * TEST_FRAME_INTERVAL;
+
+        if (mJitterBuffer->Get(&subtype, &data, &size, &timestamp, &mark, &seq, getTime))
+        {
+            getSeq = startSeq + (uint16_t)countGetFrame;
+            EXPECT_EQ(size, 1);
+            EXPECT_EQ(timestamp, countGetFrame * TEST_FRAME_INTERVAL);
+            EXPECT_EQ(seq, getSeq);
+            mJitterBuffer->Delete();
+            countGetFrame++;
+        }
+        else
+        {
+            countNotGet++;
+        }
+
+        countGet++;
+    }
+
+    EXPECT_EQ(mCallback.getNumLost(), 0);
+    EXPECT_EQ(mCallback.getNumDuplicated(), 0);
+    EXPECT_EQ(mCallback.getNumDiscarded(), 0);
+    EXPECT_EQ(countNotGet, mStartJitterBufferSize);
+    EXPECT_EQ(mCallback.getNumNormal(), kNumFrames);
+}
\ No newline at end of file
diff --git a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/MediaQualityAnalyzerTest.cpp b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/MediaQualityAnalyzerTest.cpp
index a979dd4a..a94b6654 100644
--- a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/MediaQualityAnalyzerTest.cpp
+++ b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/audio/MediaQualityAnalyzerTest.cpp
@@ -184,15 +184,50 @@ protected:
     }
 };
 
-TEST_F(MediaQualityAnalyzerTest, TestStartStop)
+TEST_F(MediaQualityAnalyzerTest, TestCodecType)
 {
-    EXPECT_CALL(mCallback, onEvent(kAudioCallQualityChangedInd, _, _)).Times(1);
+    EXPECT_CALL(mCallback, onEvent(kAudioCallQualityChangedInd, _, _)).Times(6);
     mAnalyzer->start();
+    mAnalyzer->stop();
+    EXPECT_EQ(CallQuality::AUDIO_QUALITY_AMR_WB, mFakeCallback.getCallQuality().getCodecType());
+
+    mConfig.setCodecType(AudioConfig::CODEC_AMR);
+    mAnalyzer->setConfig(&mConfig);
+    mAnalyzer->start();
+    mAnalyzer->stop();
+    EXPECT_EQ(CallQuality::AUDIO_QUALITY_AMR, mFakeCallback.getCallQuality().getCodecType());
 
-    CallQuality quality = mAnalyzer->getCallQuality();
+    mConfig.setCodecType(AudioConfig::CODEC_EVS);
+    mEvsParam.setEvsBandwidth(EvsParams::EVS_NARROW_BAND);
+    mConfig.setEvsParams(mEvsParam);
+    mAnalyzer->setConfig(&mConfig);
+    mAnalyzer->start();
+    mAnalyzer->stop();
+    EXPECT_EQ(CallQuality::AUDIO_QUALITY_EVS_NB, mFakeCallback.getCallQuality().getCodecType());
+
+    mConfig.setCodecType(AudioConfig::CODEC_EVS);
+    mEvsParam.setEvsBandwidth(EvsParams::EVS_WIDE_BAND);
+    mConfig.setEvsParams(mEvsParam);
+    mAnalyzer->setConfig(&mConfig);
+    mAnalyzer->start();
     mAnalyzer->stop();
+    EXPECT_EQ(CallQuality::AUDIO_QUALITY_EVS_WB, mFakeCallback.getCallQuality().getCodecType());
 
-    EXPECT_EQ(mFakeCallback.getCallQuality(), quality);
+    mConfig.setCodecType(AudioConfig::CODEC_EVS);
+    mEvsParam.setEvsBandwidth(EvsParams::EVS_SUPER_WIDE_BAND);
+    mConfig.setEvsParams(mEvsParam);
+    mAnalyzer->setConfig(&mConfig);
+    mAnalyzer->start();
+    mAnalyzer->stop();
+    EXPECT_EQ(CallQuality::AUDIO_QUALITY_EVS_SWB, mFakeCallback.getCallQuality().getCodecType());
+
+    mConfig.setCodecType(AudioConfig::CODEC_EVS);
+    mEvsParam.setEvsBandwidth(EvsParams::EVS_FULL_BAND);
+    mConfig.setEvsParams(mEvsParam);
+    mAnalyzer->setConfig(&mConfig);
+    mAnalyzer->start();
+    mAnalyzer->stop();
+    EXPECT_EQ(CallQuality::AUDIO_QUALITY_EVS_FB, mFakeCallback.getCallQuality().getCodecType());
 }
 
 TEST_F(MediaQualityAnalyzerTest, TestCollectTxPackets)
@@ -212,7 +247,6 @@ TEST_F(MediaQualityAnalyzerTest, TestCollectTxPackets)
     EXPECT_EQ(mAnalyzer->getTxPacketSize(), numPackets);
     EXPECT_EQ(mAnalyzer->getRxPacketSize(), 0);
     EXPECT_EQ(mAnalyzer->getLostPacketSize(), 0);
-    CallQuality quality = mAnalyzer->getCallQuality();
     mAnalyzer->stop();
 
     EXPECT_EQ(mAnalyzer->getTxPacketSize(), 0);
@@ -220,9 +254,7 @@ TEST_F(MediaQualityAnalyzerTest, TestCollectTxPackets)
     EXPECT_EQ(mAnalyzer->getLostPacketSize(), 0);
 
     // Check CallQuality value
-    CallQuality quality2 = mFakeCallback.getCallQuality();
-    EXPECT_EQ(quality2, quality);
-    EXPECT_EQ(quality2.getNumRtpPacketsTransmitted(), numPackets);
+    EXPECT_EQ(mFakeCallback.getCallQuality().getNumRtpPacketsTransmitted(), numPackets);
 }
 
 TEST_F(MediaQualityAnalyzerTest, TestRtpInactivityNotRunning)
@@ -302,14 +334,10 @@ TEST_F(MediaQualityAnalyzerTest, TestCallQualityInactivity)
     EXPECT_CALL(mCallback, onEvent(kAudioCallQualityChangedInd, _, _)).Times(2);
     mAnalyzer->start();
     mCondition.wait_timeout(4100);  // 4.1 sec
-
-    CallQuality quality = mAnalyzer->getCallQuality();
     mAnalyzer->stop();
 
     // Check CallQuality value
-    CallQuality quality2 = mFakeCallback.getCallQuality();
-    EXPECT_EQ(quality2, quality);
-    EXPECT_TRUE(quality2.getRtpInactivityDetected());
+    EXPECT_TRUE(mFakeCallback.getCallQuality().getRtpInactivityDetected());
 }
 
 TEST_F(MediaQualityAnalyzerTest, TestCallQualityLevelChanged)
@@ -346,7 +374,6 @@ TEST_F(MediaQualityAnalyzerTest, TestCallQualityLevelChanged)
     EXPECT_EQ(mAnalyzer->getTxPacketSize(), 0);
     EXPECT_EQ(mAnalyzer->getRxPacketSize(), numPackets - 1);
     EXPECT_EQ(mAnalyzer->getLostPacketSize(), 1);
-    CallQuality quality = mAnalyzer->getCallQuality();
     mAnalyzer->stop();
 
     EXPECT_EQ(mAnalyzer->getTxPacketSize(), 0);
@@ -354,10 +381,9 @@ TEST_F(MediaQualityAnalyzerTest, TestCallQualityLevelChanged)
     EXPECT_EQ(mAnalyzer->getLostPacketSize(), 0);
 
     // Check CallQuality value
-    CallQuality quality2 = mFakeCallback.getCallQuality();
-    EXPECT_EQ(quality2, quality);
-    EXPECT_EQ(quality2.getNumRtpPacketsReceived(), numPackets - 1);
-    EXPECT_EQ(quality2.getDownlinkCallQualityLevel(), CallQuality::kCallQualityBad);
+    EXPECT_EQ(mFakeCallback.getCallQuality().getNumRtpPacketsReceived(), numPackets - 1);
+    EXPECT_EQ(mFakeCallback.getCallQuality().getDownlinkCallQualityLevel(),
+            CallQuality::kCallQualityBad);
 }
 
 TEST_F(MediaQualityAnalyzerTest, TestJitterInd)
@@ -389,17 +415,14 @@ TEST_F(MediaQualityAnalyzerTest, TestJitterInd)
     EXPECT_EQ(mAnalyzer->getRxPacketSize(), numPackets);
     EXPECT_EQ(mAnalyzer->getLostPacketSize(), 0);
 
-    CallQuality quality = mAnalyzer->getCallQuality();
     mAnalyzer->stop();
 
     EXPECT_EQ(mAnalyzer->getTxPacketSize(), 0);
     EXPECT_EQ(mAnalyzer->getRxPacketSize(), 0);
     EXPECT_EQ(mAnalyzer->getLostPacketSize(), 0);
 
-    CallQuality quality2 = mFakeCallback.getCallQuality();
-    EXPECT_EQ(quality2, quality);
-    EXPECT_EQ(quality2.getNumRtpPacketsReceived(), numPackets);
-    EXPECT_EQ(quality2.getAverageRelativeJitter(), jitter);
+    EXPECT_EQ(mFakeCallback.getCallQuality().getNumRtpPacketsReceived(), numPackets);
+    EXPECT_EQ(mFakeCallback.getCallQuality().getAverageRelativeJitter(), jitter);
 
     MediaQualityStatus status = mFakeCallback.getMediaQualityStatus();
     EXPECT_EQ(status.getRtpJitterMillis(), jitter);
@@ -433,6 +456,7 @@ TEST_F(MediaQualityAnalyzerTest, TestSsrcChange)
     EXPECT_EQ(mAnalyzer->getTxPacketSize(), 0);
     EXPECT_EQ(mAnalyzer->getRxPacketSize(), numPackets);
     EXPECT_EQ(mAnalyzer->getLostPacketSize(), 0);
+
     mAnalyzer->stop();
 
     EXPECT_EQ(mAnalyzer->getTxPacketSize(), 0);
@@ -477,16 +501,13 @@ TEST_F(MediaQualityAnalyzerTest, TestPacketLossInd)
     EXPECT_EQ(mAnalyzer->getRxPacketSize(), numPackets - 1);
     EXPECT_EQ(mAnalyzer->getLostPacketSize(), 1);
 
-    CallQuality quality = mAnalyzer->getCallQuality();
     mAnalyzer->stop();
 
     EXPECT_EQ(mAnalyzer->getTxPacketSize(), 0);
     EXPECT_EQ(mAnalyzer->getRxPacketSize(), 0);
     EXPECT_EQ(mAnalyzer->getLostPacketSize(), 0);
 
-    CallQuality quality2 = mFakeCallback.getCallQuality();
-    EXPECT_EQ(quality2, quality);
-    EXPECT_EQ(quality2.getNumRtpPacketsNotReceived(), 1);
+    EXPECT_EQ(mFakeCallback.getCallQuality().getNumRtpPacketsNotReceived(), 1);
 
     MediaQualityStatus status = mFakeCallback.getMediaQualityStatus();
     EXPECT_EQ(status.getRtpPacketLossRate(), 10);
@@ -502,6 +523,5 @@ TEST_F(MediaQualityAnalyzerTest, TestNotifyMediaQualityStatus)
     mAnalyzer->start();
 
     mCondition.wait_timeout(2100);  // 2.1 sec
-
     mAnalyzer->stop();
 }
\ No newline at end of file
diff --git a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/nodes/RtpDecoderNodeTests.cpp b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/nodes/RtpDecoderNodeTests.cpp
index dfa293e7..90c23056 100644
--- a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/nodes/RtpDecoderNodeTests.cpp
+++ b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/nodes/RtpDecoderNodeTests.cpp
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2023 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -89,8 +89,15 @@ public:
     {
         dtmfDigit = 0;
         dtmfDuration = 0;
+        listExtensions = nullptr;
+    }
+    virtual ~FakeRtpDecoderCallback()
+    {
+        if (listExtensions != nullptr)
+        {
+            delete listExtensions;
+        }
     }
-    virtual ~FakeRtpDecoderCallback() {}
     virtual void onEvent(int32_t type, uint64_t param1, uint64_t param2)
     {
         if (type == kAudioDtmfReceivedInd)
@@ -98,13 +105,24 @@ public:
             dtmfDigit = static_cast<uint8_t>(param1);
             dtmfDuration = static_cast<uint32_t>(param2);
         }
+        else if (type == kImsMediaEventHeaderExtensionReceived)
+        {
+            if (listExtensions != nullptr)
+            {
+                delete listExtensions;
+            }
+
+            listExtensions = reinterpret_cast<std::list<RtpHeaderExtension>*>(param1);
+        }
     }
     uint8_t GetDtmfDigit() { return dtmfDigit; }
     uint32_t GetDtmfDuration() { return dtmfDuration; }
+    std::list<RtpHeaderExtension>* GetListExtension() { return listExtensions; }
 
 private:
     uint8_t dtmfDigit;
     uint32_t dtmfDuration;
+    std::list<RtpHeaderExtension>* listExtensions;
 };
 
 class FakeRtpDecoderNode : public BaseNode
@@ -370,6 +388,46 @@ TEST_F(RtpDecoderNodeTest, testAudioDtmfDataProcess)
     EXPECT_EQ(callback.GetDtmfDuration(), 100);
 }
 
+TEST_F(RtpDecoderNodeTest, testAudioRtpExtension)
+{
+    setupAudioConfig();
+    EXPECT_EQ(encoder->Start(), RESULT_SUCCESS);
+    EXPECT_EQ(decoder->Start(), RESULT_SUCCESS);
+
+    // AMR mode 6 payload frame
+    uint8_t testFrame[] = {0x1c, 0x51, 0x06, 0x40, 0x32, 0xba, 0x8e, 0xc1, 0x25, 0x42, 0x2f, 0xc7,
+            0xaf, 0x6e, 0xe0, 0xbb, 0xb2, 0x91, 0x09, 0xa5, 0xa6, 0x08, 0x18, 0x6f, 0x08, 0x1c,
+            0x1c, 0x44, 0xd8, 0xe0, 0x48, 0x8c, 0x7c, 0xf8, 0x4c, 0x22, 0xd0};
+
+    const uint8_t testExtension1[] = {0xFF, 0xF2};
+    const uint8_t testExtension2[] = {0xFF, 0xF2};
+
+    std::list<RtpHeaderExtension> listExtension;
+
+    RtpHeaderExtension extension1;
+    extension1.setLocalIdentifier(1);
+    extension1.setExtensionData(testExtension1, 2);
+    listExtension.push_back(extension1);
+
+    RtpHeaderExtension extension2;
+    extension2.setLocalIdentifier(2);
+    extension2.setExtensionData(testExtension2, 2);
+    listExtension.push_back(extension2);
+
+    encoder->SetRtpHeaderExtension(&listExtension);
+    encoder->OnDataFromFrontNode(MEDIASUBTYPE_UNDEFINED, testFrame, sizeof(testFrame), 0, false, 0);
+    encoder->ProcessData();
+
+    std::list<RtpHeaderExtension>* receivedExtension = callback.GetListExtension();
+    ASSERT_TRUE(receivedExtension != nullptr);
+
+    for (auto& extension : *receivedExtension)
+    {
+        EXPECT_EQ(extension, listExtension.front());
+        listExtension.pop_front();
+    }
+}
+
 TEST_F(RtpDecoderNodeTest, startVideoAndUpdate)
 {
     setupVideoConfig();
diff --git a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/protocol/rtp/core/RtpPacketTest.cpp b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/protocol/rtp/core/RtpPacketTest.cpp
index 17c758cb..319a2fe0 100644
--- a/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/protocol/rtp/core/RtpPacketTest.cpp
+++ b/tests/native/service/src/com/android/telephony/imsmedia/lib/libimsmedia/protocol/rtp/core/RtpPacketTest.cpp
@@ -90,7 +90,7 @@ TEST(RtpPacketTest, TestDecodePacket)
     RtpBuffer* pobjRtpExtHdr = rtpPacket.getExtHeader();
     ASSERT_TRUE(pobjRtpExtHdr != nullptr);
 
-    uint8_t pRtpExtHdr[] = {0x41, 0x78, 0x42, 0x00};
+    uint8_t pRtpExtHdr[] = {0xbe, 0xde, 0x00, 0x01, 0x41, 0x78, 0x42, 0x00};
 
     EXPECT_EQ(memcmp(pRtpExtHdr, pobjRtpExtHdr->getBuffer(), sizeof(pRtpExtHdr)), 0);
     EXPECT_EQ(pobjRtpExtHdr->getLength(), sizeof(pRtpExtHdr));