diff --git a/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/include/video/nodes/IVideoRendererNode.h b/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/include/video/nodes/IVideoRendererNode.h
index caa5432..3e4483e 100644
--- a/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/include/video/nodes/IVideoRendererNode.h
+++ b/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/include/video/nodes/IVideoRendererNode.h
@@ -29,6 +29,16 @@
 #define USE_JITTER_BUFFER  // off this definition ONLY for test purpose.
 #define DEMON_NTP2MSEC 65.55
 
+enum FrameType
+{
+    UNKNOWN,
+    SPS,
+    PPS,
+    VPS,
+    IDR,
+    NonIDR,
+};
+
 /**
  * @brief This class describes an interface between depacketization module and audio device
  */
@@ -69,25 +79,25 @@
     void SetPacketLossParam(uint32_t time, uint32_t rate);
 
 private:
-    bool IsIntraFrame(uint8_t* pbBuffer, uint32_t nBufferSize);
-    bool IsConfigFrame(uint8_t* pbBuffer, uint32_t nBufferSize, uint32_t* nBufferOffset = nullptr);
-    bool IsSps(uint8_t* pbBuffer, uint32_t nBufferSize, uint32_t* nBufferOffset = nullptr);
-    void SaveConfigFrame(uint8_t* pbBuffer, uint32_t nBufferSize, uint32_t type);
+    bool hasStartingCode(uint8_t* buffer, uint32_t bufferSize);
+    FrameType GetFrameType(uint8_t* buffer, uint32_t bufferSize);
+    void SaveConfigFrame(uint8_t* buffer, uint32_t bufferSize, uint32_t type);
+
     /**
      * @brief Remove Access Uint Delimiter Nal Unit.
      *
-     * @param pInBuffer
-     * @param nInBufferSize
-     * @param pOutBuffer
-     * @param pOutBufferSize
+     * @param inBuffer
+     * @param ibufferSize
+     * @param outBuffer
+     * @param outBufferSize
      * @return true
      * @return false
      */
-    bool RemoveAUDNalUnit(uint8_t* pInBuffer, uint32_t nInBufferSize, uint8_t** pOutBuffer,
-            uint32_t* pOutBufferSize);
+    bool RemoveAUDNalUnit(
+            uint8_t* inBuffer, uint32_t ibufferSize, uint8_t** outBuffer, uint32_t* outBufferSize);
     void CheckResolution(uint32_t nWidth, uint32_t nHeight);
-    ImsMediaResult ParseAvcSps(uint8_t* pbBuffer, uint32_t nBufferSize, tCodecConfig* pInfo);
-    ImsMediaResult ParseHevcSps(uint8_t* pbBuffer, uint32_t nBufferSize, tCodecConfig* pInfo);
+    ImsMediaResult ParseAvcSps(uint8_t* buffer, uint32_t bufferSize, tCodecConfig* config);
+    ImsMediaResult ParseHevcSps(uint8_t* buffer, uint32_t bufferSize, tCodecConfig* config);
     void QueueConfigFrame(uint32_t timestamp);
     void NotifyPeerDimensionChanged();
 
@@ -107,7 +117,6 @@
     bool mFirstFrame;
     ImsMediaSubType mSubtype;
     uint32_t mFramerate;
-    uint32_t mWaitIntraFrame;
     uint32_t mLossDuration;
     uint32_t mLossRateThreshold;
 };
diff --git a/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/nodes/RtpEncoderNode.cpp b/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/nodes/RtpEncoderNode.cpp
index 40f3d1a..cd4ca42 100644
--- a/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/nodes/RtpEncoderNode.cpp
+++ b/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/nodes/RtpEncoderNode.cpp
@@ -290,7 +290,7 @@
     IMLOGD3("[SetCvoExtension] cvoValue[%d], facing[%ld], orientation[%ld]", mCvoValue, facing,
             orientation);
 
