diff --git a/media_driver/agnostic/common/codec/hal/codechal_vdenc_avc.cpp b/media_driver/agnostic/common/codec/hal/codechal_vdenc_avc.cpp
index 4be42b4..e45f99e 100644
--- a/media_driver/agnostic/common/codec/hal/codechal_vdenc_avc.cpp
+++ b/media_driver/agnostic/common/codec/hal/codechal_vdenc_avc.cpp
@@ -4576,10 +4576,7 @@
                     break;
                 }
             }
-            if (dqpidx == -1)
-            {
-                return MOS_STATUS_INVALID_PARAMETER;
-            }
+            CODECHAL_ENCODE_CHK_COND_RETURN(dqpidx == -1, "Max number of supported different dQP for ROI is %u", m_maxNumNativeRoi);
 
             uint32_t curX, curY;
             for (curY = picParams->ROI[i].Top; curY < picParams->ROI[i].Bottom; curY++)
@@ -4779,14 +4776,26 @@
 
     MOS_ZeroMemory(pData, m_picHeightInMb * m_picWidthInMb);
 
+
     for (int32_t i = picParams->NumROI - 1; i >= 0; i--)
     {
+        int32_t dqpidx = -1;
+        for (int32_t j = 0; j < m_maxNumBrcRoi; j++)
+        {
+            if (m_avcPicParam->ROIDistinctDeltaQp[j] == m_avcPicParam->ROI[i].PriorityLevelOrDQp)
+            {
+                dqpidx = j;
+                break;
+            }
+        }
+        CODECHAL_ENCODE_CHK_COND_RETURN(dqpidx == -1, "Max number of supported different dQP for ROI is %u", m_maxNumBrcRoi);
+
         uint32_t curX, curY;
         for (curY = picParams->ROI[i].Top; curY < picParams->ROI[i].Bottom; curY++)
         {
             for (curX = picParams->ROI[i].Left; curX < picParams->ROI[i].Right; curX++)
             {
-                *(pData + (m_picWidthInMb * curY + curX)) = i + 1; // Shift ROI by 1
+                *(pData + (m_picWidthInMb * curY + curX)) = dqpidx + 1; // Shift ROI by 1
             }
         }
     }
diff --git a/media_driver/agnostic/common/codec/shared/codec_def_encode_avc.h b/media_driver/agnostic/common/codec/shared/codec_def_encode_avc.h
index 86d2d7b..e9f8ad2 100644
--- a/media_driver/agnostic/common/codec/shared/codec_def_encode_avc.h
+++ b/media_driver/agnostic/common/codec/shared/codec_def_encode_avc.h
@@ -42,7 +42,6 @@
 
 #define ENCODE_VDENC_AVC_MAX_ROI_NUMBER_G9            3        // Max 4  regions including non-ROI - used from DDI
 #define ENCODE_VDENC_AVC_MAX_ROI_NUMBER_ADV          16        // Max 16 regions including non-ROI - used from DDI
-#define ENCODE_VDENC_AVC_MAX_BRC_ROI_NUMBER_ADV       7        // Max 8  regions including non-ROI - used from DDI
 #define ENCODE_VDENC_AVC_MIN_ROI_DELTA_QP_G9         -8        // Min delta QP for VDEnc ROI
 #define ENCODE_VDENC_AVC_MAX_ROI_DELTA_QP_G9          7        // Max delta QP for VDEnc ROI
 
