diff --git a/camera/QCamera2/HAL3/QCamera3Channel.cpp b/camera/QCamera2/HAL3/QCamera3Channel.cpp
index 781fa88..52acc1c 100644
--- a/camera/QCamera2/HAL3/QCamera3Channel.cpp
+++ b/camera/QCamera2/HAL3/QCamera3Channel.cpp
@@ -1801,11 +1801,68 @@
     return QCamera3RegularChannel::initialize(isType);
 }
 
+#define GET_RAW_PIXEL(row_start,j) (row_start[5*(j/4)+j%4]<<2|((row_start[5*(j/4)+4]>>(j%4))&0x03))
+static void calculateBlacklevelForRaw10(mm_camera_buf_def_t *frame,
+    uint32_t stridebytes,
+    float (&fwk_blacklevel)[4],
+    int32_t opticalBlackRegions[4]){
+
+    int32_t left   = opticalBlackRegions[0];
+    int32_t right  = opticalBlackRegions[2];
+    int32_t top    = opticalBlackRegions[1];
+    int32_t bottom = opticalBlackRegions[3];
+    int32_t count  = 0;
+
+    fwk_blacklevel[0] = 0.0;
+    fwk_blacklevel[1] = 0.0;
+    fwk_blacklevel[2] = 0.0;
+    fwk_blacklevel[3] = 0.0;
+
+    for(int32_t i = top ; i < bottom ; i += 2){
+        uint8_t* row_start = (uint8_t *)frame->buffer + i * stridebytes;
+        for(int32_t j = left ; j < right ; j += 2){
+            count++;
+            fwk_blacklevel[0] += GET_RAW_PIXEL(row_start,j);
+            fwk_blacklevel[1] += GET_RAW_PIXEL(row_start,(j+1));
+            fwk_blacklevel[2] += GET_RAW_PIXEL((row_start+stridebytes),j);
+            fwk_blacklevel[3] += GET_RAW_PIXEL((row_start+stridebytes),(j+1));
+        }
+    }
+    fwk_blacklevel[0] = fwk_blacklevel[0]/count;
+    fwk_blacklevel[1] = fwk_blacklevel[1]/count;
+    fwk_blacklevel[2] = fwk_blacklevel[2]/count;
+    fwk_blacklevel[3] = fwk_blacklevel[3]/count;
+}
+
 void QCamera3RawChannel::streamCbRoutine(
                         mm_camera_super_buf_t *super_frame,
                         QCamera3Stream * stream)
 {
     ATRACE_CALL();
+    CDBG("%s, E.", __func__);
+    QCamera3HardwareInterface* hw = (QCamera3HardwareInterface*)mUserData;
+    int32_t opticalBlackRegions[4];
+
+    if (mIsRaw16 && hw->getBlackLevelRegion(opticalBlackRegions) == true) {
+        if (RAW_FORMAT == CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GBRG) {
+            QCamera3HardwareInterface* hw = (QCamera3HardwareInterface*)mUserData;
+            uint32_t frame_number = 0;
+            float dynamic_blacklevel[4] = {0.0, 0.0, 0.0, 0.0};
+
+            cam_frame_len_offset_t offset;
+            memset(&offset, 0, sizeof(cam_frame_len_offset_t));
+            stream->getFrameOffset(offset);
+            calculateBlacklevelForRaw10(super_frame->bufs[0],(uint32_t)offset.mp[0].stride_in_bytes,
+                dynamic_blacklevel, opticalBlackRegions);
+            frame_number = mMemory.getFrameNumber((uint8_t)super_frame->bufs[0]->buf_idx);
+            CDBG("%s, frame_number:%d, dynamic black level (%f, %f, %f, %f)",
+                __func__, frame_number,
+                dynamic_blacklevel[0], dynamic_blacklevel[1],
+                dynamic_blacklevel[2], dynamic_blacklevel[3]);
+            hw->sendDynamicBlackLevel(dynamic_blacklevel, frame_number);
+        }
+    }
+
     /* Move this back down once verified */
     if (mRawDump)
         dumpRawSnapshot(super_frame->bufs[0]);
diff --git a/camera/QCamera2/HAL3/QCamera3HWI.cpp b/camera/QCamera2/HAL3/QCamera3HWI.cpp
index 34fed36..59ef87b 100644
--- a/camera/QCamera2/HAL3/QCamera3HWI.cpp
+++ b/camera/QCamera2/HAL3/QCamera3HWI.cpp
@@ -58,7 +58,7 @@
 #define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX )
 
 #define EMPTY_PIPELINE_DELAY 2
-#define PARTIAL_RESULT_COUNT 2
+#define PARTIAL_RESULT_COUNT 3
 #define FRAME_SKIP_DELAY     0
 #define CAM_MAX_SYNC_LATENCY 4
 
@@ -2423,6 +2423,7 @@
     int32_t frame_number_valid, urgent_frame_number_valid;
     uint32_t frame_number, urgent_frame_number;
     int64_t capture_time;
+    bool unfinished_raw_request = false;
 
     int32_t *p_frame_number_valid =
             POINTER_OF_META(CAM_INTF_META_FRAME_NUMBER_VALID, metadata);
@@ -2516,8 +2517,6 @@
         memset(&result, 0, sizeof(camera3_capture_result_t));
 
         CDBG("%s: frame_number in the list is %u", __func__, i->frame_number);
-        i->partial_result_cnt++;
-        result.partial_result = i->partial_result_cnt;
 
         // Check whether any stream buffer corresponding to this is dropped or not
         // If dropped, then send the ERROR_BUFFER for the corresponding stream
@@ -2562,6 +2561,20 @@
                 /* this will be handled in handleInputBufferWithLock */
                 i++;
                 continue;
+            } else if (i->need_dynamic_blklvl) {
+                unfinished_raw_request = true;
+                // i->partial_result_cnt--;
+                CDBG("%s, frame number:%d, partial_result:%d, unfinished raw request..",
+                        __func__, i->frame_number, i->partial_result_cnt);
+                i++;
+                continue;
+            } else if (i->pending_extra_result) {
+                CDBG("%s, frame_number:%d, partial_result:%d, need_dynamic_blklvl:%d",
+                        __func__, i->frame_number, i->partial_result_cnt,
+                        i->need_dynamic_blklvl);
+                // i->partial_result_cnt--;
+                i++;
+                continue;
             } else {
                 ALOGE("%s: Fatal: Missing metadata buffer for frame number %d", __func__, i->frame_number);
                 if (free_and_bufdone_meta_buf) {
@@ -2576,7 +2589,22 @@
                 goto done_metadata;
             }
         } else {
-            mPendingLiveRequest--;
+            i->partial_result_cnt++;
+            CDBG("%s, frame_number:%d, need_dynamic_blklvl:%d, partial cnt:%d\n",
+                    __func__, i->frame_number, i->need_dynamic_blklvl,
+                    i->partial_result_cnt);
+            if (!i->need_dynamic_blklvl) {
+                CDBG("%s, meta for request without raw, frame number: %d\n",
+                        __func__, i->frame_number);
+                if (!unfinished_raw_request) {
+                    i->partial_result_cnt++;
+                    CDBG("%s, no raw request pending, send the final (cnt:%d) partial result",
+                            __func__, i->partial_result_cnt);
+                }
+            }
+
+            result.partial_result = i->partial_result_cnt;
+
             /* Clear notify_msg structure */
             camera3_notify_msg_t notify_msg;
             memset(&notify_msg, 0, sizeof(camera3_notify_msg_t));
@@ -2607,7 +2635,7 @@
 
             result.result = translateFromHalMetadata(metadata,
                     i->timestamp, i->request_id, i->jpegMetadata, i->pipeline_depth,
-                    i->capture_intent, i->hybrid_ae_enable, internalPproc);
+                    i->capture_intent, i->hybrid_ae_enable, internalPproc, i->need_dynamic_blklvl);
 
             saveExifParams(metadata);
 