-    if (mCvoValue != -1)
+    if (mCvoValue > 0)
     {
         uint32_t rotation = 0;
         uint32_t cameraId = 0;
diff --git a/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/ImsMediaVideoUtil.cpp b/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/ImsMediaVideoUtil.cpp
index 817a115..4dea478 100644
--- a/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/ImsMediaVideoUtil.cpp
+++ b/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/ImsMediaVideoUtil.cpp
@@ -590,22 +590,20 @@
 
     ImsMediaBitReader objBitReader;
     objBitReader.SetBuffer(pbBuffer + nOffset, nBufferSize - nOffset);
-    objBitReader.Read(4);  // sps_video_parameter_set_id;
-    uint32_t sps_max_sub_layers_minus1 = objBitReader.Read(3);
-    objBitReader.Read(1);  // sps_temporal_id_nesting_flag;
+    objBitReader.Read(4);                                       // sps_video_parameter_set_id;
+    uint32_t sps_max_sub_layers_minus1 = objBitReader.Read(3);  // 0
+    objBitReader.Read(1);                                       // sps_temporal_id_nesting_flag;
 
-    /*-----------profile_tier_level start-----------------------*/
-    objBitReader.Read(3);  // general_profile_spac, general_tier_flag
-    objBitReader.Read(5);  // general_profile_idc
+    objBitReader.Read(3);                    // general_profile_spac, general_tier_flag
+    pInfo->nProfile = objBitReader.Read(5);  // general_profile_idc
 
-    // skip 13byte - flags, not handle
-    objBitReader.Read(24);
+    // skip 10byte - flags, not handle
     objBitReader.Read(24);
     objBitReader.Read(24);
     objBitReader.Read(24);
     objBitReader.Read(8);
 
-    objBitReader.Read(8);  // general_level_idc
+    pInfo->nLevel = objBitReader.Read(8);  // general_level_idc
 
     uint8_t sub_layer_profile_present_flag[sps_max_sub_layers_minus1];
     uint8_t sub_layer_level_present_flag[sps_max_sub_layers_minus1];
@@ -645,19 +643,15 @@
 
     objBitReader.ReadByUEMode();  // sps_seq_parameter_set_id
 
-    uint32_t chroma_format_idc;
-    chroma_format_idc = objBitReader.ReadByUEMode();
+    uint32_t chroma_format_idc = objBitReader.ReadByUEMode();
 
     if (chroma_format_idc == 3)
     {
         objBitReader.Read(1);  // separate_colour_plane_flag
     }
 
-    int32_t pic_width_in_luma_samples = objBitReader.ReadByUEMode();
-    int32_t pic_height_in_luma_samples = objBitReader.ReadByUEMode();
-
-    pInfo->nWidth = pic_width_in_luma_samples;
-    pInfo->nHeight = pic_height_in_luma_samples;
+    pInfo->nWidth = objBitReader.ReadByUEMode();
+    pInfo->nHeight = objBitReader.ReadByUEMode();
 
     uint8_t conformance_window_flag = objBitReader.Read(1);
 
diff --git a/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/android/ImsMediaVideoRenderer.cpp b/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/android/ImsMediaVideoRenderer.cpp
index a4fe774..475425b 100644
--- a/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/android/ImsMediaVideoRenderer.cpp
+++ b/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/android/ImsMediaVideoRenderer.cpp
@@ -210,10 +210,12 @@
         }
 
         auto index = AMediaCodec_dequeueInputBuffer(mCodec, CODEC_TIMEOUT_NANO);
+
         if (index >= 0)
         {
             size_t bufferSize = 0;
             uint8_t* inputBuffer = AMediaCodec_getInputBuffer(mCodec, index, &bufferSize);
+
             if (inputBuffer != nullptr)
             {
                 FrameData* frame = mFrameDatas.front();
@@ -223,17 +225,8 @@
                         "config[%d]",
                         index, frame->size, frame->timestamp, frame->isConfig);
 
-                media_status_t err;
-                if (frame->isConfig)
-                {
-                    err = AMediaCodec_queueInputBuffer(mCodec, index, 0, frame->size,
-                            frame->timestamp * 1000, AMEDIACODEC_BUFFER_FLAG_CODEC_CONFIG);
-                }
-                else
-                {
-                    err = AMediaCodec_queueInputBuffer(
-                            mCodec, index, 0, frame->size, frame->timestamp * 1000, 0);
-                }
+                media_status_t err = AMediaCodec_queueInputBuffer(
+                        mCodec, index, 0, frame->size, frame->timestamp * 1000, 0);
 
                 if (err != AMEDIA_OK)
                 {
diff --git a/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/nodes/IVideoRendererNode.cpp b/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/nodes/IVideoRendererNode.cpp
index 0f5a158..9cff579 100644
--- a/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/nodes/IVideoRendererNode.cpp
+++ b/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/nodes/IVideoRendererNode.cpp
@@ -53,7 +53,6 @@
     mFirstFrame = false;
     mSubtype = MEDIASUBTYPE_UNDEFINED;
     mFramerate = 0;
-    mWaitIntraFrame = 0;
     mLossDuration = 0;
     mLossRateThreshold = 0;
 }
@@ -162,132 +161,103 @@
 void IVideoRendererNode::ProcessData()
 {
     std::lock_guard<std::mutex> guard(mMutex);
-    uint8_t* pData = nullptr;
-    uint32_t nDataSize = 0;
-    uint32_t nTimeStamp = 0;
-    bool bMark = false;
-    uint32_t nSeqNum = 0;
+    uint8_t* data = nullptr;
+    uint32_t dataSize = 0;
+    uint32_t prevTimestamp = 0;
+    bool mark = false;
+    uint32_t seq = 0;
     uint32_t timestamp = 0;
-    uint32_t nBitstreamSize = 0;
+    uint32_t frameSize = 0;
     ImsMediaSubType subtype = MEDIASUBTYPE_UNDEFINED;
-    uint32_t nInitialSeqNum = 0;
-    uint32_t nBufferOffset = 0;
+    uint32_t initialSeq = 0;
     ImsMediaSubType dataType;
 
-    while (GetData(&subtype, &pData, &nDataSize, &nTimeStamp, &bMark, &nSeqNum, &dataType))
+    while (GetData(&subtype, &data, &dataSize, &timestamp, &mark, &seq, &dataType))
     {
         IMLOGD_PACKET4(IM_PACKET_LOG_VIDEO,
-                "[ProcessData] subtype[%d], Size[%d], TimeStamp[%d] nBitstreamSize[%d]", subtype,
-                nDataSize, nTimeStamp, nBitstreamSize);
+                "[ProcessData] subtype[%d], Size[%d], TS[%d] frameSize[%d]", subtype, dataSize,
+                timestamp, frameSize);
 
-        if (timestamp == 0)
+        if (prevTimestamp == 0)
         {
-            timestamp = nTimeStamp;
+            prevTimestamp = timestamp;
         }
-        else if (timestamp != nTimeStamp)
+        else if (timestamp != prevTimestamp || (frameSize != 0 && hasStartingCode(data, dataSize)))
         {
+            // break when the timestamp is changed or next data has another starting code
             break;
         }
 
-        if (nDataSize >= MAX_RTP_PAYLOAD_BUFFER_SIZE)
+        if (dataSize >= MAX_RTP_PAYLOAD_BUFFER_SIZE)
         {
-            IMLOGE1("[ProcessData] exceed buffer size[%d]", nDataSize);
+            IMLOGE1("[ProcessData] exceed buffer size[%d]", dataSize);
             return;
         }
 
-        memcpy(mBuffer + nBitstreamSize, pData, nDataSize);
-        nBitstreamSize += nDataSize;
+        memcpy(mBuffer + frameSize, data, dataSize);
+        frameSize += dataSize;
 
-        if (nInitialSeqNum == 0)
+        if (initialSeq == 0)
         {
-            nInitialSeqNum = nSeqNum;
+            initialSeq = seq;
         }
 
         DeleteData();
 
-        if (bMark)
+        if (mark)
         {
             break;
         }
     }
 
-    if (nBitstreamSize == 0)
+    if (frameSize == 0)
     {
         return;
     }
 
     // remove AUD nal unit
-    uint32_t nDatabufferSize = nBitstreamSize;
-    uint8_t* pDataBuff = mBuffer;
-    RemoveAUDNalUnit(mBuffer, nBitstreamSize, &pDataBuff, &nDatabufferSize);
+    uint32_t size = frameSize;
+    uint8_t* buffer = mBuffer;
+    RemoveAUDNalUnit(mBuffer, frameSize, &buffer, &size);
 
-    // check Config String for updating config frame
-    nBufferOffset = 0;
-    if ((mCodecType == kVideoCodecHevc || mCodecType == kVideoCodecAvc) &&
-            IsConfigFrame(pDataBuff, nDatabufferSize, &nBufferOffset))
+    FrameType frameType = GetFrameType(buffer, size);
+
+    if (frameType == SPS)
     {
-        SaveConfigFrame(pDataBuff + nBufferOffset, nDatabufferSize - nBufferOffset, kConfigSps);
-        SaveConfigFrame(pDataBuff + nBufferOffset, nDatabufferSize - nBufferOffset, kConfigPps);
+        SaveConfigFrame(buffer, size, kConfigSps);
+        tCodecConfig codecConfig;
 
-        if (mCodecType == kVideoCodecHevc)
+        if (mCodecType == kVideoCodecAvc)
         {
-            SaveConfigFrame(pDataBuff + nBufferOffset, nDatabufferSize - nBufferOffset, kConfigVps);
-        }
-
-        if (IsSps(pDataBuff, nDatabufferSize, &nBufferOffset))
-        {
-            IMLOGD_PACKET1(
-                    IM_PACKET_LOG_VIDEO, "[ProcessData] parse SPS - nOffset[%d]", nBufferOffset);
-            tCodecConfig codecConfig;
-
-            if (mCodecType == kVideoCodecAvc)
+            if (ImsMediaVideoUtil::ParseAvcSps(buffer, size, &codecConfig))
             {
-                if (ImsMediaVideoUtil::ParseAvcSps(pDataBuff + nBufferOffset,
-                            nDatabufferSize - nBufferOffset, &codecConfig))
-                {
-                    CheckResolution(codecConfig.nWidth, codecConfig.nHeight);
-                }
+                CheckResolution(codecConfig.nWidth, codecConfig.nHeight);
             }
-            else if (mCodecType == kVideoCodecHevc)
+        }
+        else if (mCodecType == kVideoCodecHevc)
+        {
+            if (ImsMediaVideoUtil::ParseHevcSps(buffer, size, &codecConfig))
             {
-                if (ImsMediaVideoUtil::ParseHevcSps(pDataBuff + nBufferOffset,
-                            nDatabufferSize - nBufferOffset, &codecConfig))
-                {
-                    CheckResolution(codecConfig.nWidth, codecConfig.nHeight);
-                }
+                CheckResolution(codecConfig.nWidth, codecConfig.nHeight);
             }
         }
 
         return;
     }
-
-    IMLOGD_PACKET2(IM_PACKET_LOG_VIDEO, "[ProcessData] nBitstreamSize[%d] nDatabufferSize[%d]",
-            nBitstreamSize, nDatabufferSize);
-
-    bool isIntraFrame = IsIntraFrame(pDataBuff, nDatabufferSize);
-
-    // drop non-idr frame when idr frame is not received
-    if (mWaitIntraFrame > 0 && nDatabufferSize > 0)
+    else if (frameType == PPS)
     {
-        if (isIntraFrame)
-        {
-            mWaitIntraFrame = 0;
-        }
-        else
-        {
-            // Send FIR when I-frame wasn't received
-            if ((mWaitIntraFrame % mFramerate) == 0)  // every 1 sec
-            {
-                // TODO: send PLI event
-                IMLOGD0("[ProcessData] request Send PLI");
-            }
-
-            mWaitIntraFrame--;
-            nDatabufferSize = 0;  // drop non-DIR frame
-
-            IMLOGD1("[ProcessData] wait intra frame[%d]", mWaitIntraFrame);
-        }
+        SaveConfigFrame(buffer, size, kConfigPps);
+        return;
     }
+    else if (frameType == VPS)
+    {
+        SaveConfigFrame(buffer, size, kConfigVps);
+        return;
+    }
+
+    IMLOGD_PACKET2(IM_PACKET_LOG_VIDEO, "[ProcessData] frame type[%d] size[%d]", frameType, size);
+
+    // TODO: Send PLI or FIR when I-frame wasn't received since beginning.
 
     if (!mFirstFrame)
     {
@@ -297,6 +267,11 @@
         if (mCallback != nullptr)
         {
             mCallback->SendEvent(kImsMediaEventFirstPacketReceived);
+
+            if (mCvoValue <= 0)
+            {
+                mCallback->SendEvent(kImsMediaEventResolutionChanged, mWidth, mHeight);
+            }
         }
     }
 
@@ -336,13 +311,13 @@
         }
     }
 