@@ -2694,22 +2722,31 @@
             }
             result.output_buffers = result_buffers;
             mCallbackOps->process_capture_result(mCallbackOps, &result);
-            CDBG("%s %d: meta frame_number = %u, capture_time = %lld",
-                    __func__, __LINE__, result.frame_number, i->timestamp);
+            CDBG("%s %d: meta frame_number = %u, capture_time = %lld, partial:%d",
+                    __func__, __LINE__, result.frame_number, i->timestamp, result.partial_result);
             free_camera_metadata((camera_metadata_t *)result.result);
             delete[] result_buffers;
         } else {
             mCallbackOps->process_capture_result(mCallbackOps, &result);
-            CDBG("%s %d: meta frame_number = %u, capture_time = %lld",
-                        __func__, __LINE__, result.frame_number, i->timestamp);
+            CDBG("%s %d: meta frame_number = %u, capture_time = %lld, partial:%d",
+                        __func__, __LINE__, result.frame_number, i->timestamp, result.partial_result);
             free_camera_metadata((camera_metadata_t *)result.result);
         }
 
-        i = erasePendingRequest(i);
+        if (i->partial_result_cnt == PARTIAL_RESULT_COUNT) {
+            mPendingLiveRequest--;
+            i = erasePendingRequest(i);
+        } else {
+            CDBG("%s, keep in list, frame number:%d, partial result:%d",
+                    __func__, i->frame_number, i->partial_result_cnt);
+            i->pending_extra_result = true;
+            i++;
+        }
 
         if (!mPendingReprocessResultList.empty()) {
             handlePendingReprocResults(frame_number + 1);
         }