-    // send sps/pps before send I frame
-    if (isIntraFrame)
+    // send config frames before send I frame
+    if (frameType == IDR)
     {
         QueueConfigFrame(timestamp);
     }
 
-    mVideoRenderer->OnDataFrame(pDataBuff, nDatabufferSize, timestamp, false);
+    mVideoRenderer->OnDataFrame(buffer, size, timestamp, false);
 }
 
 void IVideoRendererNode::UpdateSurface(ANativeWindow* window)
@@ -372,214 +347,84 @@
     mLossRateThreshold = rate;
 }
 
-bool IVideoRendererNode::IsIntraFrame(uint8_t* pbBuffer, uint32_t nBufferSize)
+bool IVideoRendererNode::hasStartingCode(uint8_t* buffer, uint32_t bufferSize)
 {
-    bool bIntraFrame = false;
-
-    if (nBufferSize <= 4)
+    if (bufferSize <= 4)
     {
         return false;
     }
 
-    IMLOGD_PACKET2(IM_PACKET_LOG_VIDEO, "[IsIntraFrame] size[%d], data[%s]", nBufferSize,
-            ImsMediaTrace::IMTrace_Bin2String(
-                    reinterpret_cast<const char*>(pbBuffer), nBufferSize > 16 ? 16 : nBufferSize));
-
-    switch (mCodecType)
+    // Check for NAL unit delimiter 0x00000001
+    if (buffer[0] == 0x00 && buffer[1] == 0x00 && buffer[2] == 0x00 && buffer[3] == 0x01)
     {
-        case kVideoCodecAvc:
-        {
-            uint32_t nCurrSize = nBufferSize;
-            uint8_t* nCurrBuff = pbBuffer;
-
-            while (nCurrSize >= 5)
-            {
-                if (nCurrBuff[0] == 0x00 && nCurrBuff[1] == 0x00 && nCurrBuff[2] == 0x00 &&
-                        nCurrBuff[3] == 0x01 && (nCurrBuff[4] & 0x1F) == 5)
-                {
-                    bIntraFrame = true;
-                    break;
-                }
-                nCurrBuff++;
-                nCurrSize--;
-            }
-
-            break;
-        }
-        case kVideoCodecHevc:
-        {
-            uint32_t nCurrSize = nBufferSize;
-            uint8_t* nCurrBuff = pbBuffer;
-            while (nCurrSize >= 5)
-            {
-                if (nCurrBuff[0] == 0x00 && nCurrBuff[1] == 0x00 && nCurrBuff[2] == 0x00 &&
-                        nCurrBuff[3] == 0x01 &&
-                        (((nCurrBuff[4] >> 1) & 0x3F) == 19 || ((nCurrBuff[4] >> 1) & 0x3F) == 20))
-                {
-                    bIntraFrame = true;
-                    break;
-                }
-                nCurrBuff++;
-                nCurrSize--;
-            }
-            break;
-        }
-        default:
-            IMLOGE1("[IsIntraFrame] Invalid video codec type %d", mCodecType);
-            return true;
+        return true;
     }
 
-    return bIntraFrame;
+    return false;
 }
 
-bool IVideoRendererNode::IsConfigFrame(
-        uint8_t* pbBuffer, uint32_t nBufferSize, uint32_t* nBufferOffset)
+FrameType IVideoRendererNode::GetFrameType(uint8_t* buffer, uint32_t bufferSize)
 {
-    bool bConfigFrame = false;
+    if (!hasStartingCode(buffer, bufferSize))
+    {
+        return UNKNOWN;
+    }
 
-    if (nBufferSize <= 4)
-        return false;
-
-    IMLOGD_PACKET2(IM_PACKET_LOG_VIDEO, "[IsConfigFrame] size[%d], data[%s]", nBufferSize,
-            ImsMediaTrace::IMTrace_Bin2String(
-                    reinterpret_cast<const char*>(pbBuffer), nBufferSize > 16 ? 16 : nBufferSize));
+    uint8_t nalType = buffer[4];
 
     switch (mCodecType)
     {
         case kVideoCodecAvc:
         {
-            uint32_t nOffset = 0;
-            uint32_t nCurrSize = nBufferSize;
-            uint8_t* nCurrBuff = pbBuffer;
-
-            while (nCurrSize >= 5)
+            if ((nalType & 0x1F) == 5)
             {
-                if (nCurrBuff[0] == 0x00 && nCurrBuff[1] == 0x00 && nCurrBuff[2] == 0x00 &&
-                        nCurrBuff[3] == 0x01 &&
-                        ((nCurrBuff[4] & 0x1F) == 7 || ((nCurrBuff[4] & 0x1F) == 8)))
-                {
-                    bConfigFrame = true;
-
-                    if (nBufferOffset)
-                    {
-                        *nBufferOffset = nOffset;
-                    }
-                    break;
-                }
-
-                nOffset++;
-                nCurrBuff++;
-                nCurrSize--;
+                return IDR;
             }
-            break;
-        }
-        case kVideoCodecHevc:
-        {
-            uint32_t nOffset = 0;
-            uint32_t nCurrSize = nBufferSize;
-            uint8_t* nCurrBuff = pbBuffer;
-
-            while (nCurrSize >= 5)
+            else if ((nalType & 0x1F) == 7)
             {
-                if (nCurrBuff[0] == 0x00 && nCurrBuff[1] == 0x00 && nCurrBuff[2] == 0x00 &&
-                        nCurrBuff[3] == 0x01 &&
-                        (((nCurrBuff[4] >> 1) & 0x3F) == 32 || ((nCurrBuff[4] >> 1) & 0x3F) == 33 ||
-                                ((nCurrBuff[4] >> 1) & 0x3F) == 34))
-                {
-                    bConfigFrame = true;
-                    if (nBufferOffset)
-                    {
-                        *nBufferOffset = nOffset;
-                    }
-                    break;
-                }
-                nOffset++;
-                nCurrBuff++;
-                nCurrSize--;
+                return SPS;
             }
-            break;
-        }
-        default:
-            return false;
-    }
-
-    return bConfigFrame;
-}
-
-bool IVideoRendererNode::IsSps(uint8_t* pbBuffer, uint32_t nBufferSize, uint32_t* nBufferOffset)
-{
-    bool bSPS = false;
-    if (nBufferSize <= 4)
-    {
-        return false;
-    }
-
-    IMLOGD_PACKET2(IM_PACKET_LOG_VIDEO, "[IsSps] size[%d], data[%s]", nBufferSize,
-            ImsMediaTrace::IMTrace_Bin2String(
-                    reinterpret_cast<const char*>(pbBuffer), nBufferSize > 16 ? 16 : nBufferSize));
-
-    switch (mCodecType)
-    {
-        case kVideoCodecAvc:
-        {
-            uint32_t nOffset = 0;
-            uint32_t nCurrSize = nBufferSize;
-            uint8_t* nCurrBuff = pbBuffer;
-
-            while (nCurrSize >= 5)
+            else if ((nalType & 0x1F) == 8)
             {
-                if (nCurrBuff[0] == 0x00 && nCurrBuff[1] == 0x00 && nCurrBuff[2] == 0x00 &&
-                        nCurrBuff[3] == 0x01 && (nCurrBuff[4] & 0x1F) == 7)
-                {
-                    bSPS = true;
-
-                    if (nBufferOffset)
-                    {
-                        *nBufferOffset = nOffset;
-                    }
-
-                    break;
-                }
-
-                nOffset++;
-                nCurrBuff++;
-                nCurrSize--;
+                return PPS;
+            }
+            else
+            {
+                return NonIDR;
             }
 
             break;
         }
         case kVideoCodecHevc:
         {
-            uint32_t nOffset = 0;
-            uint32_t nCurrSize = nBufferSize;
-            uint8_t* nCurrBuff = pbBuffer;
-
-            while (nCurrSize >= 5)
+            if (((nalType >> 1) & 0x3F) == 19 || ((nalType >> 1) & 0x3F) == 20)
             {
-                if (nCurrBuff[0] == 0x00 && nCurrBuff[1] == 0x00 && nCurrBuff[2] == 0x00 &&
-                        nCurrBuff[3] == 0x01 && ((nCurrBuff[4] >> 1) & 0x3F) == 33)
-                {
-                    bSPS = true;
-
-                    if (nBufferOffset)
-                    {
-                        *nBufferOffset = nOffset;
-                    }
-
-                    break;
-                }
-
-                nOffset++;
-                nCurrBuff++;
-                nCurrSize--;
+                return IDR;
             }
+            else if (((nalType >> 1) & 0x3F) == 32)
+            {
+                return VPS;
+            }
+            else if (((nalType >> 1) & 0x3F) == 33)
+            {
+                return SPS;
+            }
+            else if (((nalType >> 1) & 0x3F) == 34)
+            {
+                return PPS;
+            }
+            else
+            {
+                return NonIDR;
+            }
+
             break;
         }
         default:
-            return false;
+            IMLOGE1("[GetFrameType] Invalid video codec type %d", mCodecType);
     }
 
-    return bSPS;
+    return UNKNOWN;
 }
 
 void IVideoRendererNode::SaveConfigFrame(uint8_t* pbBuffer, uint32_t nBufferSize, uint32_t eMode)