+
     }
 
 done_metadata:
@@ -2830,6 +2867,104 @@
     }
 }
 
+bool QCamera3HardwareInterface::getBlackLevelRegion(int (&opticalBlackRegions)[4])
+{
+    if (gCamCapability[mCameraId]->optical_black_region_count > 0) {
+        /*just calculate one region black level and send to fwk*/
+        for (size_t i = 0; i <  4; i++) {
+            opticalBlackRegions[i] = gCamCapability[mCameraId]->optical_black_regions[i];
+        }
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+void QCamera3HardwareInterface::sendDynamicBlackLevel(float blacklevel[4], uint32_t frame_number)
+{
+    CDBG("%s, E.\n", __func__);
+    pthread_mutex_lock(&mMutex);
+    sendDynamicBlackLevelWithLock(blacklevel, frame_number);
+    pthread_mutex_unlock(&mMutex);
+    CDBG("%s, X.\n", __func__);
+}
+
+void QCamera3HardwareInterface::sendDynamicBlackLevelWithLock(float blacklevel[4], uint32_t frame_number)
+{
+    CDBG("%s, E. frame_number:%d\n", __func__, frame_number);
+
+    pendingRequestIterator i = mPendingRequestsList.begin();
+    while (i != mPendingRequestsList.end() && i->frame_number != frame_number){
+        i++;
+    }
+    if ((i == mPendingRequestsList.end()) || !i->need_dynamic_blklvl) {
+        ALOGE("%s, error: invalid frame number.", __func__);
+        return;
+    }
+
+    i->partial_result_cnt++;
+
+    CameraMetadata camMetadata;
+    int64_t fwk_frame_number = (int64_t)frame_number;
+    camMetadata.update(ANDROID_SYNC_FRAME_NUMBER, &fwk_frame_number, 1);
+
+    // update dynamic black level here
+    camMetadata.update(ANDROID_SENSOR_DYNAMIC_BLACK_LEVEL, blacklevel, 4);
+
+    camera3_capture_result_t result;
+    memset(&result, 0, sizeof(camera3_capture_result_t));
+    result.frame_number = frame_number;
+    result.num_output_buffers = 0;
+    result.result = camMetadata.release();
+    result.partial_result = i->partial_result_cnt;
+
+    CDBG("%s, partial result:%d, frame_number:%d, pending extra result:%d\n",
+            __func__, result.partial_result, frame_number, i->pending_extra_result);
+    mCallbackOps->process_capture_result(mCallbackOps, &result);
+    free_camera_metadata((camera_metadata_t *)result.result);
+
+    if (i->partial_result_cnt == PARTIAL_RESULT_COUNT) {
+        CDBG("%s, remove cur request from pending list.", __func__);
+        mPendingLiveRequest--;
+        i = erasePendingRequest(i);
+
+        // traverse the remaining pending list to see whether need to send cached ones..
+        while (i != mPendingRequestsList.end()) {
+            CDBG("%s, frame number:%d, partial_result:%d, pending extra result:%d",
+                    __func__, i->frame_number, i->partial_result_cnt,
+                    i->pending_extra_result);
+
+            if ((i->partial_result_cnt == PARTIAL_RESULT_COUNT - 1)
+                    && (i->need_dynamic_blklvl == false) /* in case two consecutive raw requests */) {
+                // send out final result, and remove it from pending list.
+                CameraMetadata camMetadata;
+                int64_t fwk_frame_number = (int64_t)i->frame_number;
+                camMetadata.update(ANDROID_SYNC_FRAME_NUMBER, &fwk_frame_number, 1);
+
+                memset(&result, 0, sizeof(camera3_capture_result_t));
+                result.frame_number = i->frame_number;
+                result.num_output_buffers = 0;
+                result.result = camMetadata.release();
+                result.partial_result = i->partial_result_cnt + 1;
+
+                mCallbackOps->process_capture_result(mCallbackOps, &result);
+                free_camera_metadata((camera_metadata_t *)result.result);
+
+                mPendingLiveRequest--;
+                i = erasePendingRequest(i);
+                CDBG("%s, mPendingLiveRequest:%d, pending list size:%d",
+                        __func__, mPendingLiveRequest, mPendingRequestsList.size());
+            } else {
+                break;
+            }
+        }
+    }
+
+    unblockRequestIfNecessary();
+    CDBG("%s, X.mPendingLiveRequest = %d\n", __func__, mPendingLiveRequest);
+}
+
+
 /*===========================================================================
  * FUNCTION   : handleBufferWithLock
  *
@@ -2852,7 +2987,14 @@
     while (i != mPendingRequestsList.end() && i->frame_number != frame_number){
         i++;
     }
-    if (i == mPendingRequestsList.end()) {
+    if (i == mPendingRequestsList.end() || i->pending_extra_result == true) {
+        if (i != mPendingRequestsList.end()) {
+            // though the pendingRequestInfo is still in the list,
+            // still send the buffer directly, as the pending_extra_result is true,
+            // and we've already received meta for this frame number.
+            CDBG("%s, send the buffer directly, frame number:%d",
+                    __func__, i->frame_number);
+        }
         // Verify all pending requests frame_numbers are greater
         for (pendingRequestIterator j = mPendingRequestsList.begin();
                 j != mPendingRequestsList.end(); j++) {
@@ -3498,6 +3640,8 @@
     pendingRequest.jpegMetadata = mCurJpegMeta;
     pendingRequest.settings = saveRequestSettings(mCurJpegMeta, request);
     pendingRequest.shutter_notified = false;
+    pendingRequest.need_dynamic_blklvl = false;
+    pendingRequest.pending_extra_result = false;
 
     //extract capture intent
     if (meta.exists(ANDROID_CONTROL_CAPTURE_INTENT)) {
@@ -3529,6 +3673,13 @@
         CDBG("%s: frame = %d, buffer = %p, streamTypeMask = %d, stream format = %d",
                 __func__, frameNumber, bufferInfo.buffer,
                 channel->getStreamTypeMask(), bufferInfo.stream->format);
+
+        if (bufferInfo.stream->format == HAL_PIXEL_FORMAT_RAW16) {
+            if (gCamCapability[mCameraId]->optical_black_region_count > 0) {
+                CDBG("%s, frame_number:%d, need dynamic blacklevel", __func__, frameNumber);
+                pendingRequest.need_dynamic_blklvl = true;
+            }
+        }
     }
     mPendingBuffersMap.last_frame_number = frameNumber;
     latestRequest = mPendingRequestsList.insert(
@@ -4045,7 +4196,8 @@
                                  uint8_t pipeline_depth,
                                  uint8_t capture_intent,
                                  uint8_t hybrid_ae_enable,
-                                 bool pprocDone)
+                                 bool pprocDone,
+                                 bool dynamic_blklvl)
 {
     CameraMetadata camMetadata;
     camera_metadata_t *resultMetadata;
@@ -4201,14 +4353,17 @@
         camMetadata.update(QCAMERA3_SENSOR_DYNAMIC_BLACK_LEVEL_PATTERN, fwk_blackLevelInd, 4);
         camMetadata.update(NEXUS_EXPERIMENTAL_2015_SENSOR_DYNAMIC_BLACK_LEVEL, fwk_blackLevelInd, 4);
 
-        // Update the ANDROID_SENSOR_DYNAMIC_BLACK_LEVEL
-        // Need convert the internal 16 bit depth to sensor 10 bit sensor raw
-        // depth space.
-        fwk_blackLevelInd[0] /= 64.0;
-        fwk_blackLevelInd[1] /= 64.0;
-        fwk_blackLevelInd[2] /= 64.0;
-        fwk_blackLevelInd[3] /= 64.0;
-        camMetadata.update(ANDROID_SENSOR_DYNAMIC_BLACK_LEVEL, fwk_blackLevelInd, 4);
+        // if dynmaic_blklvl is true, we calculate blklvl from raw callback
+        // otherwise, use the value from linearization LUT.
+        if (dynamic_blklvl == false) {
+            // Need convert the internal 16 bit depth to sensor 10 bit sensor raw
+            // depth space.
+            fwk_blackLevelInd[0] /= 64.0;
+            fwk_blackLevelInd[1] /= 64.0;
+            fwk_blackLevelInd[2] /= 64.0;
+            fwk_blackLevelInd[3] /= 64.0;
+            camMetadata.update(ANDROID_SENSOR_DYNAMIC_BLACK_LEVEL, fwk_blackLevelInd, 4);
+        }
     }
 
     // Fixed whitelevel is used by ISP/Sensor
@@ -5759,8 +5914,17 @@
     if (gCamCapability[cameraId]->optical_black_region_count != 0 &&
             gCamCapability[cameraId]->optical_black_region_count <= MAX_OPTICAL_BLACK_REGIONS) {
         int32_t opticalBlackRegions[MAX_OPTICAL_BLACK_REGIONS * 4];
-        for (size_t i = 0; i < gCamCapability[cameraId]->optical_black_region_count * 4; i++) {
+        for (size_t i = 0; i < gCamCapability[cameraId]->optical_black_region_count * 4; i+=4) {
+            // Left
             opticalBlackRegions[i] = gCamCapability[cameraId]->optical_black_regions[i];
+            //Top
+            opticalBlackRegions[i + 1] = gCamCapability[cameraId]->optical_black_regions[i + 1];
+            // Width
+            opticalBlackRegions[i + 2] = gCamCapability[cameraId]->optical_black_regions[i + 2] -
+                    gCamCapability[cameraId]->optical_black_regions[i];
+            // Height
+            opticalBlackRegions[i + 3] = gCamCapability[cameraId]->optical_black_regions[i + 3] -
+                    gCamCapability[cameraId]->optical_black_regions[i + 1];
         }
         staticInfo.update(ANDROID_SENSOR_OPTICAL_BLACK_REGIONS,
                 opticalBlackRegions, gCamCapability[cameraId]->optical_black_region_count * 4);
diff --git a/camera/QCamera2/HAL3/QCamera3HWI.h b/camera/QCamera2/HAL3/QCamera3HWI.h
index ab7a513..0302b05 100644
--- a/camera/QCamera2/HAL3/QCamera3HWI.h
+++ b/camera/QCamera2/HAL3/QCamera3HWI.h
@@ -174,7 +174,7 @@
                             nsecs_t timestamp, int32_t request_id,
                             const CameraMetadata& jpegMetadata, uint8_t pipeline_depth,
                             uint8_t capture_intent, uint8_t hybrid_ae_enable,
-                            bool pprocDone);
+                            bool pprocDone, bool dynamic_blklvl);
     camera_metadata_t* saveRequestSettings(const CameraMetadata& jpegMetadata,
                             camera3_capture_request_t *request);
     int initParameters();
@@ -213,6 +213,9 @@
         cam_cds_mode_type_t val;
     } QCameraPropMap;
 
+    bool getBlackLevelRegion(int (&opticalBlackRegions)[4]);
+    void sendDynamicBlackLevel(float blacklevel[4], uint32_t frame_number);
+    void sendDynamicBlackLevelWithLock(float blacklevel[4], uint32_t frame_number);
 
 private:
 
@@ -344,6 +347,8 @@
         uint8_t capture_intent;
         bool shutter_notified;
         uint8_t hybrid_ae_enable;
+        bool need_dynamic_blklvl;
+        bool pending_extra_result;
     } PendingRequestInfo;
     typedef struct {
         uint32_t frame_number;