@@ -761,13 +606,13 @@
 }
 
 bool IVideoRendererNode::RemoveAUDNalUnit(
-        uint8_t* pInBuffer, uint32_t nInBufferSize, uint8_t** ppOutBuffer, uint32_t* pOutBufferSize)
+        uint8_t* inBuffer, uint32_t inBufferSize, uint8_t** outBuffer, uint32_t* outBufferSize)
 {
-    bool bAUDUnit = false;
-    *ppOutBuffer = pInBuffer;
-    *pOutBufferSize = nInBufferSize;
+    bool IsAudUnit = false;
+    *outBuffer = inBuffer;
+    *outBufferSize = inBufferSize;
 
-    if (nInBufferSize <= 4)
+    if (inBufferSize <= 4)
     {
         return false;
     }
@@ -776,29 +621,29 @@
     {
         case kVideoCodecAvc:
         {
-            uint32_t nCurrSize = nInBufferSize;
-            uint8_t* nCurrBuff = pInBuffer;
-            uint32_t nCnt = 0;
+            uint32_t currSize = inBufferSize;
+            uint8_t* currBuffer = inBuffer;
+            uint32_t count = 0;
 
-            while (nCurrSize >= 5 && nCnt <= 12)
+            while (currSize >= 5 && count <= 12)
             {
-                if (bAUDUnit &&
-                        (nCurrBuff[0] == 0x00 && nCurrBuff[1] == 0x00 && nCurrBuff[2] == 0x00 &&
-                                nCurrBuff[3] == 0x01))
+                if (IsAudUnit &&
+                        (currBuffer[0] == 0x00 && currBuffer[1] == 0x00 && currBuffer[2] == 0x00 &&
+                                currBuffer[3] == 0x01))
                 {
-                    *ppOutBuffer = nCurrBuff;
-                    *pOutBufferSize = nCurrSize;
+                    *outBuffer = currBuffer;
+                    *outBufferSize = currSize;
                     break;
                 }
-                if (nCurrBuff[0] == 0x00 && nCurrBuff[1] == 0x00 && nCurrBuff[2] == 0x00 &&
-                        nCurrBuff[3] == 0x01 && nCurrBuff[4] == 0x09)
+                if (currBuffer[0] == 0x00 && currBuffer[1] == 0x00 && currBuffer[2] == 0x00 &&
+                        currBuffer[3] == 0x01 && currBuffer[4] == 0x09)
                 {
-                    bAUDUnit = true;
+                    IsAudUnit = true;
                 }
 
-                nCurrBuff++;
-                nCurrSize--;
-                nCnt++;
+                currBuffer++;
+                currSize--;
+                count++;
             }
         }
         break;
@@ -807,7 +652,7 @@
             return false;
     }
 
-    return bAUDUnit;
+    return IsAudUnit;
 }
 
 void IVideoRendererNode::CheckResolution(uint32_t nWidth, uint32_t nHeight)
@@ -837,16 +682,16 @@
 
     for (int32_t i = 0; i < nNumOfConfigString; i++)
     {
-        uint8_t* pConfigData = nullptr;
-        uint32_t nConfigLen = mConfigLen[i];
-        pConfigData = mConfigBuffer[i];
+        uint8_t* configFrame = nullptr;
+        uint32_t configLen = mConfigLen[i];
+        configFrame = mConfigBuffer[i];
 
-        if (nConfigLen == 0 || mVideoRenderer == nullptr)
+        if (configLen == 0 || mVideoRenderer == nullptr)
         {
             continue;
         }
 
-        mVideoRenderer->OnDataFrame(pConfigData, nConfigLen, timestamp, true);
+        mVideoRenderer->OnDataFrame(configFrame, configLen, timestamp, true);
     }
 }
 
@@ -857,6 +702,8 @@
         return;
     }
 
+    IMLOGD1("[NotifyPeerDimensionChanged] subtype[%d]", mSubtype);
+
     // assume the device is portrait
     if (mWidth > mHeight)  // landscape
     {
diff --git a/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/nodes/VideoRtpPayloadEncoderNode.cpp b/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/nodes/VideoRtpPayloadEncoderNode.cpp
index 6ec6a3c..e601c16 100644
--- a/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/nodes/VideoRtpPayloadEncoderNode.cpp
+++ b/service/src/com/android/telephony/imsmedia/lib/libimsmedia/core/video/nodes/VideoRtpPayloadEncoderNode.cpp
@@ -502,7 +502,7 @@
             memset(mPPS, 0, MAX_CONFIG_LEN);
             memcpy(mPPS, pCurDataPos, nCurDataSize);
             mPpsSize = nCurDataSize;
-            IMLOGD1("[EncodeHevc] PPS Size [%d]", mSpsSize);
+            IMLOGD1("[EncodeHevc] PPS Size [%d]", mPpsSize);
         }
 
         if (nDataSize < nCurDataSize + 4)